Curso_Docker

Vista previa del material en texto

UNIVERSIDAD TECNOLÓGICA DE PANAMÁ 
 
FACULTAD DE INGENIERIA DE SISTEMAS COMPUTACIONALES 
 
Departamento de Arquitectura y Redes de Computadoras 
 
 
 
 
MANUAL DE DOCKER 
(Instalación y Desarrollo de Proyectos) 
 
 
 
 
 
 
 
 
 
 
 
 
 
Elaborado por: 
 
Dr. Armando Jipsion 
 
 
 2017 
 
 
 
 
 
 
Última modificación, marzo de 2023 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 2	
INTRODUCCIÓN 
 
Docker es un proyecto de código abierto que automatiza el despliegue de aplicaciones 
dentro de contenedores de software, proporcionando una capa adicional de abstracción y 
automatización de Virtualización a nivel de sistema operativo en Linux1. 
 
Este manual es el apoyo para el curso presencial pero también se puede utilizar para llevar 
el curso en línea. El curso está dirigido a todo personal informático que necesite trabajar 
con plataformas de software y requieren una implementación rápida de las mismas. 
 
El manual cubre desde la instalación, pasando por todos los comandos para la 
implementación y desarrollo de contenedores, a la implementación de clusters basados en 
contenedores. 
 
Se ha utilizado la información de varios manuales, libros y videos tutoriales2, muchos de 
los cuales son traducciones no oficiales, para hacer este manual lo más actualizado a la 
fecha. Se desea ir actualizando con el transcurso del tiempo y con los nuevos comandos 
que ofrezcan las nuevas versiones de Docker. 
 
Los ejemplos se van a basar en las instalaciones de Docker tanto en Linux, Windows y 
MAC. Se harán los señalamientos específicos de los sistemas operativos cuando sea 
necesario, ya que los comandos de Docker trabajan de igual manera en cualquier sistema 
operativo a no ser de alguna directriz propia del mismo. 
 
La distribución es completamente gratis para todos los cursos que quieran utilizarlo. Su 
uso es estrictamente académico. Básicamente lo estamos publicando bajo una licencia 
GPL (General Public License), de tal forma que se registraría bajo la Creative Commons 
(CC BY-NC-SA). 
 
Esperamos que este manual sea ampliamente utilizado y que el mismo sea una guía puntual 
para trabajar en el mundo de los contenedores. 
 
 
 
 
 
 
 
 
1	https://es.wikipedia.org/wiki/Docker_(software)	
2	Las	referencias	aparecen	en	los	capítulos	y	en	la	bibliografía	del	curso	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 3	
 
INDICE 
 
INTRODUCCIÓN	..........................................................................................................................................	2	
INDICE	...........................................................................................................................................................	3	
1.	 ¿QUÉ	ES	DOCKER?	............................................................................................................................	5	
2.	 INSTALACIÓN	DE	DOCKER	............................................................................................................	7	
2.1	 INSTALACIÓN	DE	DOCKER	EN	WINDOWS	..................................................................................................	7	
2.2	 INSTALACIÓN	DOCKER	EN	MAC	...............................................................................................................	13	
2.3	 INSTALACIÓN	DE	DOCKER	EN	LINUX	UBUNTU	22.04	.........................................................................	16	
3.	 EJECUTANDO	LA	PRIMERA	IMAGEN	Y	EL	PRIMER	CONTENEDOR	.................................	18	
3.1											IMÁGENES	Y	CONTENEDORES	...................................................................................................................	18	
3.2	 EJECUCIÓN	DE	LA	PRIMERA	IMAGEN.	......................................................................................................	20	
3.3	 TRABAJANDO	CON	UN	CONTENEDOR	INTERACTIVO	.............................................................................	23	
3.4	 CONSTRUYENDO	UNA	IMAGEN	DESDE	UN	CONTENEDOR	.....................................................................	26	
4.	 CONSTRUCCIÓN	DE	IMÁGENES	..................................................................................................	28	
4.1	 SISTEMA	DE	CONSTRUCCIÓN	DE	IMAGEN	INTEGRADA	DE	DOCKER	...................................................	28	
4.2	 SINTAXIS	PARA	ESCRIBIR	UN	DOCKERFILE	............................................................................................	31	
4.3	 CONSTRUCCIÓN	DE	INSTRUCCIONES	EN	EL	DOCKERFILE	....................................................................	31	
4.4	 LABORATORIOS	...........................................................................................................................................	41	
5.	 PUBLICACIÓN	DE	IMÁGENES	......................................................................................................	46	
5.1	 ENTENDIENDO	EL	DOCKER	HUB	..............................................................................................................	46	
5.2	 EMPUJANDO	IMÁGENES	AL	DOCKER	HUB	..............................................................................................	48	
5.3	 REPOSITORIOS	PRIVADOS	LOCALES	........................................................................................................	52	
6.	 TRABAJANDO	CON	CONTENEDORES	........................................................................................	54	
6.1	 EJECUTAR	O	CREAR	UN	NUEVO	CONTENEDOR	.......................................................................................	54	
6.2	 COMANDO	VERSION	....................................................................................................................................	55	
6.3	 COMANDO	CONTAINER	RUN	......................................................................................................................	55	
6.4	 COMANDO	CONTAINER	LIST	......................................................................................................................	57	
6.5	 COMANDO	CONTAINER	REMOVE	..............................................................................................................	58	
6.6	 COMANDO	CONTAINER	STOP	....................................................................................................................	60	
6.7	 COMANDO	CONTAINER	LOGS	....................................................................................................................	61	
6.8	 COMANDO	CONTAINER	TOP	......................................................................................................................	61	
6.9	 COMANDO	CONTAINER	INSPECT	..............................................................................................................	62	
6.10	 COMANDO	CONTAINER	STATS	..................................................................................................................	63	
6.11	 COMANDO	CONTAINER	ATTACH	...............................................................................................................	63	
6.12	 COMANDO	CONTAINER	EXEC	....................................................................................................................	64	
6.13	 COMANDO	CONTAINER	COMMIT	...............................................................................................................	64	
6.14	 VOLVIENDO	AL	COMANDO	RUN	................................................................................................................	66	
7.	 DOCKER	NETWORKING	................................................................................................................	67	
7.1	 REDES	POR	DEFECTO	.................................................................................................................................	67	
7.2	 REDES	DEFINIDAS	POR	EL	USUARIO	.........................................................................................................	71	
7.3	 USO	DE	REDES	DOCKER	EN	WINDOWS	10	.............................................................................................74	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 4	
7.4	 TOPOLOGÍAS	DE	RED	E	IPAM	..................................................................................................................	75	
7.5	 DOCKER	NETWORK	CREATE	......................................................................................................................	77	
7.6	 OTROS	COMANDOS	RELACIONADOS	.........................................................................................................	78	
8.	 CORRIENDO	SERVICIOS	EN	UN	CONTENEDOR	......................................................................	81	
8.1	 CONCEBIR	EL	CONTENEDOR	COMO	UN	SERVICIO	..................................................................................	81	
8.2	 PUBLICAR	PUERTOS	DE	CONTENEDOR:	LA	OPCIÓN	–P	.........................................................................	82	
8.3	 UNIÓN	DE	PUERTOS	USANDO	EXPOSE	Y	LA	OPCIÓN	–P	.....................................................................	83	
9.	 COMPARTIR	DATOS	CON	CONTENEDORES	............................................................................	85	
9.1	 VOLUMEN	DE	DATOS	..................................................................................................................................	85	
9.2	 CREANDO	DOCKER	VOLUMES	...................................................................................................................	86	
9.3	 COMPARTIR	DATOS	ENTRE	CONTENEDORES	........................................................................................	90	
9.4	 MONTANDO	UN	VOLUMEN	DE	DATOS	DESDE	OTRO	CONTENEDOR	..................................................	90	
10.	 ORGANIZAR	CONTENEDORES	................................................................................................	92	
10.1	 ENLAZANDO	CONTENEDORES	..................................................................................................................	92	
10.2	 ORQUESTACIÓN	DE	CONTENEDORES	......................................................................................................	95	
10.3	 LABORATORIO	...........................................................................................................................................	102	
11.	 DOCKER-MACHINE	.................................................................................................................	105	
11.1	 INSTALACIÓN	DEL	DOCKER-MACHINE	DEPENDIENDO	DEL	SO	UTILIZADO	.....................................	105	
11.2	 UTILIZANDO	DOCKER-MACHINE	CON	VIRTUALBOX	...........................................................................	106	
11.3	 UTILIZANDO	DOCKER-MACHINE	CON	HYPER-V	..................................................................................	108	
12.	 DOCKER	SWARM	.....................................................................................................................	113	
12.1	 SERVICIOS	Y	TAREAS	................................................................................................................................	113	
12.2	 BALANCEO	..................................................................................................................................................	114	
12.3	 CONFIGURAR	SWARM	..............................................................................................................................	114	
12.4	 GESTIÓN	DE	SERVICIOS	............................................................................................................................	115	
12.5	 LABORATORIO	...........................................................................................................................................	117	
13.	 DOCKER	STACK	.......................................................................................................................	119	
13.1	 COMPRENDER	EL	USO	DE	LAS	PILAS	DOCKER	......................................................................................	119	
13.2	 CÓMO	CREAR	Y	USAR	UN	YAML	COMPUESTO	PARA	PILAS	................................................................	120	
BIBLIOGRAFÍA	.......................................................................................................................................	132	
ANEXO	1	...................................................................................................................................................	133	
COMANDOS	BÁSICOS	DE	DOCKER	..........................................................................................................................	133	
ANEXO	2	...................................................................................................................................................	135	
LANZAR	UN	SERVICIO	CON	DOCKER	SWARM	EN	LOAD	BALANCING	..........................................	135	
ANEXO	3	...................................................................................................................................................	139	
IMPLEMENTACIÓN	DE	UN	CLUSTER	HA_ASTERISK	UTILIZANDO	DOCKER	.....................................................	139	
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 5	
1. ¿QUÉ ES DOCKER? 
 
Docker es un motor de contenedor de código abierto, que automatiza el empaque, el envío 
y el despliegue de cualquier aplicación de software que se presenta como contenedores 
livianos, portátiles y autosuficientes, que se ejecutarán prácticamente en cualquier lugar. Un 
contenedor Docker es un cubo de software que comprende todo lo necesario para ejecutar 
el software de forma independiente. Puede haber varios contenedores Docker en una sola 
máquina y los contenedores están completamente aislados entre sí, así como desde la 
máquina anfitriona. 
 
