Cómo usar el comando docker buildx history open para ver detalles de compilación

Introducción

En este laboratorio, aprenderás a utilizar el comando docker buildx history open para ver información detallada sobre tus construcciones (builds) de Docker. Comenzarás construyendo una imagen simple de Docker usando un Dockerfile, que describe los pasos para crear la imagen.

Después de construir la imagen, explorarás cómo listar el historial de tus construcciones. Finalmente, utilizarás el comando docker buildx history open para abrir e inspeccionar los detalles de una construcción específica directamente dentro de Docker Desktop, proporcionando una visión visual y completa del proceso de construcción.

Skills Graph

Construir una imagen simple de Docker

En este paso, aprenderás cómo construir una imagen simple de Docker usando un Dockerfile. Un Dockerfile es un documento de texto que contiene todos los comandos que un usuario podría ejecutar en la línea de comandos para ensamblar una imagen. Docker puede construir imágenes automáticamente leyendo las instrucciones de un Dockerfile.

Primero, navega al directorio ~/project, que es tu directorio de trabajo para este laboratorio.

cd ~/project

Ahora, creemos un Dockerfile simple. Crearemos un archivo llamado Dockerfile en el directorio ~/project.

nano Dockerfile

Dentro del editor nano, pega el siguiente contenido:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker!"]

Analicemos este Dockerfile:

• FROM ubuntu:latest: Esta instrucción especifica la imagen base para nuestra nueva imagen. Estamos comenzando con la última versión del sistema operativo Ubuntu.
• RUN apt-get update && apt-get install -y cowsay: Esta instrucción ejecuta comandos durante el proceso de construcción de la imagen. Actualizamos la lista de paquetes e instalamos el paquete cowsay, que es un programa simple que muestra texto en un globo de diálogo de una vaca.
• CMD ["cowsay", "Hello, Docker!"]: Esta instrucción proporciona el comando predeterminado que se ejecutará cuando se inicie un contenedor a partir de esta imagen. En este caso, ejecutará el comando cowsay con el argumento "Hello, Docker!".

Guarda el archivo presionando Ctrl + X, luego Y, y Enter.

Ahora que tenemos nuestro Dockerfile, podemos construir la imagen de Docker. Usa el comando docker build. La bandera -t se utiliza para etiquetar la imagen con un nombre y opcionalmente una etiqueta en el formato nombre:etiqueta. El . al final del comando le indica a Docker que busque el Dockerfile en el directorio actual.

docker build -t my-cowsay-image:latest .

Verás una salida que indica que Docker está construyendo la imagen capa por capa, ejecutando las instrucciones en el Dockerfile. Este proceso puede tomar unos momentos mientras descarga la imagen base e instala el paquete cowsay.

Una vez que la construcción esté completa, puedes verificar que la imagen se haya creado listando las imágenes disponibles con el comando docker images.

docker images

Deberías ver my-cowsay-image en la lista de salida.

Finalmente, ejecutemos un contenedor a partir de la imagen que acabamos de construir para ver si funciona como se espera.

docker run my-cowsay-image:latest

Deberías ver la salida del comando cowsay:

 _______
< Hello, Docker! >
 -------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Esto confirma que nuestra imagen de Docker se construyó correctamente y que el comando predeterminado se ejecuta como se esperaba.

Listar el historial de construcción

En este paso, aprenderás cómo ver el historial de una imagen de Docker, el cual muestra las capas que componen la imagen y los comandos utilizados para crear cada capa. Esto es útil para entender cómo se construyó una imagen y para depuración.

Utilizaremos el comando docker history seguido del nombre o ID de la imagen. En el paso anterior, construimos una imagen llamada my-cowsay-image. Veamos su historial.

docker history my-cowsay-image:latest

La salida mostrará una tabla con varias columnas:

• IMAGE: El ID de la capa de la imagen.
• CREATED: La marca de tiempo cuando se creó la capa.
• CREATED BY: El comando que creó la capa.
• SIZE: El tamaño de la capa.
• COMMENT: Cualquier comentario asociado con la capa.

