Guía Paso a Paso para Clonar una Imagen de Contenedor Docker

Introducción

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.

Entendiendo Docker y Verificando su Entorno

Antes de comenzar a clonar imágenes Docker, es importante entender qué es Docker y verificar que nuestro entorno esté correctamente configurado.

¿Qué es Docker?

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.

Verificando la Instalación de Docker

Primero, asegurémonos de que Docker esté correctamente instalado en nuestro sistema. Abra una ventana de terminal y ejecute:

docker --version

Debería ver una salida similar a:

Docker version 20.10.21, build baeda1f

A continuación, verifique que el servicio Docker se esté ejecutando:

sudo systemctl status docker

La salida debería indicar que Docker está activo (en ejecución). Si no se está ejecutando, puede iniciarlo con:

sudo systemctl start docker

Probando la Funcionalidad de Docker

Ejecutemos un comando de prueba simple para verificar que Docker esté funcionando correctamente:

docker run hello-world

Este 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.

Listando Imágenes Docker

Para ver qué imágenes Docker están actualmente disponibles en su sistema, ejecute:

docker images

Este 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.

Descargando y Ejecutando una Imagen Docker

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.

¿Qué es Docker Hub?

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.

Descargando una Imagen de Docker Hub

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:latest

Este 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:latest

Verificando la Imagen Descargada

Para confirmar que la imagen se ha descargado correctamente, liste sus imágenes Docker nuevamente:

docker images

Ahora debería ver la imagen Nginx en la lista:

REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    605c77e624dd   2 weeks ago    142MB

Ejecutando el Contenedor Docker Nginx

Ahora ejecutemos un contenedor basado en la imagen Nginx que acabamos de descargar:

docker run --name my-nginx -d -p 8080:80 nginx

Este 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 contenedor
• nginx: Usa la imagen Nginx que descargamos anteriormente

Debería ver una cadena larga de salida, que es el ID del contenedor.

Verificando el Contenedor en Ejecución

Para verificar si el contenedor se está ejecutando:

docker ps

Deberí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-nginx

Ahora 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:8080

Deberí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.

Creando una Imagen Docker Personalizada

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:

1. Realizar cambios en el contenedor en ejecución
2. Crear una nueva imagen a partir de estos cambios
3. Ejecutar un contenedor basado en nuestra nueva imagen

Entendiendo la Creación de Imágenes Docker

Las imágenes Docker se pueden crear de dos maneras:

1. Usando un Dockerfile (el enfoque recomendado para producción)
2. Confirmando los cambios realizados en un contenedor en ejecución (útil para la exploración y la experimentación)

Usaremos el segundo enfoque en este tutorial, ya que es más sencillo para comprender el proceso de clonación.

Modificando el Contenedor en Ejecució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 bash

Esto 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.html

Puede verificar el cambio comprobando el contenido del archivo:

cat /usr/share/nginx/html/index.html

Ahora salga del shell del contenedor:

exit

Probando los Cambios

Probemos si nuestros cambios se aplicaron accediendo al servidor Nginx nuevamente:

curl http://localhost:8080

Ahora debería ver nuestro contenido HTML personalizado en lugar de la página de bienvenida predeterminada de Nginx.

Creando una Nueva Imagen a partir del Contenedor Modificado

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:v1

Este comando crea una nueva imagen llamada my-custom-nginx con la etiqueta v1 basada en el estado actual del contenedor my-nginx.

Verificando la Nueva Imagen

Verifiquemos que nuestra nueva imagen se haya creado:

docker images

Deberí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      142MB

Ejecutando un Contenedor desde la Nueva Imagen

Ahora, 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:v1

Estos comandos:

1. Detienen el contenedor original
2. Eliminan el contenedor original
3. Crean un nuevo contenedor basado en nuestra imagen personalizada, mapeado al puerto 8081

Probando el Nuevo Contenedor

Verifiquemos que nuestro nuevo contenedor se esté ejecutando correctamente:

docker ps

Deberí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-container

