Cómo importar historial de compilación con el comando docker buildx history import

Introducción

En este laboratorio, aprenderás a utilizar el comando docker buildx history import para importar el historial de compilación. Comenzaremos creando un Dockerfile simple que construye una imagen basada en Ubuntu e instala el paquete curl.

Después de crear el Dockerfile, construirás la imagen y exportarás su historial de compilación. Finalmente, importarás este historial en Docker Desktop y verificarás que se haya importado correctamente. Este ejercicio práctico demostrará la aplicación real de importar el historial de compilación para una mejor trazabilidad y depuración de tus construcciones en Docker.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/ls -.-> lab-555050{{"Cómo usar el comando docker buildx history import para importar historial de compilación"}} docker/create -.-> lab-555050{{"Cómo usar el comando docker buildx history import para importar historial de compilación"}} docker/images -.-> lab-555050{{"Cómo usar el comando docker buildx history import para importar historial de compilación"}} docker/build -.-> lab-555050{{"Cómo usar el comando docker buildx history import para importar historial de compilación"}} end

Crear un Dockerfile de ejemplo

En este paso, crearemos un Dockerfile simple. 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.

Crearemos un Dockerfile que construya una imagen basada en la última versión de Ubuntu e instale el paquete curl.

Primero, navega al directorio ~/project si no estás allí ya.

cd ~/project

Ahora, crea un nuevo archivo llamado Dockerfile en el directorio ~/project usando el editor nano.

nano Dockerfile

Dentro del editor nano, agrega el siguiente contenido al Dockerfile:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y curl

Analicemos las instrucciones en este Dockerfile:

FROM ubuntu:latest: Esta instrucción especifica la imagen base para nuestra nueva imagen. Estamos usando la última versión de la imagen oficial de Ubuntu de Docker Hub.
RUN apt-get update && apt-get install -y curl: Esta instrucción ejecuta comandos en una nueva capa sobre la imagen actual y guarda los resultados. Aquí, actualizamos la lista de paquetes e instalamos el paquete curl usando el gestor de paquetes apt-get. La bandera -y responde automáticamente "sí" a cualquier pregunta durante la instalación.

Después de agregar el contenido, guarda el archivo y sal de nano presionando Ctrl + X, luego Y para confirmar que deseas guardar, y Enter para confirmar el nombre del archivo.

Puedes verificar el contenido del Dockerfile usando el comando cat:

cat Dockerfile

La salida debería mostrar el contenido que acabas de agregar al archivo.

Construir una imagen y exportar el historial de compilación

En este paso, construiremos una imagen Docker a partir del Dockerfile creado anteriormente y luego exportaremos el historial de compilación de esta imagen.

Primero, asegúrate de estar en el directorio ~/project donde se encuentra tu Dockerfile.

cd ~/project

Ahora, construyamos la imagen Docker usando el comando docker build. Etiquetaremos la imagen con el nombre my-ubuntu-curl y la etiqueta latest. El . al final del comando indica a Docker que busque el Dockerfile en el directorio actual.

docker build -t my-ubuntu-curl:latest .

Verás una salida que muestra el proceso de compilación, incluyendo la descarga de la imagen base y la ejecución del comando apt-get. Este proceso puede tardar unos minutos dependiendo de tu conexión a internet.

Una vez completada la compilación, puedes verificar que la imagen se ha creado listando tus imágenes Docker locales:

docker images

Deberías ver my-ubuntu-curl en la lista de imágenes.

Ahora, exportaremos el historial de compilación de esta imagen. El historial de compilación muestra las capas que componen la imagen y los comandos utilizados para crear cada capa. Podemos exportar este historial a un archivo usando el comando docker history y redirigiendo la salida a un archivo.

Exportemos el historial a un archivo llamado build_history.txt en el directorio ~/project.

docker history my-ubuntu-curl:latest > build_history.txt

Este comando toma la salida de docker history my-ubuntu-curl:latest y la escribe en el archivo build_history.txt.

Puedes ver el contenido del archivo de historial exportado usando el comando cat:

cat build_history.txt

La salida mostrará una tabla con información sobre cada capa de la imagen, incluyendo el ID de la capa, tiempo de creación, tamaño y el comando utilizado para crearla.

Importar historial de compilación en Docker Desktop

En este paso, simularemos importar el historial de compilación que exportamos en el paso anterior a Docker Desktop. Aunque no podemos interactuar directamente con una instancia gráfica de Docker Desktop en este entorno de terminal, podemos demostrar el concepto y el proceso de transferencia de archivos.

