Cómo usar el comando docker container commit para crear nuevas imágenes

Introducción

En este laboratorio, aprenderás a usar el comando docker container commit para crear nuevas imágenes de Docker a partir de contenedores existentes. Comenzaremos lanzando y modificando un contenedor, luego confirmaremos (commit) esos cambios en una nueva imagen.

También explorarás cómo confirmar cambios en contenedores con nuevas configuraciones, incluyendo la configuración de nuevas instrucciones CMD y EXPOSE, demostrando la flexibilidad de crear imágenes personalizadas basadas en contenedores en ejecución.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/rm("Remove Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/images("List Images") subgraph Lab Skills docker/run -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} docker/ps -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} docker/rm -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} docker/inspect -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} docker/pull -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} docker/images -.-> lab-555104{{"Cómo usar el comando docker container commit para crear nuevas imágenes"}} end

Iniciar y modificar un contenedor

En este paso, aprenderás cómo iniciar un contenedor de Docker y realizar cambios dentro de él. Utilizaremos una imagen simple de Ubuntu para demostrar el proceso.

Primero, descarguemos la imagen de Ubuntu. Este comando descarga la imagen de Ubuntu desde Docker Hub a tu máquina local.

docker pull ubuntu:latest

Deberías ver una salida que indica que la imagen se está descargando. Una vez completada la descarga, puedes ejecutar un contenedor basado en esta imagen.

Ahora, ejecutemos un contenedor interactivo usando la imagen de Ubuntu. Los flags -it se utilizan para asignar una pseudo-TTY y mantener stdin abierto, permitiéndote interactuar con el shell del contenedor. El flag --name asigna un nombre al contenedor, facilitando su referencia posterior.

docker run -it --name my-ubuntu ubuntu:latest /bin/bash

Después de ejecutar este comando, estarás dentro del shell bash del contenedor. Puedes verificarlo comprobando el hostname, que será el ID del contenedor.

Dentro del contenedor, creemos un archivo simple. Usaremos el comando echo para escribir texto en un archivo llamado hello.txt en el directorio raíz.

echo "Hello from inside the container!" > /hello.txt

Puedes verificar que el archivo fue creado y contiene el contenido correcto usando el comando cat.

cat /hello.txt

Deberías ver la salida "Hello from inside the container!".

Ahora que hemos realizado un cambio dentro del contenedor, salgamos del shell del contenedor.

exit

Ahora estás de vuelta en la terminal de tu máquina host. El contenedor sigue ejecutándose en segundo plano. Puedes verificarlo listando los contenedores en ejecución.

docker ps

Deberías ver el contenedor my-ubuntu en la lista.

Guardar cambios del contenedor en una nueva imagen

En el paso anterior, realizamos cambios dentro de un contenedor en ejecución creando un archivo. Ahora aprenderemos cómo guardar estos cambios como una nueva imagen Docker. Este proceso se denomina "commit" (confirmación) de un contenedor.

Al hacer commit de un contenedor, se crea una nueva imagen que incluye los cambios realizados en el sistema de archivos y configuración del contenedor. Esto es útil para crear imágenes personalizadas basadas en imágenes existentes.

Para confirmar los cambios del contenedor, usamos el comando docker commit. La sintaxis básica es docker commit [nombre_contenedor] [nombre_nueva_imagen]. Vamos a confirmar el contenedor my-ubuntu y nombrar la nueva imagen como my-ubuntu-modified.

docker commit my-ubuntu my-ubuntu-modified

Deberías ver una cadena larga de caracteres como salida, que corresponde al ID de la nueva imagen creada.

Ahora, verifiquemos que la nueva imagen se ha creado. Podemos usar el comando docker images para listar todas las imágenes en tu sistema.

docker images

Deberías ver my-ubuntu-modified en la lista, junto con la imagen original ubuntu.

Para confirmar que los cambios se guardaron en la nueva imagen, ejecutemos un nuevo contenedor basado en my-ubuntu-modified y verifiquemos el archivo que creamos en el paso anterior.

docker run -it --name my-ubuntu-test my-ubuntu-modified /bin/bash

Una vez dentro del nuevo contenedor, verifica la existencia del archivo /hello.txt.

cat /hello.txt

Deberías ver la salida "Hello from inside the container!", lo que confirma que los cambios se guardaron correctamente en la nueva imagen.

Ahora, sal del contenedor.

exit

Finalmente, limpiemos el contenedor de prueba que acabamos de crear.

docker rm -f my-ubuntu-test

Confirmar cambios en contenedores con nuevas configuraciones

En este paso, exploraremos cómo confirmar cambios en contenedores incluyendo también nuevas configuraciones para la imagen resultante. Esto permite definir aspectos como el comando predeterminado al iniciar un contenedor o variables de entorno.

Continuaremos usando el contenedor my-ubuntu de los pasos anteriores. Primero, detengamos el contenedor ya que confirmaremos su estado actual.

docker stop my-ubuntu

Deberías ver el nombre del contenedor my-ubuntu impreso como salida, indicando que se ha detenido.

Ahora, confirmemos el contenedor y agreguemos una etiqueta (label) a la nueva imagen. Las etiquetas son pares clave-valor que pueden adjuntarse a imágenes para añadir metadatos. Añadiremos una etiqueta indicando la versión de nuestra imagen modificada. Usamos el flag -c seguido de la instrucción de configuración.

docker commit -c 'LABEL version="1.0"' my-ubuntu my-ubuntu-labeled

Deberías ver el ID de la nueva imagen creada como salida.

Verifiquemos que la nueva imagen my-ubuntu-labeled se ha creado y que la etiqueta se ha aplicado. Podemos usar el comando docker inspect para ver información detallada de la imagen.

docker inspect my-ubuntu-labeled

La salida será un objeto JSON extenso. Busca la sección "Labels" dentro del bloque "Config". Deberías encontrar "version": "1.0" listado allí.

Alternativamente, puedes usar docker inspect con filtrado para verificar específicamente la etiqueta.

docker inspect --format '{{.Config.Labels}}' my-ubuntu-labeled

Este comando mostrará solo las etiquetas asociadas a la imagen. Deberías ver algo como map[version:1.0].

También podemos añadir otras configuraciones durante el proceso de confirmación, como establecer una variable de entorno. Confirmemos nuevamente el contenedor my-ubuntu, esta vez añadiendo una variable de entorno.

docker commit -c 'ENV MY_VARIABLE="Hello Docker"' my-ubuntu my-ubuntu-env

Verifica la nueva imagen y la variable de entorno usando docker inspect.

docker inspect --format '{{.Config.Env}}' my-ubuntu-env

Deberías ver una salida similar a [PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin MY_VARIABLE=Hello Docker], confirmando que la variable de entorno está configurada.

Confirmar cambios en contenedores con instrucciones CMD y EXPOSE

En este paso final, aprenderemos cómo confirmar cambios en contenedores estableciendo el comando predeterminado (CMD) y los puertos expuestos (EXPOSE) para la nueva imagen.

La instrucción CMD define el comando predeterminado que se ejecutará cuando se inicie un contenedor desde la imagen sin especificar un comando. La instrucción EXPOSE informa a Docker que el contenedor escucha en los puertos de red especificados durante su ejecución.

Confirmaremos nuevamente el contenedor my-ubuntu, esta vez estableciendo un comando predeterminado para mostrar el contenido de /hello.txt y exponiendo el puerto 80.

Primero, asegúrate de que el contenedor my-ubuntu esté detenido.

docker stop my-ubuntu

Ahora, confirma el contenedor con las instrucciones CMD y EXPOSE. Nota que la instrucción CMD se proporciona como un array JSON de strings.

docker commit -c 'CMD ["cat", "/hello.txt"]' -c 'EXPOSE 80' my-ubuntu my-ubuntu-final

Deberías ver el ID de la nueva imagen creada como salida.

Verifiquemos las configuraciones CMD y EXPOSE de la nueva imagen my-ubuntu-final usando docker inspect.

docker inspect --format '{{.Config.Cmd}}' my-ubuntu-final

Esto debería mostrar [cat /hello.txt], confirmando que el comando predeterminado está configurado.

Ahora, revisemos los puertos expuestos.

docker inspect --format '{{.Config.ExposedPorts}}' my-ubuntu-final

Deberías ver una salida similar a map[80/tcp:{}], indicando que el puerto 80 está expuesto.

Finalmente, ejecutemos un contenedor desde esta nueva imagen sin especificar un comando para verificar si el CMD predeterminado funciona.

docker run --rm my-ubuntu-final

El flag --rm elimina automáticamente el contenedor cuando finaliza. Como el comando predeterminado es cat /hello.txt, el contenedor debería ejecutarse, mostrar "Hello from inside the container!" y luego finalizar.

Deberías ver "Hello from inside the container!" impreso en tu terminal.

Esto demuestra cómo puedes confirmar cambios en contenedores y definir el comportamiento predeterminado y la configuración de red de la imagen resultante.

Resumen

En este laboratorio, aprendiste cómo iniciar y modificar un contenedor Docker. Descargaste una imagen de Ubuntu, ejecutaste un contenedor interactivo basado en ella, creaste un archivo dentro del contenedor y luego saliste del shell del contenedor manteniéndolo en ejecución.

Posteriormente, aprendiste cómo confirmar (commit) los cambios realizados dentro de un contenedor en ejecución para crear una nueva imagen Docker. Este proceso te permite guardar el estado actual de un contenedor como una imagen reutilizable.