Ahora, acceda al servidor Nginx en el nuevo puerto:

curl http://localhost:8081

Deberí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.

Etiquetando y Compartiendo su Imagen Docker

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.

Entendiendo las Etiquetas de las Imágenes Docker

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.

Agregando Más Etiquetas a su Imagen

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:stable

Estos 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.

Verificando las Etiquetas

Comprobemos nuestras imágenes de nuevo:

docker images

Ahora 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      142MB

Observe 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.

Preparándose para la Distribución de Imágenes

En un escenario del mundo real, enviaría su imagen a un registro como Docker Hub. Para hacer esto, necesitaría:

1. Crear una cuenta en Docker Hub
2. Iniciar sesión en Docker Hub desde su terminal
3. Etiquetar su imagen con su nombre de usuario de Docker Hub
4. Enviar la imagen

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:v1

Para enviar la imagen (en un escenario real), usaría:

## Esto es solo para demostración - realmente no enviaremos
## docker push yourusername/my-custom-nginx:v1

Guardando una Imagen Docker en un Archivo

En 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:v1

Este 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.tar

Debería ver una salida similar a:

-rw------- 1 labex labex 142M Nov 10 12:34 my-custom-nginx.tar

Cargando una Imagen desde un Archivo

Para 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.tar

Exportando la Documentación del Contenedor

Para 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
EOF

Ahora 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.

Mejores Prácticas y Limpieza

En este paso final, cubriremos algunas de las mejores prácticas para trabajar con imágenes Docker y limpiaremos nuestro entorno.

Mejores Prácticas para Imágenes Docker

1. Use Etiquetas Específicas

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:latest

2. Mantenga las Imágenes Pequeñas

Las 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 nginx

Puede 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!

3. Use Construcciones de Múltiples Etapas (Multi-Stage Builds)

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"]

4. Documente sus Imágenes

Siempre mantenga la documentación de sus imágenes personalizadas, incluyendo:

• Para qué es la imagen
• Cómo usarla
• Qué cambios ha realizado
• Cualquier opción de configuración

Creamos un archivo de documentación simple en el paso anterior.

5. Escanee en Busca de Vulnerabilidades

Escanee regularmente sus imágenes en busca de vulnerabilidades:

## Ejemplo de escaneo (Docker Desktop tiene esto integrado)
## docker scan my-custom-nginx:v1

Inspeccionando Imágenes Docker

Exploremos un comando útil para inspeccionar imágenes Docker:

docker inspect my-custom-nginx:v1

Este comando muestra información detallada sobre la imagen, incluyendo sus capas, configuración y variables de entorno.

Visualizando el Historial de la Imagen

Puede ver el historial de cómo se construyó una imagen:

docker history my-custom-nginx:v1

Esto muestra cada capa de la imagen y los comandos que las crearon.

Limpieza

Ahora, limpiemos nuestro entorno eliminando los contenedores y las imágenes que creamos:

1. Primero, detenga y elimine nuestro contenedor personalizado:

docker stop my-custom-container
docker rm my-custom-container

2. Elimine las imágenes que creamos:

docker rmi my-custom-nginx:v1 my-custom-nginx:latest my-custom-nginx:stable

3. Opcionalmente, elimine la imagen Nginx:

docker rmi nginx:latest nginx:alpine

4. Verifique que todos los contenedores e imágenes hayan sido eliminados:

docker ps -a
docker images

Usando Docker System Prune

Docker proporciona un comando conveniente para limpiar los recursos no utilizados:

docker system prune

Esto 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 -a

Esto elimina adicionalmente todas las imágenes no utilizadas, no solo las colgantes.

Conclusión

Ahora ha aprendido a:

1. Descargar y ejecutar imágenes Docker
2. Modificar contenedores en ejecución
3. Confirmar cambios para crear nuevas imágenes personalizadas
4. Etiquetar imágenes para organización y distribución
5. Guardar imágenes en archivos para transferencia manual
6. Documentar sus imágenes personalizadas
7. Limpiar su entorno Docker

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.

Resumen

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.