Docker es un servicio de gestión de contenedores. Las palabras clave de Docker son 
desarrollo, portabilidad y funcionalidad en cualquier lugar. Toda la idea de Docker es que 
los desarrolladores desarrollen fácilmente aplicaciones y las envíen a contenedores que 
pueden desplegarse en cualquier lugar. 
 
Docker no es un framework ni tampoco es un lenguaje de programación. Considéralo 
como una herramienta para la gestión de software. 
 
El lanzamiento inicial de Docker fue en marzo de 2013 y desde entonces, se ha convertido 
en la palabra de moda para el desarrollo del mundo moderno, especialmente para los 
proyectos basados en metodologías ágiles. 
 
1.1 Características	de	Docker.	
• Docker	tiene	la	capacidad	de	reducir	el	tamaño	del	desarrollo	proporcionando	
una	huella	más	pequeña	del	sistema	operativo	a	través	de	contenedores.	
• Con	los	contenedores,	resulta	más	fácil	para	los	equipos	de	diferentes	unidades,	
como	 el	 desarrollo,	 el	 control	 de	 calidad	 y	 las	 operaciones,	 trabajar	 sin	
problemas	en	todas	las	aplicaciones.	
• Puede	 implementar	 contenedores	de	Docker	 en	 cualquier	 lugar,	 en	 cualquier	
máquina	física	y	virtual	e	incluso	en	la	nube.	
• Dado	 que	 los	 contenedores	Docker	 son	 bastante	 ligeros,	 son	muy	 fácilmente	
escalables.	
 
1.2 Componentes	de	Docker	
Docker cuenta con los siguientes componentes: 
• Docker	para	Mac	-	Le	permite	a	uno	ejecutar	 contenedores	Docker	en	el	
sistema	operativo	Mac.	
• Docker	para	Linux	–	Le	permite	a	uno	ejecutar	contenedores	Docker	en	el	
sistema	operativo	Linux.	
• Docker	para	Windows	–	Le	permite	a	uno	ejecutar	contenedores	Docker	
en	el	sistema	operativo	Windows.	
• Docker	 Engine	 –	 Es	 utilizado	 para	 crear	 imágenes	 y	 construir	
contenedores	Docker.	
• Docker	Hub	-	Este	es	el	registro	que	se	utiliza	para	alojar	varias	imágenes	
Docker	en	la	web.	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 6	
• Docker	Compose	-	Esto	se	usa	para	definir	aplicaciones	que	usan	múltiples	
contenedores	Docker.	
 
1.3 Docker	internamente	
Supongamos que queremos ejecutar directamente los contenedores en una máquina 
Linux. El motor Docker produce, monitorea y administra varios contenedores como se 
ilustra en el siguiente diagrama: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura1.1 Conceptualización de Docker 
 
El diagrama anterior ilustra vívidamente cómo los futuros sistemas de TI tendrían 
cientos de contenedores sensibles a las aplicaciones, que de forma innata podrían 
facilitar su integración y orquestación integradas para derivar aplicaciones 
modulares (empresariales, sociales, móviles, analíticas y soluciones integradas). 
Estas aplicaciones contenidas podrían ejecutarse con fluidez en infraestructuras 
convergentes, federadas, virtualizadas, compartidas, dedicadas y automatizadas. 
 
 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 7	
2. Instalación de Docker 
 
Docker puede ser instalado en sistemas operativos como Linux, Windows y Mac. 
Cada sistema operativo tiene su forma de instalar Docker, pero lo interesante es que en 
todos los sistemas operativos los comandos de Docker son los mismos, no cambian, el 
mismo comando que usted utiliza en Linux es el mismo que debe aplicar en Windows y 
en Mac. 
 
2.1 Instalación de Docker en Windows 
 
Hay dos formas de instalar Docker en Windows. Si se va a instalar en Windows 
7/8/10 Home, se utiliza lo que se conoce como Docker Toolbox. Existe una 
versión de Docker para Windows 10 Proffessional o Enterprise, la cual trabaja 
directamente con el kernel de Windows. 
 
2.1.1. Instalación	de	Docker	en	Windows	7/8/10	Home3	
• El	sistema	operativo	Windows	debe	ser	de	64	bits	
• Lo	primero	es	descargar	el	Docker	Tollbox	
https://docs.docker.com/toolbox/toolbox_install_windows/ 
• Asegurarse	 que	 su	 sistema	 Windows	 soporta	 tecnología	 de	
virtualización	y	que	la	misma	está	activa.	
Para Windows 8 y 8.1 ir a Start > Task Manager, bajo el tab CPU 
usted debe ver lo siguiente: 
 
 
Figura 2.1 Verificación de Windows 8 y 8.1 
 
• Para	Windows	7	debe	utilizar	una	herramienta	similar	a		
 
3	https://docs.docker.com/toolbox/toolbox_install_windows/#step-3-verify-your-installation	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 8	
https://www.microsoft.com/en-us/download/details.aspx?id=592 
• Confirmar	que	tu	sistema	operativo	es	de	64	bits.		Para	eso	debe	
dirigirse	a:	
https://support.microsoft.com/en-us/help/827218/how-to-determine-
whether-a-computer-is-running-a-32-bit-version-or-64 
• Docker	Toolbox	va	a	descargar	los	siguientes	softwares	en	su	pc	
o Docker	Client	for	Windows	
o Docker	Toolbox	management	tool	and	ISO	
o Oracle	VM	VirtualBox	
o Git	MSYS-git	UNIX	tools	
• Si	tiene	Virtual	Box	activado	debe	apagarlo	antes	de	empezar	la	
instalación.	
• Ahora	darle	doble	click	al	 instalador	del	Docker	Toolbok	y	debe	
aparecer	la	siguiente	pantalla	
 
 
Figura 2.2 Pantalla de inicio del Toolbox 
 
• Presione	 Next	 para	 aceptar	 las	 opciones	 e	 instalaciones.	 Al	
terminar	debe	aparecer	la	siguiente	pantalla	
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 9	
 
Figura 2.3 Pantalla de finalización de la instalación de Toolbox 
 
• Ahora	 debe	 buscar	 en	 su	 escritorio	 de	 Window	 los	 siguientes	
iconos.	
 
 
Figura 2.4 Iconos de arranque de Docker 
 
• Dar	doble	click	en	el	icono	Docker	Quickstart	
Si el sistema muestra un aviso de Control de cuenta de usuario para 
permitir que VirtualBox realice cambios en su computadora. Elija Sí. 
El terminal hace varias cosas para configurar Docker Toolbox por 
usted. Cuando está hecho, el terminal muestra el $ prompt. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 10	
 
 
Figura 2.5 Pantalla inicial de Docker 
 
• Para	 verificar	 que	Docker	 está	 instalado	 y	 corriendo	 escriba	 lo	
siguiente:	
docker run hello-world 
Debe aparecer la siguiente pantalla 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 2.6 Pantalla de verificación de que Docker está instalado 
 
2.1.2. Instalación	de	Docker	en	Windows	10	Pro4	
• Debemos	descargar	Docker	desde	
https://store.docker.com/editions/community/docker-ce-desktop-
windows 
 
4	https://docs.docker.com/docker-for-windows/install/#install-docker-for-windows	
$ docker run hello-world 
 Unable to find image 'hello-world:latest' locally 
 Pulling repository hello-world 
 91c95931e552: Download complete 
 a8219747be10: Download complete 
 Status: Downloaded newer image for hello-world:latest 
 Hello from Docker. 
 This message shows that your installation appears to be working correctly. 
 
 To generate this message, Docker took the following steps: 
 1. The Docker Engine CLI client contacted the Docker Engine daemon. 
 2. The Docker Engine daemon pulled the "hello-world" image from the Docker Hub. 
 (Assuming it was not already locally available.) 
 3. The Docker Engine daemon created a new container from that image which runs the 
 executable that produces the output you are currently reading. 
 4. The Docker Engine daemon streamed that output to the Docker Engine CLI client, which sent it 
 to your terminal. 
 
 To try something more ambitious, you can run an Ubuntu container with: 
 $ docker run -it ubuntu bash 
 
 For more examples and ideas, visit: 
 https://docs.docker.com/userguide/ 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 11	
• Darle	doble	click	a	Docker	for	Windows	Installer.exe	
• Siga	el	asistente	de	instalación	para	aceptar	la	licencia,	autorizar	
el	instalador	y	continuar	con	la	instalación.	
• Al	 finalizar	 debe	 aparecer	 la	 siguiente	 pantalla	 donde	 le	 damos	
clik	al	botón	que	dice	Finish	
 
 
Figura 2.7 Pantalla de finalización de instalación de Docker en Win 10 
 
 
• Docker	 no	 se	 iniciará	 automáticamente.	 Para	 iniciarlo,	
busque	Docker,	 seleccione	 la	aplicación	en	 los	 resultados	
de	búsqueda	y	haga	clic	en	ella	(o	presione	Retorno).	
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 12	
 
Figura 2.8 Inicialización de Docker en Win 10 Pro 
 
• Cuando	 la	 ballena	 en	 la	 barra	 de	 estado	 se	 mantiene	
estable,	 Docker	 está	 funcionando	 y	 se	 puede	 acceder	
desde	cualquier	ventana	de	terminal.	
 
 
Figura 2.9 Docker estable 
 
 
• Si	 acaba	 de	 instalar	 la	 aplicación,	 también	 recibirá	 un	
mensaje	emergente	con	los	próximos	pasos	sugeridos	y	un	
enlace	a	esta	documentación.	
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 13	
 
Figura 2.10 Pantalla de inicio de Docker en Win 10 Pro 
 
2.1.3. Instalación	de	Docker	en	Windows	11	
Recomendamos ver el siguiente video 
https://www.youtube.com/watch?v=U8RcrCoL9q4 
 
2.2 Instalación Docker en Mac 
• Descargar	Docker	para	Mac	desde:	
https://store.docker.com/editions/community/docker-ce-
desktop-mac 
• Dar	doble	click	a	Docker.dmg	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 14	
• Debe	aparecer	la	siguiente	pantalla	
• Arrastra	Moby	la	ballena	a	la	carpeta	Aplicaciones	
 
Figura 2.11 Pantalla de instalación de Docker en Mac 
 
• Haga	 doble	 clic	 en	 Docker.app	 en	 la	 carpeta	 de	
aplicaciones	para	iniciar	Docker.	
 
 
 
Figura 2.12 Docker en la sección de Aplicaciones 
 