Verás entradas correspondientes a las instrucciones en nuestro Dockerfile: la imagen base de Ubuntu, los comandos apt-get, y la instrucción CMD. Cada instrucción RUN en un Dockerfile crea una nueva capa en la imagen.

Entender el historial te ayuda a ver cómo cada instrucción en tu Dockerfile contribuye a la imagen final. Esto es particularmente útil al optimizar el tamaño de la imagen o solucionar problemas de construcción.

Por ejemplo, puedes ver el tamaño añadido por cada comando, lo que puede ayudar a identificar capas grandes que podrían ser innecesarias.

Probemos viendo el historial de la imagen base ubuntu:latest que utilizamos.

docker history ubuntu:latest

Esto mostrará el historial de la imagen oficial de Ubuntu, que es mucho más largo y complejo que nuestro historial de imagen simple. Demuestra cómo las imágenes base se construyen a partir de múltiples capas.

El comando docker history proporciona información valiosa sobre la composición de tus imágenes de Docker.

Abrir una compilación específica en Docker Desktop

En este paso, discutiremos cómo normalmente verías los detalles de una compilación de imagen específica usando Docker Desktop. Mientras que el entorno de LabEx proporciona una interfaz de línea de comandos, Docker Desktop es una herramienta gráfica popular que ofrece una forma más visual de interactuar con Docker.

Nota: Docker Desktop es una aplicación gráfica que se ejecuta en tu máquina local (Windows, macOS o Linux con entorno de escritorio). El entorno de LabEx es una máquina virtual basada en la nube a la que se accede a través de un navegador web, que no tiene un entorno de escritorio gráfico para ejecutar Docker Desktop. Por lo tanto, no puedes "abrir una compilación específica en Docker Desktop" directamente dentro de este entorno de LabEx.

Sin embargo, es importante entender cómo se haría esto en una configuración de desarrollo típica usando Docker Desktop.

En Docker Desktop, navegarías a la sección "Images" (Imágenes). Aquí verías una lista de todas las imágenes de Docker en tu sistema. Puedes encontrar la imagen que construiste, my-cowsay-image:latest.

Al hacer clic en el nombre de la imagen se abriría una vista detallada de la misma. Esta vista normalmente incluye:

• Overview (Resumen): Información básica sobre la imagen, como su tamaño, fecha de creación e ID.
• Layers (Capas): Una representación visual de las capas de la imagen, similar a la salida de docker history pero a menudo con más detalle y una interfaz gráfica. Puedes inspeccionar cada capa para ver los comandos que se ejecutaron y los archivos que se añadieron o modificaron.
• Tags (Etiquetas): Una lista de etiquetas asociadas con la imagen.
• Vulnerabilities (Vulnerabilidades): Información sobre cualquier vulnerabilidad de seguridad conocida en la imagen (si el escaneo está habilitado).

Esta interfaz gráfica en Docker Desktop facilita la exploración del contenido y el historial de una imagen en comparación con la salida de línea de comandos, especialmente para imágenes complejas con muchas capas.

Aunque no puedes realizar esta acción en el entorno actual de LabEx, entender esta capacidad de Docker Desktop es valioso para tu aprendizaje general de Docker.

Para completar este paso en el entorno de LabEx, simplemente reconoceremos el concepto.

Resumen

En este laboratorio, aprendiste cómo construir una imagen simple de Docker usando un Dockerfile. Creaste un Dockerfile con instrucciones para usar Ubuntu como imagen base, instalar el paquete cowsay y establecer el comando predeterminado para ejecutar cowsay. Luego usaste el comando docker build para construir la imagen y etiquetarla.

Después de construir la imagen, exploraste cómo listar el historial de compilación usando docker buildx history y luego usaste el comando docker buildx history open para ver los detalles de una compilación específica directamente dentro de Docker Desktop, proporcionando una interfaz visual para inspeccionar el proceso de compilación y sus artefactos.