Cómo ver traces de compilación con docker buildx history trace

Introducción

En este laboratorio, aprenderás a utilizar docker buildx history trace para visualizar y analizar los registros de compilación (build traces) de tus imágenes Docker. Comenzarás construyendo una imagen Docker simple y registrando su historial de compilación utilizando comandos estándar de Docker.

Después de la compilación inicial, explorarás cómo listar los registros de historial de compilación almacenados y luego profundizarás en la visualización del trazo detallado de OpenTelemetry para un registro de compilación específico. Finalmente, aprenderás a comparar los trazados de dos registros de compilación diferentes, lo que proporcionará información valiosa sobre el proceso de compilación y posibles optimizaciones.

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/inspect("Inspect Container") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/inspect -.-> lab-555056{{"Cómo usar docker buildx history trace para ver traces de compilación"}} docker/images -.-> lab-555056{{"Cómo usar docker buildx history trace para ver traces de compilación"}} docker/build -.-> lab-555056{{"Cómo usar docker buildx history trace para ver traces de compilación"}} end

Construir una imagen y registrar su historial

En este paso, aprenderás cómo construir una imagen Docker y registrar su historial de compilación. Las imágenes Docker se construyen a partir de un Dockerfile, que es un archivo de texto que contiene todos los comandos que un usuario podría ejecutar en la línea de comandos para ensamblar una imagen.

Primero, creemos un Dockerfile simple. Navega al directorio ~/project si no estás allí.

cd ~/project

Ahora, crea un archivo llamado Dockerfile usando el editor nano.

nano Dockerfile

Agrega el siguiente contenido al Dockerfile:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y --no-install-recommends fortune-mod
CMD ["/usr/games/fortune"]

Este Dockerfile parte de la imagen más reciente de Ubuntu, actualiza la lista de paquetes, instala el paquete fortune-mod y establece el comando predeterminado para ejecutar el programa fortune.

Guarda el archivo y sal de nano (Presiona Ctrl + X, luego Y, y después Enter).

Ahora, construyamos la imagen Docker usando el comando docker build. Etiquetaremos la imagen como my-fortune-image y usaremos el directorio actual (.) como contexto de compilación.

docker build -t my-fortune-image .

Verás una salida que indica el proceso de compilación, incluyendo la descarga de la imagen base y la ejecución del comando apt-get.

Para registrar el historial de compilación, podemos usar el comando docker history. Este comando muestra el historial de una imagen.

docker history my-fortune-image

La salida mostrará una lista de capas que componen la imagen, junto con el comando utilizado para crear cada capa, el tamaño de la capa y cuándo fue creada. Este historial es útil para entender cómo se construyó una imagen y para depuración.

Listar registros del historial de compilación

En este paso, aprenderás más sobre cómo listar los registros del historial de compilación de una imagen Docker. Como viste en el paso anterior, el comando docker history proporciona una vista detallada de las capas que componen una imagen.

Ejecutemos nuevamente el comando docker history para la imagen my-fortune-image que construimos en el paso anterior.

docker history my-fortune-image

La salida muestra varias columnas:

IMAGE: El ID de la capa de 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

Cada línea en la salida representa una capa en la imagen. Las capas se listan desde la más reciente (arriba) hasta la más antigua (abajo). La imagen base (ubuntu:latest en nuestro caso) es la capa inferior.

También puedes usar el flag -q para mostrar solo los IDs de imagen.

docker history -q my-fortune-image

Esto puede ser útil si solo necesitas los IDs de capa para scripting u otros propósitos.

El comando docker history es una herramienta poderosa para entender la composición de una imagen Docker y para depurar problemas relacionados con las capas de imagen.

Visualizar el trace de OpenTelemetry de un registro de compilación

En este paso, aprenderás cómo visualizar el trace de OpenTelemetry de un registro de compilación Docker. OpenTelemetry es un conjunto de herramientas, APIs y SDKs utilizados para instrumentar, generar, recolectar y exportar datos de telemetría (métricas, logs y traces) que ayudan a analizar el rendimiento y comportamiento de tu software. Docker puede integrarse con OpenTelemetry para proporcionar traces detallados del proceso de compilación.