• Se	le	pedirá	que	autorice	Docker.app	con	la	contraseña	de	
su	 sistema	 después	 de	 iniciarlo.	 Se	 necesita	 acceso	
privilegiado	para	instalar	componentes	de	red	y	enlaces	a	
las	aplicaciones	Docker.	 	La	ballena	en	la	barra	de	estado	
superior	indica	que	Docker	se	está	ejecutando	y	se	puede	
acceder	desde	una	terminal.	
 
 
Figura 2.13 Docker en la Barra de Tareas de Mac 
 
• Si	 acaba	 de	 instalar	 la	 aplicación,	 también	 recibirá	 un	
mensaje	 de	 éxito	 con	 los	 próximos	 pasos	 sugeridos	 y	 un	
enlace	 a	 esta	 documentación.	 Haga	 clic	 en	 la	 ballena	
(ballena	 menú)	 en	 la	 barra	 de	 estado	 para	 cerrar	 esta	
ventana	emergente.	
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 15	
 
 
Figura 2.14 Pantalla inicial de Docker 
 
• Haga	 clic	 en	 la	 ballena	 (menú	 de	 ballenas)	 para	 obtener	
las	Preferencias	y	otras	opciones.	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 16	
 
Figura 2.15 Pantalla para iniciar Docker en Mac 
 
Para instalar Docker en las nuevas Mac recomendamos el siguiente 
video de instalación: 
https://www.youtube.com/watch?v=SGmFGYCuJK4 
 
2.3 Instalación de Docker en Linux Ubuntu 22.04 
• sudo	apt	update	
• sudo	apt	install	apt-transport-https	ca-certificatescurl	software-properties-common	
• sudo	mkdir	-m	0755	-p	/etc/apt/keyrings	
• curl	-fsSL	
https://download.docker.com/linux/ubuntu/gpg	|	
sudo	gpg	--dearmor	-o	/etc/apt/keyrings/docker.gpg	
• echo	\	"deb	[arch=$(dpkg	--print-architecture)	
signed-by=/etc/apt/keyrings/docker.gpg]	
https://download.docker.com/linux/ubuntu	
\	$(lsb_release	-cs)	stable"	|	sudo	tee	
/etc/apt/sources.list.d/docker.list	>	/dev/null	
• sudo	apt-get	update	
• apt-cache	policy	docker-ce	
• sudo	apt-get	install	docker-ce	docker-ce-cli	
containerd.io	docker-buildx-plugin	docker-compose-
plugin	
• sudo	systemctl	status	docker	
• sudo	systemctl	enable	docker	
• sudo	usermod	-aG	docker	<SU	USUARIO>	
• Verificar	la	instalación	de	Docker	
docker info 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 17	
docker version 
 docker run hello-world 
 
 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 18	
3. Ejecutando la Primera Imagen y el Primer Contenedor 
 
Antes de empezar con la ejecución de nuestra primera imagen y nuestro primer 
contenedor, debemos repasar algunos conceptos utilizados en Docker. 
3.1 Imágenes y Contenedores 
Una imagen en Docker es una plantilla que puede solamente contener un sistema 
operativo o una aplicación en particular. Mientras tanto un contenedor es un 
conjunto de imagénes que producen una aplicación en particular. 
 
 
Figura 3.1 Imagen y Contenedor 
 
Una imagen Docker es una colección de todos los archivos que componen una 
aplicación de software. Cada cambio que se realiza en la imagen original se 
almacena en una capa separada. Para ser precisos, cualquier imagen Docker tiene 
que originarse a partir de una imagen base de acuerdo con los diversos requisitos. 
Se pueden unir módulos adicionales a la imagen base para derivar las diversas 
imágenes que pueden exhibir el comportamiento preferido. Cada vez que se 
compromete con una imagen Docker, está creando una nueva capa en la imagen 
Docker, pero la imagen original y cada capa preexistente permanecen sin cambios. 
En otras palabras, las imágenes son típicamente del tipo de solo lectura. Si cuentan 
con el poder mediante la incorporación sistemática de módulos más nuevos, se 
creará una imagen nueva con un nombre nuevo. Las imágenes Docker se están 
convirtiendo en una base viable para desarrollar e implementar los contenedores 
Docker. 
 
Las imágenes base se pueden mejorar para que puedan crear las imágenes 
principales, que a su vez pueden usarse para crear las imágenes secundarias. La 
imagen base no tiene ningún elemento principal, es decir, las imágenes principales 
se encuentran en la parte superior de la imagen base. Cuando trabajamos con una 
imagen y no especificamos esa imagen a través de una identidad apropiada (por 
ejemplo, un nombre nuevo), la imagen más reciente (generada recientemente) 
siempre será identificada y utilizada por el motor Docker. 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 19	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.2 Debian es la imagen base 
 
 
 
 
 
 
Al final, agregar módulos adicionales a la imagen base crea un contenedor. La 
manera más fácil de pensar sobre un contenedor es como la capa de lectura y 
escritura que se encuentra en una o más imágenes de solo lectura. Cuando se 
ejecuta el contenedor, el motor Docker combina no solo todas las imágenes 
necesarias, sino que también fusiona los cambios de la capa de lectura y escritura 
en el contenedor. Esto lo convierte en un sistema autónomo, extensible y 
ejecutable. Los cambios se pueden combinar utilizando el subcomando Docker, 
docker commit. El nuevo contenedor acomodará todos los cambios que se realicen 
en la imagen base. La nueva imagen formará una nueva capa en la parte superior de 
la imagen base. 
 
En el siguiente diagrama. la imagen base es la distribución Debian, luego hay una 
adición de dos imágenes (los emacs y el servidor Apache), y esto dará como 
resultado el contenedor: 
 
En general, la imagen base representa un sistema operativo, y en el 
caso de Linux, la imagen base puede ser una de sus distribuciones, 
como Debian. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 20	
 
Figura 3.3 Construcción de un contenedor 
 
3.2 Ejecución de la primera imagen. 
Para ejecutar una imagen primero hay que encontrarla. Existen dos métodos para 
hacerlo: 
 
3.2.1 hub.docker.com	
hub.docker.com es el repositorio oficial de imágenes de docker, con más de 
100,000 imágenes públicas y privadas. 
 
 
Figura 3.4 Pantalla de inicio de hub.docker 
 
Utilizando el portal podemos buscar la imagen que necesitamos. El 
portal nos desplegará todas las imágenes disponibles, además, 
indicará cuál es el comando que se debe utilizar para descargar la 
imagen. También indica cuántas descargas lleva la imagen escogida. 
 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 21	
Figura 3.5 Resultado de la búsqueda de una imagen 
 
Si tomamos la opción DETAILS obtendremos toda la información 
de la imagen que se quiere descargar 
 
 
Figura 3.6 Información de la imagen a descargar 
 
En el lado derecho de la pantalla anterior podemos observar el 
comando que debemos usar para descargar la imagen. 
 
3.2.2 La	otra	forma	de	acceder	a	las	imágenes	es	usando	comandos	directos		
$ docker search nombre de la imagen 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 22	
$ docker pull nombre de la imagen 
 
docker search busca la imagen primeramente en el repositorio local de 
docker. Si no lo encuentra en el repositorio local lo busca y lo descarga de 
hub.docker.com 
 
 
Figura 3.7 Resultado del comando docker search buscando en hub.docker.com 
 
Si analizamos la figura anterior obtenemos una pantalla similar a la figura 
3.5. 
 
Para descargar la imagen utilizamos el comando docker pull. docker pull 
siempre descargará la variante de imagen que tiene la última etiqueta en ese 
repositorio. Si dentro del comando utilizamos la opción - a nos descargará 
más imágenes. 
$ docker pull -a ubuntu 
Nos va a descargar las imágenes de ubuntu desde la versión 10.04 a 17.04 
más otras imágenes dentro del repositotio. 
 
 
Figura 3.8 Imágenes descargadas en el repositorio local 
REPOSITORY: Este es el nombre del repositorio o imagen. En el ejemplo 
anterior, el nombre del repositorio es ubuntu. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 23	
TAG: Esta es la etiqueta asociada con la imagen, por ejemplo 17.04, la 
última. Se pueden asociar una o más etiquetas a una imagen. 
IMAGE ID: Cada imagen está asociada con una identificación única. La 
identificación de la imagen se representa utilizando un número aleatorio 
largo de 64 dígitos hexadecimales. Por defecto, el subcomando de imágenes 
Docker solo mostrará 12 dígitos hexadecimales. 
CREATED: Indica que tanto tiempo ha pasado desde que se creó la imagen. 
SIZE: Tamaño de la imagen descargada. 
 
 
 
 
 
 
 
 
 
 
hub.docker.com también proporciona una plataforma para los 
desarrolladores y proveedores para compartir sus imágenes para consumo 
general. Las imágenes de terceros están precedidas por la identificación de 
usuario de sus desarrolladores o depositantes. Por ejemplo, thedockerbook / 
helloworld es una imagen de terceros, en donde thedockerbook es la 
identificación del usuario y helloworld es el nombre del repositorio de 
imágenes. Puede descargar cualquier imagen de terceros mediante el uso del 
comando de extracción, como se muestra a continuación: 
docker pull thedockerbook/helloworld 
 
Además del repositorio anterior, el ecosistema Docker también proporciona 
un mecanismo para aprovechar las imágenes de cualquier hub de repositorio 
de terceros que no sea el Docker Hub Registry, y proporciona las imágenes 
alojadas en los concentradores de repositorio locales. El motor Docker se ha 
programado para buscar imágenes en index.docker.io de forma 
predeterminada, mientras que en el caso del tercero o el hub de repositorio 
local, debemos especificar manualmente la ruta desde la que debe estar la 
imagen. Una ruta de repositorio manual es similar a una URL sin un 
especificador de protocolo,como https: //, http: // y ftp: //. A continuación, se 
muestra un ejemplo de extracción de una imagen desde un centro de 
depósito de terceros: 
docker pull registry.example.com/myapp 
 
 
3.3 Trabajando con un contenedor interactivo 
En el segundo capítulo, ejecutamos nuestro primer contenedor Hello World para 
tener una idea de cómo funciona la tecnología de contenedorización. En esta 
sección, vamos a ejecutar un contenedor en modo interactivo. El comando de 
De forma predeterminada, Docker siempre usa la imagen etiquetada 
como la más reciente (latest). Cada variante de imagen se puede 
identificar directamente calificándola con su etiqueta. Una imagen puede 
calificarse agregando la etiqueta al nombre del repositorio con un : que se 
agrega entre la etiqueta y el nombre del repositorio (<repository>:<tag>) 
docker pull ubuntu:17.04 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 24	
ejecución del docker toma una imagen como entrada y la lanza como un 
contenedor. Debe pasar las banderas -t y -i al comando de la ventana docker para 
que el contenedor sea interactivo. El distintivo -i es el controlador de la clave, lo 
que hace que el contenedor sea interactivo al tomar la entrada estándar (STDIN) 
del contenedor. El distintivo -t asigna un pseudo-TTY o un pseudo-terminal 
(emulador de terminal) y luego lo asigna al contenedor. 
En el siguiente ejemplo vamos a lanzar un contenedor interactivo usando la imagen 
de ubuntu 14.04 y usaremos el comando /bin/bash (permite usar los comandos de 
ubuntu) 
docker run -i -t ubuntu:14.04 /bin/bash 
 
 
Figura 3.9 Ejecución del contenedor interactivo 
 
