Este tutorial le guiará a través del proceso de clonación de una imagen de contenedor Docker. Las imágenes Docker son plantillas empaquetadas que contienen todo lo necesario para ejecutar una aplicación, y la clonación le permite crear copias que luego puede personalizar. Al final de esta guía, comprenderá cómo clonar una imagen Docker, modificarla y compartirla para su despliegue.
Antes de comenzar a clonar imágenes Docker, es importante entender qué es Docker y verificar que nuestro entorno esté correctamente configurado.
Docker es una plataforma que utiliza contenedores para desarrollar, desplegar y ejecutar aplicaciones. Los contenedores empaquetan una aplicación con todas sus dependencias, asegurando que funcione consistentemente en diferentes entornos. Esto hace que Docker sea particularmente útil para los flujos de trabajo de desarrollo y despliegue.
Primero, asegurémonos de que Docker esté correctamente instalado en nuestro sistema. Abra una ventana de terminal y ejecute:
docker --versionDebería ver una salida similar a:
Docker version 20.10.21, build baeda1fA continuación, verifique que el servicio Docker se esté ejecutando:
sudo systemctl status dockerLa salida debería indicar que Docker está activo (en ejecución). Si no se está ejecutando, puede iniciarlo con:
sudo systemctl start dockerEjecutemos un comando de prueba simple para verificar que Docker esté funcionando correctamente:
docker run hello-worldEste comando descarga y ejecuta la imagen hello-world, que imprime un mensaje de confirmación y sale. Debería ver una salida similar a:
Hello from Docker!
This message shows that your installation appears to be working correctly.Para ver qué imágenes Docker están actualmente disponibles en su sistema, ejecute:
docker imagesEste comando lista todas las imágenes Docker que están actualmente almacenadas localmente. La salida muestra el repositorio de la imagen, la etiqueta (tag), el ID de la imagen, la fecha de creación y el tamaño.
Ahora que hemos confirmado que Docker funciona correctamente, estamos listos para comenzar a trabajar con imágenes Docker en el siguiente paso.
En este paso, descargaremos una imagen Docker de Docker Hub y la ejecutaremos en nuestro sistema local. Este es el primer paso en el proceso de clonación de una imagen Docker.
Docker Hub es un servicio de registro basado en la nube donde los usuarios pueden encontrar y compartir imágenes de contenedores. Contiene muchas imágenes oficiales mantenidas por los proveedores de software, así como imágenes contribuidas por la comunidad.
Descarguemos la imagen oficial del servidor web Nginx de Docker Hub. Nginx es un servidor web popular que usaremos como ejemplo a lo largo de este tutorial.
Ejecute el siguiente comando para descargar la imagen Nginx:
docker pull nginx:latestEste comando descarga la última versión de la imagen Nginx. Debería ver una salida que muestre el progreso de la descarga:
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
186b1aaa4aa6: Pull complete
b4df32aa5a72: Pull complete
a0bcbecc962e: Pull complete
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latestPara confirmar que la imagen se ha descargado correctamente, liste sus imágenes Docker nuevamente:
docker imagesAhora debería ver la imagen Nginx en la lista:
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 2 weeks ago 142MBAhora ejecutemos un contenedor basado en la imagen Nginx que acabamos de descargar:
docker run --name my-nginx -d -p 8080:80 nginxEste comando hace lo siguiente:
--name my-nginx: Nombra nuestro contenedor "my-nginx"-d: Ejecuta el contenedor en modo desasociado (en segundo plano)-p 8080:80: Mapea el puerto 8080 en nuestro host al puerto 80 en el contenedornginx: Usa la imagen Nginx que descargamos anteriormenteDebería ver una cadena larga de salida, que es el ID del contenedor.
Para verificar si el contenedor se está ejecutando:
docker psDebería ver una salida similar a:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f8d3e9c5b9a7 nginx "/docker-entrypoint.…" 30 seconds ago Up 29 seconds 0.0.0.0:8080->80/tcp my-nginxAhora puede acceder a la página predeterminada de Nginx abriendo un navegador web y navegando a http://localhost:8080 o usando curl:
curl http://localhost:8080Debería ver el contenido HTML de la página de bienvenida de Nginx.
Ahora que hemos descargado y ejecutado con éxito una imagen Docker, estamos listos para crear nuestra propia imagen personalizada basada en ella en el siguiente paso.
Ahora que tenemos un contenedor Nginx en ejecución, crearemos una imagen personalizada modificándolo. Este es el núcleo del proceso de clonación. Haremos lo siguiente:
Las imágenes Docker se pueden crear de dos maneras:
Usaremos el segundo enfoque en este tutorial, ya que es más sencillo para comprender el proceso de clonación.
Primero, creemos un archivo HTML personalizado para reemplazar la página de bienvenida predeterminada de Nginx. Necesitamos entrar en el contenedor en ejecución y modificar sus archivos.
Use el siguiente comando para ejecutar un shell dentro del contenedor en ejecución:
docker exec -it my-nginx bashEsto abre un shell bash interactivo dentro del contenedor. Ahora, creemos un archivo HTML personalizado:
echo "<html><body><h1>Mi Imagen Docker Personalizada</h1><p>Esta es una imagen Nginx personalizada creada en el tutorial LabEx.</p></body></html>" > /usr/share/nginx/html/index.htmlPuede verificar el cambio comprobando el contenido del archivo:
cat /usr/share/nginx/html/index.htmlAhora salga del shell del contenedor:
exitProbemos si nuestros cambios se aplicaron accediendo al servidor Nginx nuevamente:
curl http://localhost:8080Ahora debería ver nuestro contenido HTML personalizado en lugar de la página de bienvenida predeterminada de Nginx.
Ahora que hemos modificado el contenedor, crearemos una nueva imagen que incluya estos cambios. Esto se hace usando el comando docker commit:
docker commit my-nginx my-custom-nginx:v1Este comando crea una nueva imagen llamada my-custom-nginx con la etiqueta v1 basada en el estado actual del contenedor my-nginx.
Verifiquemos que nuestra nueva imagen se haya creado:
docker imagesDebería ver su nueva imagen en la lista:
REPOSITORY TAG IMAGE ID CREATED SIZE
my-custom-nginx v1 a1b2c3d4e5f6 10 seconds ago 142MB
nginx latest 605c77e624dd 2 weeks ago 142MBAhora, detengamos y eliminemos el contenedor original, y luego ejecutemos un nuevo contenedor basado en nuestra imagen personalizada:
docker stop my-nginx
docker rm my-nginx
docker run --name my-custom-container -d -p 8081:80 my-custom-nginx:v1Estos comandos:
Verifiquemos que nuestro nuevo contenedor se esté ejecutando correctamente:
docker psDebería ver su nuevo contenedor en la lista:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
g9h8i7j6k5l4 my-custom-nginx:v1 "/docker-entrypoint.…" 10 seconds ago Up 9 seconds 0.0.0.0:8081->80/tcp my-custom-containerAhora, acceda al servidor Nginx en el nuevo puerto:
curl http://localhost:8081Debería ver el mismo contenido HTML personalizado, confirmando que nuestra nueva imagen contiene los cambios que hicimos.
¡Felicitaciones! Ha clonado con éxito una imagen Docker y la ha personalizado. En el siguiente paso, aprenderemos a compartir esta imagen personalizada.
Ahora que hemos creado una imagen Docker personalizada, aprenderemos a etiquetarla correctamente y a prepararla para compartirla. En un escenario del mundo real, enviaría la imagen a un registro como Docker Hub, pero en este tutorial, nos centraremos en los pasos de preparación.
Las imágenes Docker se identifican por el nombre de su repositorio y su etiqueta. Las etiquetas ayudan en el versionado y la organización de las imágenes. La etiqueta predeterminada es latest, pero es una buena práctica usar etiquetas de versión significativas.
Agreguemos algunas etiquetas más a nuestra imagen personalizada:
docker tag my-custom-nginx:v1 my-custom-nginx:latest
docker tag my-custom-nginx:v1 my-custom-nginx:stableEstos comandos crean dos etiquetas adicionales para nuestra imagen: latest y stable. Los datos reales de la imagen se comparten entre las tres etiquetas, por lo que esta operación es muy eficiente.
Comprobemos nuestras imágenes de nuevo:
docker imagesAhora debería ver múltiples entradas para my-custom-nginx:
REPOSITORY TAG IMAGE ID CREATED SIZE
my-custom-nginx v1 a1b2c3d4e5f6 10 minutes ago 142MB
my-custom-nginx latest a1b2c3d4e5f6 10 minutes ago 142MB
my-custom-nginx stable a1b2c3d4e5f6 10 minutes ago 142MB
nginx latest 605c77e624dd 2 weeks ago 142MBObserve que todas las imágenes my-custom-nginx tienen el mismo ID de imagen, lo que indica que son la misma imagen con diferentes etiquetas.
En un escenario del mundo real, enviaría su imagen a un registro como Docker Hub. Para hacer esto, necesitaría:
Para fines de demostración, supongamos que su nombre de usuario de Docker Hub es su_nombre_de_usuario. Así es como prepararía su imagen para enviarla:
docker tag my-custom-nginx:v1 yourusername/my-custom-nginx:v1Para enviar la imagen (en un escenario real), usaría:
## Esto es solo para demostración - realmente no enviaremos
## docker push yourusername/my-custom-nginx:v1En lugar de enviar a un registro, también puede guardar una imagen Docker en un archivo para la transferencia manual:
docker save -o my-custom-nginx.tar my-custom-nginx:v1Este comando guarda la imagen en un archivo tar llamado my-custom-nginx.tar. Puede verificar que el archivo se creó:
ls -lh my-custom-nginx.tarDebería ver una salida similar a:
-rw------- 1 labex labex 142M Nov 10 12:34 my-custom-nginx.tarPara cargar una imagen desde un archivo tar en otra máquina (o en la misma máquina después de eliminar la imagen), usaría:
## No ejecutaremos realmente este comando como parte del tutorial
## docker load -i my-custom-nginx.tarPara ayudar a otros a comprender su imagen personalizada, es una buena práctica documentar los cambios que ha realizado. Creemos un archivo de documentación simple:
cat > my-custom-nginx-doc.txt << EOF
## Mi Imagen Nginx Personalizada
Esta es una imagen Nginx personalizada creada clonando la imagen oficial de Nginx.
### Cambios Realizados
- Se reemplazó la página de bienvenida predeterminada con una página HTML personalizada
### Cómo Ejecutar
docker run --name my-custom-container -d -p 8080:80 my-custom-nginx:v1
### Historial de Versiones
- v1: Versión personalizada inicial con página de bienvenida modificada
EOFAhora tiene un archivo de documentación para su imagen personalizada.
¡Felicitaciones! Ha aprendido a etiquetar su imagen Docker y a prepararla para compartirla. En el siguiente paso, repasaremos algunas mejores prácticas y limpiaremos nuestro entorno.
En este paso final, cubriremos algunas de las mejores prácticas para trabajar con imágenes Docker y limpiaremos nuestro entorno.
Siempre use etiquetas de versión específicas en lugar de depender de la etiqueta latest. Esto asegura la consistencia en sus implementaciones.
## Mejor enfoque
docker pull nginx:1.23.2
## Menos predecible
docker pull nginx:latestLas imágenes más pequeñas son más rápidas de descargar y usan menos almacenamiento. Considere usar imágenes basadas en Alpine cuando sea posible:
## Veamos la diferencia de tamaño
docker pull nginx:alpine
docker images | grep nginxPuede ver una salida como:
nginx alpine 2bc7edbc3cf2 2 weeks ago 40.7MB
nginx latest 605c77e624dd 2 weeks ago 142MB¡La versión Alpine es significativamente más pequeña!
Al crear imágenes con un Dockerfile, use construcciones de múltiples etapas para mantener la imagen final pequeña. Aquí hay un ejemplo simple (no necesita ejecutar esto):
## Etapa de construcción
FROM golang:1.17 AS builder
WORKDIR /app
COPY . .
RUN go build -o app
## Etapa final
FROM alpine:3.15
COPY --from=builder /app/app /app
CMD ["/app"]Siempre mantenga la documentación de sus imágenes personalizadas, incluyendo:
Creamos un archivo de documentación simple en el paso anterior.
Escanee regularmente sus imágenes en busca de vulnerabilidades:
## Ejemplo de escaneo (Docker Desktop tiene esto integrado)
## docker scan my-custom-nginx:v1Exploremos un comando útil para inspeccionar imágenes Docker:
docker inspect my-custom-nginx:v1Este comando muestra información detallada sobre la imagen, incluyendo sus capas, configuración y variables de entorno.
Puede ver el historial de cómo se construyó una imagen:
docker history my-custom-nginx:v1Esto muestra cada capa de la imagen y los comandos que las crearon.
Ahora, limpiemos nuestro entorno eliminando los contenedores y las imágenes que creamos:
docker stop my-custom-container
docker rm my-custom-containerdocker rmi my-custom-nginx:v1 my-custom-nginx:latest my-custom-nginx:stabledocker rmi nginx:latest nginx:alpinedocker ps -a
docker imagesDocker proporciona un comando conveniente para limpiar los recursos no utilizados:
docker system pruneEsto elimina todos los contenedores detenidos, las redes no utilizadas, las imágenes colgantes y la caché de construcción. Se le pedirá que confirme antes de continuar.
Para una limpieza más agresiva, puede usar:
docker system prune -aEsto elimina adicionalmente todas las imágenes no utilizadas, no solo las colgantes.
Ahora ha aprendido a:
Estas habilidades forman la base del trabajo con imágenes Docker y serán valiosas a medida que continúe su viaje con la containerización.
En este tutorial práctico, ha aprendido el proceso completo de clonar una imagen de contenedor Docker. Comenzó entendiendo los conceptos básicos de Docker y verificando su entorno. Luego, descargó una imagen oficial de Nginx y la ejecutó como un contenedor. A continuación, personalizó este contenedor modificando su contenido y confirmó esos cambios para crear su propia imagen personalizada.
También aprendió a etiquetar correctamente sus imágenes para el versionado y la distribución, cómo guardar imágenes en archivos para la transferencia manual y cómo documentar sus cambios. Finalmente, exploró las mejores prácticas para trabajar con imágenes Docker y limpió su entorno.
Estas habilidades proporcionan una base sólida para trabajar con Docker en entornos de desarrollo y producción. Ahora puede crear y personalizar con confianza imágenes Docker para que se ajusten a sus requisitos específicos, haciendo que sus aplicaciones sean más portátiles y consistentes en diferentes entornos.