Para visualizar el trace de OpenTelemetry, necesitas habilitar el tracing al construir la imagen. Reconstruiremos my-fortune-image con tracing activado.

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

cd ~/project

Ahora, compila la imagen nuevamente, pero esta vez configuraremos la variable de entorno BUILDKIT_TRACE para habilitar el tracing. También usaremos el flag --progress=plain para ver directamente la salida de compilación.

BUILDKIT_TRACE=trace.json docker build --progress=plain -t my-fortune-image .

Este comando reconstruirá la imagen y guardará los datos del trace OpenTelemetry en un archivo llamado trace.json en el directorio actual.

Una vez completada la compilación, puedes ver el contenido del archivo trace.json. Este archivo contiene los datos del trace en formato JSON.

cat trace.json

La salida será un objeto JSON grande que contiene información detallada sobre el proceso de compilación, incluyendo la duración de cada paso, dependencias y otros metadatos. Estos datos de trace pueden importarse a un backend de tracing compatible con OpenTelemetry (como Jaeger o Zipkin) para visualización y análisis.

Aunque no configuraremos un backend de tracing completo en este laboratorio, entender cómo generar el archivo de trace es el primer paso para aprovechar OpenTelemetry en el análisis de compilaciones Docker.

Comparar traces de dos registros de compilación

En este paso, aprenderás cómo generar y comparar traces de OpenTelemetry de dos registros de compilación Docker diferentes. Comparar traces puede ser útil para identificar diferencias de rendimiento entre compilaciones, especialmente después de realizar cambios en tu Dockerfile o entorno de compilación.

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

cd ~/project

Ya tenemos un archivo trace.json de la compilación anterior. Renombrémoslo a trace1.json para conservarlo.

mv trace.json trace1.json

Ahora, hagamos un pequeño cambio a nuestro Dockerfile y compilemos la imagen nuevamente, generando un segundo archivo de trace. Añadiremos una simple instrucción LABEL al Dockerfile.

Abre el Dockerfile para editar.

nano Dockerfile

Añade la siguiente línea después de la instrucción CMD:

LABEL version="1.0"

El Dockerfile actualizado debería verse así:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y --no-install-recommends fortune-mod
CMD ["/usr/games/fortune"]
LABEL version="1.0"

Guarda el archivo y sal de nano.

Ahora, compila la imagen nuevamente, generando un nuevo archivo de trace llamado trace2.json.

BUILDKIT_TRACE=trace2.json docker build --progress=plain -t my-fortune-image .

Al completarse la compilación, tendrás dos archivos de trace: trace1.json y trace2.json.

Aunque comparar directamente los archivos JSON en bruto puede ser complicado, estos archivos están diseñados para ser procesados por backends de tracing OpenTelemetry. En un escenario real, importarías ambos archivos (trace1.json y trace2.json) a una herramienta de visualización de tracing (como Jaeger). Esta herramienta te permitiría comparar visualmente las líneas de tiempo y spans de las dos compilaciones, facilitando la identificación de diferencias en el tiempo de ejecución y qué pasos fueron afectados por tus cambios.

Por ejemplo, si visualizaras estos traces en Jaeger, verías los pasos individuales de la compilación Docker (como FROM, RUN, CMD, LABEL) como spans. Podrías entonces comparar la duración de estos spans entre los dos traces para ver si añadir la instrucción LABEL tuvo algún impacto medible en el tiempo de compilación.

Como no tenemos un backend de tracing configurado en este laboratorio, simplemente verificaremos que ambos archivos de trace existen.

Resumen

En este laboratorio, aprendiste cómo construir una imagen Docker desde un Dockerfile usando el comando docker build, etiquetando la imagen para facilitar su identificación. Luego exploraste cómo ver el historial de compilación de la imagen creada usando el comando docker history, que proporciona información sobre las capas y comandos utilizados durante el proceso de compilación.

El laboratorio también te guió para listar los registros del historial de compilación con más detalle, demostrando la información disponible a través del comando docker history. También aprendiste cómo visualizar el trace de OpenTelemetry de un registro de compilación específico, permitiendo un análisis más profundo del proceso de compilación. Finalmente, practicaste comparando los traces de dos registros de compilación diferentes, lo cual es útil para entender cambios y depurar problemas de compilación.