El indicador bash anterior confirma que nuestro contenedor ha sido lanzado con 
éxito, y que está listo para tomar nuestra entrada. Si se está preguntando sobre el 
número hexadecimal 46f52acc2c1b en el mensaje, entonces no es más que el 
nombre de host del contenedor. En el lenguaje de Docker, el nombre de host es el 
mismo que el ID del contenedor. 
 
Para salir del contenedor interactivo pero que el mismo siga corriendo se utiliza el 
comando ctrl pq. Para comprobar que contenedor está en uso se utiliza el 
comando docker ps 
 
 
Figura 3.10 Ejecución del comando docker ps 
 
CONTAINER ID: Muestra la identificación del contenedor asociada con el 
contenedor. La identificación del contenedor es un número aleatorio largo de 64 
dígitos hexadecimales. Por defecto, el subcomando docker ps mostrará solo 12 
dígitos hexadecimales. Puede visualizar todos los 64 dígitos utilizando el indicador -
-no-trunc, por ejemplo: 
docker ps --no-trunc 
IMAGE: Muestra la imagen desde la que se ha diseñado el contenedor Docker. 
COMMAND: Muestra el comando ejecutado durante el lanzamiento del 
contenedor. 
CREATED: Indica cuándo se creó el contenedor. 
STATUS: Estado actual del contenedor. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 25	
PORTS: Indica si se ha asignado algún puerto al contenedor. 
NAMES: El motor Docker genera automáticamente un nombre de contenedor 
aleatorio mediante la concatenación de un adjetivo y un nombre. La ID del 
contenedor o su nombre pueden usarse para tomar medidas adicionales en el 
contenedor. El nombre del contenedor se puede configurar manualmente utilizando 
la opción --name en el comando de run. 
 
Para detener la ejecución del contenedor usamos el comando 
docker stop 4b1ae9582e9c 
 
Ahora si ejecutamos el comando docker ps veremos que no se encuentra ningún 
contenedor en ejecución 
 
 
Figura 3.11 Repositorio de contenedores vacio 
 
Si se desea nuevamente arrancar y conectarse al contenedor debemos usar los 
siguientes comandos: 
docker start CONTAINER ID 
docker attach CONTAINER ID 
 
 
Figura 3.12 Reactivación de un contenedor 
 
También podemos darle seguimiento a los cambios realizados dentro del contenedor 
utilizando el comando 
docker diff CONTAINER ID 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 26	
 
Figura 3.13 Seguimiento de los cambios hechos en el contenedor 
 
Si queremos ver todos los contenedores que hemos creado, incluyendo los que no 
están en ejecución, utilizamos el siguiente comando: 
docker ps –a 
 
 
Figura 3.14 Contenedores en ejecución y los contenedores detenidos 
 
3.4 Construyendo una imagen desde un contenedor 
En esta sección, veamos cómo podemos agregar más software a nuestra imagen 
base en un contenedor en ejecución y luego convertir ese contenedor en una 
imagen para ser usada en el futuro. Usaremos como imagen base ubuntu 14.04, la 
cual no cuenta con muchos de sus comandos. En esta ocasión lo vamos agregar el 
wget. 
 
En este ejemplo usaremos la siguiente secuencia de comandos: 
docker run -i -t ubuntu:14.04 /bin/bash 
root@78ed016a4234:/# which wget 
root@78ed016a4234:/# #ubicación del comando wget 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 27	
root@78ed016a4234:/# apt-get update 
root@78ed016a4234:/# apt-get install -y wget 
root@78ed016a4234:/# which wget 
/usr/bin/wget #ubicación del comando wget 
root@78ed016a4234:/# exit 
docker commit 78ed016a4234 \ubuntu_wget 
 
El comando commit es uno de los comandos utilizados para crear una nueva 
imagen a partir de un contenedor. Se recomienda que para usar commit el 
contenedor debe estar detenido. 
 
Ahora utilizamos el comando docker images para comprobar que la imagen se creo 
con el nombre ubuntu_wget 
 
 
Figura 3.15 Comprobación de la creación de la nueva imagen 
 
 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 28	
4. Construcción de Imágenes 
 
En este capítulo usaremos Dockerfile para la construcción de imágenes de 
mayor productividad. Un Dockerfile es un documento de texto que contiene 
todos los comandos que un usuario podría llamar en la línea de comando para 
ensamblar una imagen. Al usar Docker los usuarios pueden crear una 
compilación automatizada que ejecuta varias instrucciones de línea de comandos 
en sucesión5. 
 
Cubriremos los siguientes temas en este capítulo: 
• Sistema integrado de construcción de imágenes de Docker 
• Visión general rápida de la sintaxis de Dockerfile 
• Instrucciones de compilación de Dockerfile 
• Cómo almacena Docker las imágenes 
 
Para la realización de este capítulo nos basaremos principalmente en el libro 
“Learning Docker de Pethuru Raj”. 
 
4.1 Sistema de construcción de imagen integrada de Docker 
 
Como comentamos en el capítulo anterior, pudimos crear una imagen 
manualmente al abrir un contenedor desde una imagen base, instalar todas 
las aplicaciones requeridas, realizar los cambios necesarios en el archivo de 
configuración y luego enviar el contenedor como una imagen. 
 
Las instrucciones secuenciales dentro de Dockerfile pueden incluir la 
selección de la imagen base, la instalación de la aplicación requerida, la 
adición de la configuración y los archivos de datos, la ejecución automática 
de los servicios y la exposición de esos servicios al mundo externo. Por lo 
tanto, el sistema de compilación automatizado basado en Dockerfile 
simplificó el proceso de creación de imágenes. También ofrece una gran 
flexibilidad en la forma en que se organizan las instrucciones de 
construcción y en la forma en que visualizan el proceso de construcción 
completo. 
 
Veamos un ejemplo básico de lo que podemos hacer con Dockerfile, 
solamente utilizando dos instrucciones. 
 
$ cat > Dockerfile #escribir > para crear el archivo 
FROM busybox:latest 
CMD echo Hello World!! 
Ctrl c 
 
5	https://docs.docker.com/engine/reference/builder/	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 29	
• La	 primera	 instrucción	 es	 para	 elegir	 la	 selección	 de	 la	
imagen	 base.	 En	 este	 ejemplo,	 seleccionaremos	 la	
busybox6:	última	imagen	
• La	 segunda	 instrucción	es	para	 llevar	a	 cabo	el	 comando	
CMD,	 que	 instruye	 el	 contenedor	 para	 hacer	 eco	 Hello	
World	!!.	
 
Ahora procedamos a generar una imagen de Docker utilizando el archivo 
Docker anterior llamando a la compilación Docker junto con la ruta de 
Dockerfile. En nuestro ejemplo, invocaremos el comando docker build del 
directorio donde hemosalmacenado Dockerfile7, y la ruta se especificará 
con el siguiente comando: 
docker build . 
 
Después de emitir el comando anterior, el proceso de compilación 
comenzará enviando contexto de construcción al daemon8 y luego mostrará 
el texto que se muestra aquí: 
 
$ docker build . 
Sending build context to Docker daemon 2.048kB 
Step 1/2 : FROM busybox:latest 
latest: Pulling from library/busybox 
0ffadd58f2a6: Pull complete 
Digest: 
sha256:bbc3a03235220b170ba48a157dd097dd1379299370e1ed99ce976df0
355d24f0 
Status: Downloaded newer image for busybox:latest 
 ---> 6ad733544a63 
Step 2/2 : CMD echo Hola Mundo!! 
 ---> Running in ca5ffaa44155 
 ---> eea3e1c44e6f 
Removing intermediate container ca5ffaa44155 
Successfully built eea3e1c44e6f 
 
 
El proceso de compilación continuará y, después de completarse, mostrará lo 
siguiente: 
Successfully built eea3e1c44e6f 
 
 
6	Es	un	programa	que	combina	muchas	utilidades	estándares	de	Unix	en	un	solo	ejecutable	pequeño.	
			https://es.wikipedia.org/wiki/Busybox	
7	Dockerfile	no	puede	estar	en	el	directorio	raíz	
8	El	uso	de	este	nombre	viene	del	retroacrónimo	"Daemon",	Disk	And	Execution	MONitor	
				https://es.wikipedia.org/wiki/Demonio_(informática)	
	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 30	
En el ejemplo anterior, la imagen fue construida por el ID DE IMAGEN 
eea3e1c44e6f. 
Usemos esta imagen para abrir un contenedor mediante el uso del comando 
docker de la siguiente manera: 
docker run eea3e1c44e6f 
 
$ docker run eea3e1c44e6f 
Hola Mundo!! 
 
Con muy poco esfuerzo, hemos podido crear una imagen con busybox como 
imagen base, y hemos podido extender esa imagen para producir ¡¡Hola 
Mundo!!. Esta es una aplicación simple, pero las imágenes a escala 
empresarial también pueden realizarse utilizando la misma tecnología. 
 
Ahora corremos el comando: 
docker images 
 
$ docker images 
REPOSITORY TAG IMAGE ID CREATED 
SIZE 
<none> <none> eea3e1c44e6f 23 minutes ago 
 
Aquí, se sorprenderá al ver que el nombre de IMAGEN (REPOSITORY) y 
TAG se han enumerado como <ninguno>. Esto se debe a que no 
especificamos ninguna imagen o nombre de TAG cuando construimos esta 
imagen. Puede especificar un nombre de IMAGEN y opcionalmente un 
nombre de TAG mediante el uso del comando etiqueta docker, como se 
muestra aquí: 
docker tag eea3e1c44e6f busyboxplus 
 
El enfoque alternativo es construir la imagen con un nombre de imagen 
durante el tiempo de construcción mediante la opción -t para el comando 
docker build, como se muestra aquí: 
docker build -t busyboxplus . 
 
$ docker build -t busyboxplus . 
Sending build context to Docker daemon 2.048kB 
Step 1/2 : FROM busybox:latest 
 ---> 6ad733544a63 