En un escenario real, después de exportar el archivo build_history.txt desde tu entorno de compilación (como esta VM de LabEx), normalmente transferirías este archivo a la máquina donde está instalado Docker Desktop. Los métodos comunes para transferir archivos incluyen usar scp, sftp o servicios de almacenamiento en la nube.

Para los propósitos de este laboratorio, asumiremos que has transferido el archivo build_history.txt a tu máquina local donde se ejecuta Docker Desktop.

Una vez que el archivo está en tu máquina local, abrirías Docker Desktop. Docker Desktop proporciona una interfaz gráfica para gestionar tus imágenes Docker, contenedores y volúmenes. Aunque no hay un botón directo de "importar historial de compilación" en Docker Desktop que lea este formato específico de archivo de texto, la información dentro de build_history.txt es valiosa para entender cómo se construyó una imagen.

Los desarrolladores suelen usar este historial de compilación para:

Entender las capas de una imagen
Depurar problemas con compilaciones de imágenes
Recrear el proceso de compilación en una máquina diferente
Documentar el proceso de creación de imágenes

Para simular la "importación" y hacer que el historial de compilación sea accesible para el siguiente paso de verificación, simplemente nos aseguraremos de que el archivo build_history.txt esté presente en el directorio ~/project, como si estuviera listo para ser examinado o usado por una herramienta que pudiera analizarlo.

Puedes confirmar que el archivo sigue en el directorio ~/project:

ls ~/project/build_history.txt

Si el archivo existe, el comando mostrará su ruta. Si no existe, podrías ver un mensaje de error.

En un entorno real de Docker Desktop, normalmente usarías la interfaz gráfica para inspeccionar imágenes y sus capas, lo que proporciona una vista similar a la información en build_history.txt. Algunas herramientas o scripts avanzados también podrían usarse para analizar y visualizar estos datos de historial.

Como estamos en un entorno de terminal, la presencia del archivo build_history.txt en la ubicación esperada significa que hemos completado el objetivo de este paso dentro del contexto del laboratorio.

Verificar historial de compilación importado

En este paso final, verificaremos el contenido del archivo de historial de compilación que "importamos" (asegurando su presencia) en el paso anterior. Esto simula el proceso de examinar el historial de compilación dentro de un entorno Docker Desktop o usando herramientas para analizar el historial exportado.

Utilizaremos herramientas simples de línea de comandos para verificar si el archivo build_history.txt contiene la información esperada, buscando específicamente evidencia de la imagen base ubuntu y el comando de instalación de curl.

Primero, asegúrate de estar en el directorio ~/project.

cd ~/project

Ahora, usemos el comando grep para buscar información sobre la imagen base en el archivo build_history.txt. Esperamos ver una línea que indique el uso de la imagen ubuntu.

grep "ubuntu" ~/project/build_history.txt

La salida debería mostrar una línea que contenga "ubuntu", probablemente relacionada con la instrucción inicial FROM ubuntu:latest en tu Dockerfile.

A continuación, busquemos el comando que instaló curl. Esperamos ver una línea que contenga "apt-get install -y curl".

grep "apt-get install -y curl" ~/project/build_history.txt

La salida debería mostrar una línea con el comando usado para instalar curl.

Estos comandos grep demuestran cómo podrías verificar programáticamente aspectos del historial de compilación. En un entorno real de Docker Desktop, inspeccionarías visualmente las capas y sus comandos asociados a través de la interfaz gráfica.

Encontrar exitosamente estas piezas clave de información en el archivo build_history.txt confirma que el historial de compilación fue exportado correctamente y está disponible para su inspección, completando el objetivo de este laboratorio.

Resumen

En este laboratorio, aprendimos a utilizar el comando docker buildx history import para gestionar el historial de compilación de Docker. Comenzamos creando un Dockerfile simple basado en Ubuntu e instalando el paquete curl. Esto demostró el proceso fundamental de definir las capas e instrucciones de una imagen.

Tras la creación del Dockerfile, procedimos a construir la imagen y exportar su historial de compilación. Este paso es crucial para comprender cómo capturar y preservar la información detallada sobre el proceso de construcción de la imagen. Finalmente, importamos este historial exportado a Docker Desktop y verificamos que se integró correctamente, mostrando la aplicación práctica del comando buildx history import para compartir o migrar información de compilación.