Step 2/2 : CMD echo Hola Mundo!! 
 ---> Using cache 
 ---> eea3e1c44e6f 
Successfully built eea3e1c44e6f 
Successfully tagged busyboxplus:latest 
$ docker images 
REPOSITORY TAG IMAGE ID CREATED SIZE 
busyboxplus latest eea3e1c44e6f 36 minutes ago 1.13MB 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 31	
4.2 Sintaxis para escribir un Dockerfile 
 
Vamos a explicar la sintaxis que se debe utilizar al escribir un archivo 
Dockerfile. 
# Este es el símbolo de comentario 
 
INSTRUCCIÓN argumento 
 
La línea de instrucción de Dockerfile está formada por dos componentes, 
donde la línea de instrucción comienza con la instrucción en sí misma, que 
es seguida por los argumentos para la instrucción. La instrucción podría 
escribirse en mayúsculas o minúsculas, en otras palabras, no distingue entre 
mayúsculas y minúsculas. Sin embargo, la práctica o convención estándar es 
usar mayúsculas para diferenciarlo de los argumentos. Echemos otro vistazo 
al contenido de Dockerfile en nuestro ejemplo anterior: 
 
FROM busybox:latest 
CMD echo Hola Mundo!! 
 
La línea de comentarios en Dockerfile debe comenzar con el símbolo #. El 
símbolo # después de una instrucción se considera como un argumento. Si el 
símbolo # está precedido por un espacio en blanco, entonces el sistema de 
compilación de docker lo consideraría como una instrucción desconocida y 
saltaría la línea. Ahora, comprendamos mejor estos casos mencionados con 
la ayuda de un ejemplo para comprender mejor la línea de comentarios: 
 
# Esto es un comentario válido dentro de Dockerfile 
 
CMD echo ### Bienvenido a Docker ### 
 
 # instrucción desconocida 
 
 
 
 
 
 
 
 
 
 
 
 
 
4.3 Construcción de Instrucciones en el Dockerfile 
4.3.1 Instrucción	FROM	
El sistema de compilación Docker ignora cualquier línea vacía en 
Dockerfile, por lo que se anima al autor de Dockerfile a agregar 
comentarios y líneas vacías para mejorar sustancialmente la 
legibilidad de Dockerfile. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 32	
La instrucción FROM es la más importante y es la primera 
instrucción válida de un Dockerfile. Establece la imagen base para el 
proceso de compilación. Las siguientes instrucciones usarían esta 
imagen base y construirían sobre ella. El sistema de compilación 
Docker le permite usar de manera flexible las imágenes creadas por 
cualquier persona. También puede ampliarlos añadiéndoles 
características más precisas y prácticas. De forma predeterminada, el 
sistema de compilación Docker busca en el host Docker las 
imágenes. Sin embargo, si la imagen no se encuentra en el host 
Docker, entonces el sistema de compilación Docker extraerá la 
imagen del Registro de Docker Hub públicamente disponible. El 
sistema de compilación Docker devolverá un error si no puede 
encontrar la imagen especificada en el host Docker y el Registro 
Docker Hub. 
La sintaxis de FROM es la siguiente: 
FROM <image>[:<tag>] 
 
• <image>:	Este	es	el	nombre	de	la	imagen	base	que	se	va	a	
utilizar.	
• <tag>:	Esta	es	la	etiqueta	opcional	que	vamos	a	usar	para	
identificar	 la	 imagen	 que	 se	 va	 a	 utilizar.	 Si	 no	 se	 usa	 el	
Docker	asume	que	utilizará	la	última	imagen	subida.	
Ejemplos: 
 FROM Centos 
 FROM ubuntu:16.04 
 
Docker permite el uso de múltiples instrucciones FROM pero esta 
práctica puede traer muchos conflictos 
 
4.3.2 Instrucción	MAINTAINER	
La instrucción MAINTAINER establece el campo Autor de las 
imágenes generadas. La instrucción LABEL es una versión mucho 
más flexible de esto y debe usarla en su lugar, ya que permite 
configurar cualquier metadato que requiera y se puede ver 
fácilmente, por ejemplo, con Docker Inspection. Para establecer una 
etiqueta correspondiente al campo MAINTAINER, puede usar: 
LABEL maintainer="SvenDowideit@home.org.au" 
 
4.3.3 Instrucción	COPY	
La instrucción COPY le permite copiar los archivos del host Docker 
al sistema de archivos de la nueva imagen. La siguiente es la sintaxis 
de la instrucción COPY: 
COPY <src> ... <dst> 
Los términos del código anterior tienen las explicaciones que se 
muestran aquí: 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 33	
• <src>: este es el directorio fuente, el archivo en el contexto de 
compilación o el directorio desde donde se invocó el comando docker 
build. 
• ...: Esto indica que múltiples archivos de origen pueden ser 
especificados directamente o especificados por comodines. 
• <dst>: esta es la ruta de destino para la nueva imagen en la que se 
copiará el archivo o directorio de origen. Si se han especificado 
varios archivos, la ruta de destino debe ser un directorio y debe 
terminar con una barra inclinada /. 
 
Se recomienda usar una ruta absoluta para el directorio de destino o 
un archivo. 
En ausencia de una ruta absoluta, la instrucción COPY supondrá que 
la ruta de destino comenzará desde root /. La instrucción COPY es lo 
suficientemente potente como para crear un nuevo directorio y 
sobrescribir el sistema de archivos en la imagen recién creada. 
En el siguiente ejemplo, copiaremos el directorio html del contexto 
de compilación fuente a /var/www/html, que está en el sistema de 
archivos de imagen, utilizando la instrucción COPY, como se 
muestra aquí:COPY html /var/www/html 
 
Aquí hay otro ejemplo de múltiples archivos (httpd.conf y magic) que 
se copiarán desde el contexto de compilación de origen a 
/etc/httpd/conf/, que está en el sistema de archivos de la imagen: 
COPY httpd.conf magic /etc/httpd/conf/ 
 
4.3.4 Instrucción	ADD	
La instrucción ADD es similar a la instrucción COPY. Sin embargo, 
además de la funcionalidad admitida por la instrucción COPY, la 
instrucción ADD puede manipular los archivos TAR y las URL 
remotas. 
Sintaxis de la instrucción ADD 
ADD <src> ... <dst> 
 
• <src>:	este	es	el	directorio	fuente,	el	archivo	en	el	contexto	
de	 compilación	 o	 el	 directorio	 desde	 donde	 se	 invocó	 el	
comando	docker	build.		Sin	embargo,	la	diferencia	notable	
es	que	la	fuente	puede	ser	un	archivo	TAR	almacenado	en	
el	contexto	de	compilación	o	ser	una	URL	remota.	
• ...:	Esto	indica	que	múltiples	archivos	de	origen	pueden	ser	
especificados	directamente	o	especificados	por	comodines.	
• <dst>	:	Esta	es	la	ruta	de	destino	para	la	nueva	imagen	en	
la	que	se	copiará	el	archivo	o	directorio	de	origen.	
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 34	
Aquí hay un ejemplo para demostrar el procedimiento para copiar 
múltiples archivos fuente a los diversos directorios de destino en el 
sistema de archivos de imágenes objetivo. En este ejemplo, hemos 
tomado un archivo TAR (web-page-config.tar) en el contexto de 
compilación de origen con el archivo de configuración de http 
daemon y los archivos para las páginas web se almacenan en la 
estructura de directorios adecuada, como se muestra a continuación: 
$ tar tf web-page-config.tar 
etc/httpd/conf/httpd.conf 
var/www/html/index.html 
var/www/html/aboutus.html 
var/www/html/images/welcome.gif 
var/www/html/images/banner.gif 
 
La siguiente línea en el contenido de Dockerfile tiene una instrucción 
ADD para copiar el archivo TAR (web-page-config.tar) a la imagen 
de destino y extraer el archivo TAR del directorio raíz (/) de la 
imagen de destino, como se muestra aquí: 
ADD web-page-config.tar / 
 
Por lo tanto, la opción TAR de la instrucción ADD se puede usar 
para copiar múltiples archivos a la imagen objetivo. 
 
4.3.5 Instrucción	ENV	
La instrucción ENV establece una variable de entorno en la nueva 
imagen. Una variable de entorno es un par de clave-valor, a la que 
cualquier secuencia de comandos o aplicación puede acceder. Las 
aplicaciones de Linux usan mucho las variables de entorno para una 
configuración inicial. 
Sintaxis de la instrucción ENV 
ENV <key> <value> 
 
Los términos del código indican lo siguiente: 
• <key>: esta es la variable de entorno 
• <value>: este es el valor que se debe establecer para la variable de 
entorno 
 
Las siguientes líneas dan dos ejemplos para la instrucción ENV, 
donde en la primera línea DEBUG_LVL se ha establecido en 3 y, en 
la segunda línea, APACHE_LOG_DIR se ha establecido en 
/var /log /apache: 
 
ENV DEBUG_LVL 3 
ENV APACHE_LOG_DIR /var/log/apache 
 
4.3.6 Instrucción	USER	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 35	
La instrucción USER establece la ID de usuario inicial o el Nombre 
de usuario en la nueva imagen. De forma predeterminada, los 
contenedores se iniciarán con la raíz como ID de usuario o UID. 
Básicamente, la instrucción USER modificará la identificación de 
usuario predeterminada de la raíz a la especificada en esta 
instrucción. 
La sintaxis de la instrucción USER es: 
USER <UID>|<UName> 
 
Las instrucciones de USER aceptan <UID> o <UName> como su 
argumento: 
• <UID>:	esta	es	una	ID	de	usuario	numérica	
• <UName>:	este	es	un	nombre	de	usuario	válido	
 
El siguiente es un ejemplo para configurar el ID de usuario 
predeterminado en el momento del inicio en 73. Aquí 73 es la ID 
numérica del usuario: 
USER 73 
 
4.3.7 Instrucción	WORKDIR	
La instrucción WORKDIR cambia el directorio de trabajo actual de / 
a la ruta especificada por esta instrucción. Las instrucciones 
siguientes, como RUN, CMD y ENTRYPOINT también funcionarán 
en el directorio establecido por la instrucción WORKDIR. 
La sintaxis de la instrucción WORKDIR es: 
WORKDIR <dirpath> 
 
Donde <dirpath> es la ruta para que el directorio de trabajo se 
establezca. La ruta puede ser absoluta o relativa. En el caso de una 
ruta relativa, será relativa a la ruta anterior establecida por la 
instrucción WORKDIR. Si el directorio especificado no se encuentra 
en el sistema de archivos de imágenes objetivo, entonces se creará el 
directorio. 
Un ejemplo de la instrucción WORKDIR es: 
WORKDIR /var/log 
 
4.3.8 Instrucción	VOLUME	
La instrucción VOLUME crea un directorio en el sistema de archivos 
de imágenes, que luego puede usarse para montar volúmenes desde el 
host Docker u otros contenedores. 
La instrucción VOLUME tiene dos tipos de sintaxis, como se 
muestra aquí: 
• El	 primer	 tipo	 es	 exec	 o	 JSON	 array	 (todos	 los	 valores	
deben	estar	dentro	de	doublequotes	(")):	
VOLUME ["<mountpoint>"] 
• El	segundo	tipo	es	shell	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 36	
VOLUME <mountpoint> 
En la línea anterior, <mountpoint> es el punto de montaje que 
debe crearse en la nueva imagen. 
 
4.3.9 Instrucción	EXPOSE	
La instrucción EXPOSE abre un puerto de red de contenedor para 
comunicarse entre el contenedor y el mundo externo. 
La sintaxis de la instrucción EXPOSE es la siguiente: 
EXPOSE <port>[/<proto>] [<port>[/<proto>]...] 
 
• <port>:	este	es	el	puerto	de	red	que	debe	estar	expuesto	al	
mundo	exterior.	
• <proto>:	 este	 es	 un	 campo	 opcional	 proporcionado	 para	
un	protocolo	de	transporte	específico,	como	TCP	y	UDP.	Si	
no	 se	 ha	 especificado	 ningún	 protocolo	 de	 transporte,	
entonces	se	supone	que	TCP	es	el	protocolo	de	transporte.	
 
El siguiente es un ejemplo de la instrucción EXPOSE dentro de un 
Dockerfile que expone el número de puerto 7373 como un puerto 
UDP y el número de puerto 8080 como un puerto TCP. Como se 
mencionó anteriormente, si el protocolo de transporte no se ha 
especificado, entonces se supone que el transporte TCP es el 
protocolo de transporte: 
EXPOSE 7373/udp 8080 
 
4.3.10 Instrucción	RUN	
La instrucción RUN puede ejecutar cualquier comando en tiempo de 
compilación. Esto quiere decir que puede ejecutar comandos en la 
imagen base antes de crearse o de otra forma, correr comandos al 
construirse la imagen. La recomendación general es ejecutar 
comandos múltiples usando una instrucción RUN. Esto reduce las 
capas en la imagen Docker resultante porque el sistema Docker crea 
inherentemente una capa para cada vez que se invoca una instrucción 
en Dockerfile. 
La instrucción RUN tiene dos tipos de sintaxis: 
• El	primero	es	el	tipo	de	shell,	como	se	muestra	aquí:	
RUN <command> 
Aquí, el <command> es el comando del shell que debe 
ejecutarse durante el tiempo de compilación. Si se utiliza este 
tipo de sintaxis, el comando siempre se ejecuta utilizando / 
bin / sh -c. 
• El	segundo	tipo	de	sintaxis	es	exec	o	la	matriz	JSON,	como	
se	muestra	aquí:	
RUN ["<exec>", "<arg-1>", ..., "<arg-n>"] 
o <exec>:	 este	 es	 el	 ejecutable	 que	 se	 ejecutará	
durante	el	tiempo	de	compilación.	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 37	
o <arg-1>,	...,	<arg-n>:	Estas	son	las	variables	(cero	o	
más)	número	de	argumentos	para	el	ejecutable.	
 
En el primer ejemplo, usaremos la instrucción RUN para agregar una 
línea de saludo al archivo .bashrc en el sistema de archivos de imagen 
objetivo, como se muestra aquí: 
RUN echo "echo Welcome to Docker!" >> /root/.bashrc 
 
El segundo ejemplo es un Dockerfile, que tiene las instrucciones para 
crear una imagen de la aplicación Apache2 encima de la imagen base 
de Ubuntu 14.04. 
########################################### 
# Dockerfile to build an Apache2 image 
########################################### 
# Base image is Ubuntu 
FROM ubuntu:14.04 
# Author: Yo 
MAINTAINER Yo yo@gmail.com 
# Install apache2 package 
RUN apt-get update && \ 
apt-get install -y apache2 && \ 
apt-get clean 
 
4.3.11 Instrucción	CMD	
La instrucción CMD puede ejecutar cualquier comando(o 
aplicación), que es similar a la instrucción RUN. Sin embargo, la 
diferencia principal entre esos dos es el tiempo de ejecución. El 
comando proporcionado a través de la instrucción RUN se ejecuta 
durante el tiempo de compilación, mientras que el comando 
especificado a través de la instrucción CMD se ejecuta cuando el 
contenedor se inicia desde la imagen recién creada. Por lo tanto, la 
instrucción CMD proporciona una ejecución predeterminada para 
este contenedor. Sin embargo, puede ser anulado por los argumentos 
del comando RUN de docker. Cuando la aplicación termina, el 
contenedor también terminará junto con la aplicación y viceversa. 
La instrucción CMD tiene tres tipos de sintaxis, como se muestra 
aquí: 
 
• El	 primer	 tipo	 de	 sintaxis	 es	 el	 tipo	 de	 shell,	 como	 se	
muestra	aquí:	
• CMD	<comando>	
• Dentro	de	esto,	el	<comando>	es	el	comando	de	shell,	que	
debe	ejecutarse	durante	el	lanzamiento	del	contenedor.	Si	
se	 utiliza	 este	 tipo	 de	 sintaxis,	 el	 comando	 siempre	 se	
ejecuta	utilizando	/	bin	/	sh	-c.	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 38	
• El	segundo	tipo	de	sintaxis	es	exec	o	la	matriz	JSON,	como	
se	muestra	aquí:	
CMD ["<exec>", "<arg-1>", ..., "<arg-n>"] 
Dentro de esto, los términos del código significan lo 
siguiente: 
o <exec>:	 este	 es	 el	 ejecutable,	 que	 se	 ejecutará	
durante	el	tiempo	de	lanzamiento	del	contenedor.	
o <arg-1>,	...,	<arg-n>:	Estas	son	las	variables	(cero	o	
más)	números	de	los	argumentos	para	el	ejecutable.	
• El	tercer	tipo	de	sintaxis	también	es	exec	o	la	matriz	JSON,	
que	 es	 similar	 al	 tipo	 anterior.	 Sin	 embargo,	 este	 tipo	 se	
usa	para	configurar	 los	parámetros	predeterminados	a	 la	
instrucción	ENTRYPOINT,	como	se	muestra	aquí:	
CMD ["<arg-1>", ..., "<arg-n>"] 
Dentro de esto, los términos del código significan lo 
siguiente: 
o <arg-1>,	 ...,	 <arg-n>:	 Estos	 son	 los	 números	
variables	 (cero	 o	más)	 de	 los	 argumentos	 para	 la	
instrucción	ENTRYPOINT	
 
 
 
 
 
 
 
 
 
En este ejemplo, creamos una imagen usando Dockerfile con la 
instrucción CMD para proporcionar una ejecución predeterminada y 
luego lanzar un contenedor usando la imagen elaborada. El siguiente 
es Dockerfile utiliza una instrucción CMD para hacer eco de un 
texto: 
 
#######################################################
# 
# Dockerfile to demonstrate the behaviour of CMD 
#######################################################
# 
# Build from base image busybox:latest 
FROM busybox:latest 
# Author: Yo 
MAINTAINER Yo <yo@gmail.com> 
# Set command for CMD 
CMD ["echo", "Dockerfile CMD demo"] 
 
Sintácticamente, puede agregar más de una instrucción 
CMD en Dockerfile. Sin embargo, el sistema de 
compilación ignoraría todas las instrucciones CMD excepto 
la última. En otras palabras, en el caso de múltiples 
instrucciones CMD, solo la última instrucción CMD sería 
efectiva. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 39	
Ahora ejecutamos los siguientes comandos: 
docker build -t cmd-demo . 
docker run cmd-demo 
 
4.3.12 Instrucción	ENTRYPOINT	
La instrucción ENTRYPOINT ayudará a crear una imagen para 
ejecutar una aplicación (punto de entrada) durante el ciclo de vida 
completo del contenedor, que se habría separado de la imagen. 
Cuando finaliza la aplicación del punto de entrada, el contenedor 
también se da por terminado junto con la aplicación y viceversa. Por 
lo tanto, la instrucción ENTRYPOINT haría que el contenedor 
funcionara como un ejecutable. Funcionalmente, ENTRYPOINT es 
similar a la instrucción CMD, pero la principal diferencia entre los 
dos es que la aplicación de punto de entrada se inicia utilizando la 
instrucción ENTRYPOINT, que no puede anularse utilizando los 
argumentos del comando de ejecución Docker. Sin embargo, estos 
argumentos del comando de ejecución del docker se pasarán como 
argumentos adicionales a la aplicación de punto de entrada. Habiendo 
dicho esto, Docker proporciona un mecanismo para anular la 
aplicación de punto de entrada a través de la opción --entrypoint en el 
comando de ejecución de la ventana acoplable. La opción --
entrypoint solo puede aceptar palabras como argumentos, por lo que 
tiene una funcionalidad limitada. 
Sintácticamente, la instrucción ENTRYPOINT es muy similar a las 
instrucciones RUN y CMD, y tiene dos tipos de sintaxis, como se 
muestra aquí: 
 
• El	 primer	 tipo	 de	 sintaxis	 es	 el	 tipo	 de	 shell,	 como	 se	
muestra	aquí:	
ENTRYPOINT <comando> 
Aquí, <comando> es el comando de shell, que se ejecuta 
durante el lanzamiento del contenedor. Si se utiliza este tipo 
de sintaxis, el comando siempre se ejecuta utilizando /bin/sh -
c. 
• El	segundo	tipo	de	sintaxis	es	exec	o	la	matriz	JSON,	como	
se	muestra	aquí:	
ENTRYPOINT ["<exec>", "<arg-1>", ..., "<arg-n>"] 
Dentro de esto, los términos del código significan lo 
siguiente: 
o <exec>:	 este	 es	 el	 ejecutable,	 que	 debe	 ejecutarse	
durante	el	tiempo	de	lanzamiento	del	contenedor.	
o <arg-1>,	...,	<arg-n>:	Estas	son	las	variables	(cero	o	
más)	números	de	argumentos	para	el	ejecutable.	
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 40	
 
 
 
 
 
 
 
 
Para obtener una mejor comprensión de la instrucción 
ENTRYPOINT, creamos un imagen mediante el uso de Dockerfile 
con la instrucción ENTRYPOINT, y luego lanzamos un contenedor 
mediante el uso de la imagen hecha a mano. El siguiente es 
Dockerfile con una instrucción ENTRYPOINT para hacer eco de un 
texto: 
#######################################################
# 
# Dockerfile to demonstrate the behaviour of ENTRYPOINT 
#######################################################
# 
# Build from base image busybox:latest 
FROM busybox:latest 
# Author: Yo 
MAINTAINER Yo <yo@gmail.com> 
# Set entrypoint command 
ENTRYPOINT ["echo", "Dockerfile ENTRYPOINT demo"] 
 
Aplicamos los siguientes comandos: 
docker build -t entrypoint-demo . 
docker run entrypoint-demo 
 
El contenedor se ejecutará como un ejecutable haciendo eco de la 
cadena de demostración Dockerfile ENTRYPOINT y luego saldrá de 
inmediato. Si pasamos argumentos adicionales al comando de 
ejecución de la ventana acoplable, el argumento adicional pasará al 
comando de punto de entrada. La siguiente es una demostración del 
lanzamiento de la misma imagen con los argumentos adicionales 
dados al comando de ejecución del docker: 
docker run entrypoint-demo con argumentos adicionales 
 
 
 
4.3.13 Instrucción	ONBUILD	
La instrucción ONBUILD registra una instrucción de compilación en 
una imagen y esta se desencadena cuando se crea otra imagen 
utilizando esta imagen como su imagen base. Cualquier instrucción 
de compilación puede registrarse como desencadenante y esas 
instrucciones se activarán inmediatamente después de la instrucción 
Sintácticamente, puede agregar más de una instrucción 
ENTRYPOINT en Dockerfile. Sin embargo, el sistema de 
compilación ignoraría todas las instrucciones 
ENTRYPOINTexcepto la última. En otras palabras, en el 
caso de múltiples instrucciones ENTRYPOINT, solo la 
última instrucción ENTRYPOINT sería efectiva. 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 41	
FROM en el archivo Dockerfile en sentido descendente. Por lo tanto, 
la instrucción ONBUILD se puede utilizar para diferir la ejecución de 
la instrucción de compilación desde la imagen base a la imagen 
objetivo. 
La sintaxis de la instrucción ONBUILD es la siguiente: 
ONBUILD <INSTRUCTION> 
 
Dentro de esto, <INSTRUCTION> es otra instrucción de 
compilación de Dockerfile, que se activará más tarde. La instrucción 
ONBUILD no permite el encadenamiento de otra instrucción 
ONBUILD. Además, no permite las instrucciones FROM y 
MAINTAINER como activadores ONBUILD. 
Aquí hay un ejemplo de la instrucción ONBUILD: 
ONBUILD ADD config /etc/appconfig 
 
4.4 Laboratorios 
 
Vamos a crear una imagen para ejecutar un archivo html en Apache. Para 
este ejemplo usaré comandos Linux, pero usted puede usar comandos o 
interfaces gráficas de Windows o Mac. 
• Creamos	primeramente	un	directorio	
mkdir lab1 
• Nos	posicionamosen	el	directorio	lab1	
• cd		/home/lab1	
• Ahora	creamos	nuestro	archivo	index.html9,	con	algún	tipo	de	
información,	y	lo	guardamos	en	el	directorio	lab1	
• Utilizamos	un	editor	de	texto	y	creamos	el	Dockerfile	
FROM ubuntu:16.04 
MAINTAINER Yo yo@gmail.com 
RUN apt-get update && apt-get -y install apache2 
EXPOSE 80 
CMD /usr/sbin/apache2ctl -D FOREGROUND 
• Construimos	la	imagen	
docker build –t lab1 . 
• Confirmamos	que	nuestra	imagen	se	ha	creado	
docker images 
• Corremos	nuestro	contenedor		
docker run -d -p 85:80 lab1 
• Verificamos	que	nuestro	contenedor	se	esta	ejecutando	
docker ps 
• Ahora	entramos	a	nuestro	navegador	y	tecleamos	lo	siguiente	
localhost:85 
• Debe	aparecer	la	siguiente	pantalla	
 
9	Utilice	Word	para	crear	mi	archivo	index.html,	revise	la	figura	4.2	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 42	
 
 
Figura 4.1 Prueba de ejecución de la imagen lab1 
 
Modifiquemos nuestro Dockerfile 
• Debemos	detener	el	contenedor	que	estamos	ejecutando	del	ejemplo	
anterior	
docker ps 
docker stop ID CONTAINER 
• Entramos	a	Dockerfile	e	introducimos	el	comando	
COPY index.html /var/www/html 
FROM ubuntu:16.04 
MAINTAINER Yo yo@gmail.com 
RUN apt-get update && apt-get -y install apache2 
COPY index.html /var/www/html 
EXPOSE 80 
CMD /usr/sbin/apache2ctl -D FOREGROUND 
• Volvemos	a	correr	el	comando	
docker build –t lab1 . 
• Ejecutamos	el	comando	
docker run -d -p 85:80 lab1 
• Ahora	entramos	a	nuestro	navegador	y	tecleamos	lo	siguiente	
• Localhost:85	
• Debe	aparecer	la	página	index.html	que	creo	anteriormente	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 43	
 
Figura 4.2 Despliegue de index.html usando un Dockerfile 
 
 
 
 
Laboratorio 2 (Ejemplo del blog de Albert Coronado10) 
 
Vamos a crear un Dockerfile utilizando dos archivos package json. 
• Crear	 un	 directorio	 y	 posicionarse	 en	 él	 y	 construir	 los	 siguientes	
archivos.	
=========Nombre del archivo: package.json=============== 
{ 
 "name": "docker_web_app", 
 "version": "1.0.0", 
 "description": "Node.js on Docker", 
 "author": "Yo mismo", 
 "main": "server.js", 
 "scripts": { 
 "start": "node server.js" 
 }, 
 "dependencies": { 
 "express": "^4.13.3" 
 } 
} 
 
 
 
 
 
10 https://www.albertcoronado.com/2019/11/13/formacion-docker-creando-imagenes-para-
nuestros-microservicios-y-dockerizar-aplicaciones/ 
	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 44	
=========Nombre del archivo server.js=========== 
'use strict'; 
 
const express = require('express'); 
const exec = require('child_process').execSync; 
 
// Constants 
const PORT = 8080; 
 
// App 
const app = express(); 
app.get('/', function (req, res) { 
 var result=""+exec( "ping -c 1 google.com" ); 
 
 while ( result.indexOf("\n")!=-1 ) 
 result=result.replace("\n","<br/>"); 
 
 res.send( '<h1>Test ping</h1>'+result ); 
}); 
 
app.listen(PORT); 
console.log('Running on http://localhost:' + PORT); 
 
==============Dockerfile================= 
FROM node:argon 
 
RUN mkdir -p /usr/src/app 
WORKDIR /usr/src/app 
 
COPY package.json /usr/src/app 
COPY server.js /usr/src/app 
 
RUN npm install 
 
EXPOSE 8080 
CMD ["npm","start"] 
 
• Ahora	construimos	la	imagen	utilizando	el	Dockerfile	
docker build -t appjs:latest . 
docker images # Verificar que se creo la imagen 
• Creamos	el	contenedor	usando	la	imagen	creada	
docker run -p 8080:8080 appjs:latest 
• Abrimos	nuestro	navegador	y	tecleamos	
localhost:8080 
• Debe	aparecer	una	imagen	similar	
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 45	
 
Figura 4.3 Pantalla de Prueba de Ping 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 46	
5. Publicación de Imágenes 
 
En este capítulo usaremos como base el capítulo “Publishing Images” del libro 
“Learning Docker” de Pethuru Raj. 
 
Publicación de las imágenes de Docker se refiere al almacenamiento de las 
mismas en repositorios públicos o privados para el uso de la comunidad 
mundial. Aprenderemos a usar a capacidad el Docker Hub y repositorios de 
confianzas para el almacenamientos de imágenes producidas por nosotros. 
 
Los repositorios de Docker Hub le permiten compartir imágenes con 
compañeros de trabajo, clientes o la comunidad de Docker en general. Si está 
construyendo sus imágenes internamente, ya sea en su propio daemon Docker o 
utilizando sus propios servicios de integración continua, puede insertarlos en un 
repositorio de Docker Hub que agregue a su cuenta de Docker Hub u 
organización. 
 
Alternativamente, si el código fuente de su imagen Docker está en GitHub o 
Bitbucket, puede usar un repositorio de "compilación automatizada", que está 
construido por los servicios de Docker Hub 
 
5.1 Entendiendo el Docker Hub 
Docker Hub es un lugar central utilizado para mantener las imágenes de 
Docker en un repositorio público o privado. Docker Hub proporciona 
funciones, como un repositorio de imágenes Docker, autenticaciones de 
usuarios, creación automatizada de imágenes, integración con GitHub o 
Bitbucket, y administración de organizaciones y grupos. El componente 
Docker Registry del Docker Hub gestiona el repositorio. 
Docker Registry es un sistema de almacenamiento utilizado para almacenar 
las imágenes. La creación automatizada es una característica de Docker 
Hub,. El siguiente diagrama muestra las características típicas: 
 
 
 
 
 
 
 
 
 
 
Figura 5.1 
Conformación del Docker Hub 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 47	
Para trabajar con Docker Hub, debe registrarse en Docker Hub y crear una 
cuenta usando el enlace en https://hub.docker.com/account/signup. Puede 
actualizar el nombre de usuario, la contraseña y la dirección de correo 
electrónico, como se muestra en la siguiente captura de pantalla: 
 
 
Figura 5.2 Registro en Docker Hub 
 
Después de completar el proceso de registro, debe completar la verificación 
recibida en un correo electrónico. Una vez completada la verificación del 
correo electrónico, verá algo similar a la siguiente captura de pantalla 
cuando inicie sesión en Docker Hub: 
 
 
Figura 5.3 Cuenta en Docker Hub 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 48	
5.2 Empujando Imágenes al Docker Hub 
 
Aquí, creamos una imagen Docker en la máquina local, y empujaremos esta 
imagen al Docker Hub. Debe realizar los siguientes pasos en esta sección: 
1. Cree	una	imagen	Docker	en	la	máquina	local	realizando	una	de	las	
siguientes	acciones:	
a. Usando	el	comando	docker	commit	
b. Usando	el	comando	docker	commit	con	Dockerfile	
2. Empuje	esta	imagen	creada	al	Docker	Hub.	
3. Borre	la	imagen	del	Docker	Hub.	
 
Vamos a crear una imagen ubuntu y también vamos a crear un archivo, un 
directorio y lo subiremos al Docker Hub. Los comandos serán los 
siguientes: 
docker run -i --name="contenedordeejemplo" -t ubuntu /bin/bash 
 
Unable to find image 'ubuntu:latest' locally 
latest: Pulling from library/ubuntu 
Digest: 
sha256:ec0e4e8bf2c1178e025099eed57c566959bb408c6b478c284c1683bc
4298b683 
Status: Downloaded newer image for ubuntu:latest 
 
root@5b4c56a3cef7:/# 
root@5b4c56a3cef7:/# mkdir minuevodir 
root@5b4c56a3cef7:/# cd minuevodir 
root@5b4c56a3cef7:/minuevodir# echo 'Este es mi nuevo contenedor 
para hacer una imagen y subirla al Docker Hub' >minuevoarchivo 
root@5b4c56a3cef7:/minuevodir# cat minuevoarchivo 
Este es mi nuevo contenedor para hacer una imagen y subirla al Docker 
Hub 
root@5b4c56a3cef7:/minuevodir# 
Salimos del contenedor sin detenerlo ctrl + pq 
Usaremos el comando commit para crear la nueva imagen 
docker commit -m="NuevaImagen" contenedordeejemplo 
pana507/imagenparahub 
sha256:86e6e9e421c8453742dcef5bf6a7e95f22085b3ce6d1ef736a4ee7f19
900fd14 
Nos conectamos al Docker Hub 
docker login 
Login with your Docker ID to push and pull images from Docker Hub. 
If you don't have a Docker ID, head over to https://hub.docker.com to 
create one. 
Username: pana507 
Password: 
Login Succeeded 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 49	
Colocamos la imagen creada en el Docker Hub 
docker push pana507/imagenparahub 
The push refers toa repository [docker.io/pana507/imagenparahub] 
63811b8fe7d9: Pushed 
f17fc24fb8d0: Mounted from library/ubuntu 
6458f770d435: Mounted from library/ubuntu 
5a876f8f1a3d: Mounted from library/ubuntu 
d2f8c05d353b: Mounted from library/ubuntu 
48e0baf45d4d: Mounted from library/ubuntu 
latest: digest: 
sha256:dd04e0e168581019b57c6ae78273f0b0ee0538df6e0a681be80a2801
5cfa10f1 size: 1564 
 
Comprobamos que la imagen se encuentra en nuestro repositorio en Docker 
Hub. 
 
Entramos a hub.docker.com, nos registramos con nuestra cuenta y debe 
aparecer la siguiente pantalla: 
 
 
Figura 5.4 Pantalla de repositorio personal en Docker Hub 
 
Vamos a detener el contenedor, borrar la imagen del repositorio local para 
luego ejecutar el comando run para que la misma se descargue directamente 
del Docker Hub. 
docker ps 
docker stop contenedordeejemplo 
docker rm contenedordeejemplo 
docker ps 
docker images 
docker rmi pana507/imagenparahub 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 50	
docker images 
docker run -i --name="nuevocontenedorparahub" -t 
pana507/imagenparahub /bin/bash 
Unable to find image 'pana507/imagenparahub:latest' locally 
latest: Pulling from pana507/imagenparahub 
50aff78429b1: Already exists 
f6d82e297bce: Already exists 
275abb2c8a6f: Already exists 
9f15a39356d6: Already exists 
fc0342a94c89: Already exists 
0b6d68de9675: Pull complete 
Digest: 
sha256:dd04e0e168581019b57c6ae78273f0b0ee0538df6e0a681be80a2801
5cfa10f1 
Status: Downloaded newer image for pana507/imagenparahub:latest 
root@8485fa1eedfd:/# 
ctrl + pq 
docker images 
 
Eliminamos la imagen del Docker Hub, entrando a nuestra cuenta y debe 
aparecer la siguiente pantalla: 
 
 
Figura 5.5 Cuenta en Dcoker Hub 
 
Debemos hacer click en DETAILS, y tomar la pestaña Settings y debe 
aparecer la siguiente pantalla: 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 51	
 
Figura 5.6 Pantalla para eliminar la imagen del Docker Hub 
 
Para eliminar la imagen creada debemos primero convertir el repositorio 
público en privado 
 
 
Figura 5.7 Convertir el repositorio publico a privado 
 
Nuevamente tomamos la opción Setting y ejecutamos la opción Delete, debe 
aparecer la siguiente pantalla: 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 52	
 
 
Figura 5.8 Pantalla para eliminar la imagen del Docker Hub 
 
 
5.3 Repositorios Privados Locales 
Docker Hub proporciona un repositorio público y privado. El repositorio 
público es gratuito para los usuarios y privado es un servicio pago. Los 
planes con repositorios privados están disponibles en diferentes tamaños, 
como una suscripción micro, pequeña, mediana o grande. 
 
Normalmente, a las empresas no les gusta conservar sus imágenes Docker en 
un repositorio público o privado de Docker. Prefieren mantener, dar 
mantenimiento y respaldar su propio repositorio. Por lo tanto, Docker 
también proporciona la opción para que las empresas creen e instalen su 
propio repositorio. 
 
Vamos a crear un repositorio en la máquina local usando la imagen de 
registro proporcionada por Docker. Vamos a ejecutar el contenedor de 
registro en la máquina local, utilizando la imagen de registro de Docker: 
docker run -p 5000:5000 -d registry 
Unable to find image 'registry:latest' locally 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 53	
latest: Pulling from library/registry 
ab7e51e37a18: Pull complete 
c8ad8919ce25: Pull complete 
5808405bc62f: Pull complete 
f6000d7b276c: Pull complete 
f792fdcd8ff6: Pull complete 
Digest: 
sha256:9d295999d330eba2552f9c78c9f59828af5c9a9c15a3fbd1351df03e
aad04c6a 
Status: Downloaded newer image for registry:latest 
12fe262e8dacab9acff71d8694fe56a19ebf5ca9981cc936ce864201a90800a6 
 
Debemos crear un tag para identificar la imagen dentro del repositorio 
docker tag 86e6e9e421c8 localhost:5000/pana507/imagenparahub 
 
Ahora hacemos un push a un nuevo registro 
docker push localhost:5000/pana507/imagenparahub 
The push refers to a repository [localhost:5000/pana507/imagenparahub] 
63811b8fe7d9: Pushed 
f17fc24fb8d0: Pushed 
6458f770d435: Pushed 
5a876f8f1a3d: Pushed 
d2f8c05d353b: Pushed 
48e0baf45d4d: Pushed 
latest: digest: 
sha256:dd04e0e168581019b57c6ae78273f0b0ee0538df6e0a681be80a28015cfa10
f1 size: 1564 
 
Si utilizamos un comando docker images se verá que la nueva imagen 
aparece en nuestro repositorio local y no en el Docker Hub. 
 
 
 
 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 54	
6. Trabajando con Contenedores 
 
 Para está sección del curso nos basaremos del manual escrito por Evaristo 
García Zambrana11, el cual nos brinda buenos ejemplos para trabajar Docker. 
También nos apoyaremos del libro Docker Quick Start Guide12. 
 
6.1 Ejecutar o crear un nuevo contenedor 
Antes de ejecutar un contenedor debemos estar seguro que contamos con la 
imagen o imágenes necesarias para construir nuestro contenedor. Para eso 
usaremos el comnado docker image ls, el cual mostrará la lista y sus 
columnas de propiedades. 
 
 
 
 Figura 6.1 Comando docker image ls 
 
A partir del 2017, por la gran cantidad de comandos y opciones asociadas 
que se han ido creando con cada versión nueva de Docker, se decidió que los 
comandos de la CLI se divirían en grupos funcionales de administración. 
Ahora hay un grupo de administración de contenedores y otro grupo de 
administración de imagenés. Esto lleva un cambio en la ejecución de 
comandos en Docker. 
 
# el commando con la nueva sintaxis... 
docker container run hello-world 
# el commando con la vieja sintaxis… 
docker run hello-world 
 
Estos cambios permiten una mejor visibilidad de los comandos, pero Docker 
todavía reconoce los comandos con la vieja sintaxis. 
 
Usted puede utilizar el comando docker container para conocer los 
comandos asociados a la versión de Docker que esta utilizando. 
 
 
 
11	Docker	y	Docker	Swarm,	IES	Gonzalo	Nazareno,	Dos	Hermanas	(Sevilla),	2017	
12	Docker	Quick	Start	Guide,	Earl	Waud,	Packt,	2018	
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 55	
6.2 Comando version 
 
Este es comando es muy útil para conocer los detalles de la versión de 
Docker instalado en su equipo. 
 
docker version 
 
 
 
Figura 6.2 Salida del comando docker version 
 
Recuerde que todos los comandos de Docker tienen incorporado un 
rico sistema de ayuda. Pruébelo ingresando cualquier parte de un comando 
de Docker y utilizando el parámetro --help. Por ejemplo, 
docker container run --help 
 
6.3 Comando container run 
 
Ya este comando lo hemos usado anteriormente en su formato de sintaxis 
antiguo 
 
docker run hello-world 
 
Con la sintaxis nueva sería 
 
docker container run hello-world 
 
Este comando le dice a Docker que desea ejecutar un contenedor basado en 
la imagen descrita como hello-world. Puede que se pregunte: ¿se instaló la 
imagen del contenedor hello-world cuando instalé Docker? La respuesta es 
no. El comando docker run mirará el caché de la imagen del contenedor 
local para ver si hay una imagen del contenedor que coincida con la 
descripción del contenedor solicitado. Si lo hay, Docker ejecutará el 
contenedor desde la imagen en caché. Si la imagen del contenedor deseada 
MANUAL	DE	DOCKER	–	Dr.Armando	Jipsion	 56	
no se encuentra en el caché, Docker se comunicará con Docker registry para 
intentar descargar la imagen del contenedor, almacenándola en el caché local 
en el proceso. Docker ejecutará el contenedor recién descargado desde el 
caché. 
 
El Docker registry es un almacén central donde se almacenan las imagenés 
que se utilizan para la construcción de contenedores. Por ahora, solo 
comprenda que hay un caché de imágenes local y un almacén de imágenes 
remotas. Se puede descargar imagenés desde el registry utilizando el 
comando: docker image pull ….. Por ejemplo, 
 
docker image pull hello-world 
 
La descripción de cada imagen de contenedor consta de tres partes: 
• Nombre	de	host	del	registro	de	Docker	
• Nombre	separado	por	barra	
• Nombre	de	etiqueta	(TAG)	
 
La primera parte, el nombre de host del registro, no lo hemos visto ni 
utilizado todavía,