Cómo usar el comando docker buildx imagetools inspect para examinar detalles de imágenes

Introducción

En este laboratorio, aprenderás a utilizar el comando docker buildx imagetools inspect para examinar la información detallada de imágenes Docker. Cubriremos la inspección de imágenes tanto de plataforma única como multiplataforma, demostrando cómo ver su configuración, capas y metadatos.

También aprenderás a formatear la salida de la inspección utilizando plantillas Go (Go templates) para vistas personalizadas y cómo mostrar el manifiesto JSON en bruto de una imagen para comprender completamente su estructura.

Skills Graph

Inspeccionar una imagen de plataforma única

En este paso, aprenderás cómo inspeccionar una imagen Docker de plataforma única utilizando el comando docker image inspect. Este comando proporciona información detallada sobre una imagen, incluyendo su configuración, capas y metadatos.

Primero, vamos a descargar una imagen simple de plataforma única. Usaremos la imagen hello-world para este ejemplo.

docker pull hello-world

Deberías ver una salida que indica que la imagen está siendo descargada.

Using default tag: latest
latest: Pulling from library/hello-world
...
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest

Ahora que tenemos la imagen, podemos inspeccionarla. Usa el comando docker image inspect seguido del nombre de la imagen.

docker image inspect hello-world

Este comando mostrará un objeto JSON grande que contiene varios detalles sobre la imagen hello-world. Verás información como el ID de la imagen, fecha de creación, arquitectura, sistema operativo y configuración.

[
    {
        "Id": "sha256:...",
        "RepoTags": [
            "hello-world:latest"
        ],
        "RepoDigests": [
            "hello-world@sha256:..."
        ],
        "Parent": "",
        "Comment": "",
        "Created": "...",
        "Container": "...",
        "ContainerConfig": {
            ...
        },
        "DockerVersion": "...",
        "Author": "",
        "Config": {
            ...
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": ...,
        "VirtualSize": ...,
        "GraphDriver": {
            ...
        },
        "RootFS": {
            ...
        },
        "Metadata": {
            ...
        }
    }
]

La salida es un arreglo JSON, incluso si estás inspeccionando una sola imagen. Esto se debe a que el comando puede aceptar múltiples nombres de imágenes como argumentos.

Inspeccionar una imagen multiplataforma

En este paso, aprenderás cómo inspeccionar una imagen Docker multiplataforma. Estas imágenes están diseñadas para ejecutarse en diferentes arquitecturas y sistemas operativos. Cuando descargas una imagen multiplataforma, Docker selecciona automáticamente la imagen correcta para la arquitectura de tu sistema.

Vamos a descargar una imagen multiplataforma. Usaremos la imagen alpine, que es una distribución Linux ligera.

docker pull alpine

Verás una salida similar al paso anterior, indicando que la imagen está siendo descargada.

Using default tag: latest
latest: Pulling from library/alpine
...
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

Ahora, inspeccionemos la imagen alpine usando el comando docker image inspect.

docker image inspect alpine

La salida será nuevamente un objeto JSON. Observa los campos Architecture y Os. Estos reflejarán la arquitectura y sistema operativo de la imagen que se descargó para tu entorno específico.

[
    {
        "Id": "sha256:...",
        "RepoTags": [
            "alpine:latest"
        ],
        "RepoDigests": [
            "alpine@sha256:..."
        ],
        "Parent": "",
        "Comment": "",
        "Created": "...",
        "Container": "...",
        "ContainerConfig": {
            ...
        },
        "DockerVersion": "...",
        "Author": "",
        "Config": {
            ...
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": ...,
        "VirtualSize": ...,
        "GraphDriver": {
            ...
        },
        "RootFS": {
            ...
        },
        "Metadata": {
            ...
        }
    }
]

Aunque el comando inspect muestra los detalles de la imagen específica descargada para tu plataforma, no muestra directamente la información sobre todas las plataformas que soporta la imagen en esta vista predeterminada. Exploraremos cómo ver más detalles sobre el manifiesto de la imagen en un paso posterior.

Formatear la salida usando plantillas Go

En este paso, aprenderás cómo formatear la salida del comando docker image inspect utilizando plantillas Go. Esto te permite extraer información específica del extenso resultado JSON y mostrarla en un formato más legible.

El comando docker image inspect soporta el flag --format, que recibe una cadena de plantilla Go como argumento. Las plantillas Go te permiten acceder a campos dentro del resultado JSON usando notación de puntos.

Inspeccionemos nuevamente la imagen alpine, pero esta vez formatearemos la salida para mostrar solo el ID de la imagen y la arquitectura.

docker image inspect --format 'ID: {{.Id}}, Architecture: {{.Architecture}}' alpine

En este comando, {{.Id}} accede al campo Id y {{.Architecture}} accede al campo Architecture del resultado JSON.

Deberías ver una salida similar a esta, mostrando el ID y arquitectura de la imagen descargada:

ID: sha256:..., Architecture: amd64

También puedes acceder a campos anidados. Por ejemplo, para obtener el sistema operativo, que está dentro del objeto principal, usarías {{.Os}}. Probemos mostrando el ID, arquitectura y sistema operativo.

docker image inspect --format 'ID: {{.Id}}, Architecture: {{.Architecture}}, OS: {{.Os}}' alpine

La salida ahora incluirá el sistema operativo:

ID: sha256:..., Architecture: amd64, OS: linux

Las plantillas Go ofrecen características más avanzadas como bucles y sentencias condicionales, pero para la extracción simple de campos, la notación de puntos es suficiente. Este formato es muy útil cuando necesitas automatizar operaciones basadas en propiedades específicas de las imágenes.

Mostrar el manifiesto JSON en bruto

En este paso, aprenderás cómo visualizar el manifiesto JSON en bruto de una imagen Docker. El manifiesto proporciona información detallada sobre la imagen, incluyendo las capas y configuraciones para diferentes arquitecturas en el caso de imágenes multiplataforma.

Para ver el manifiesto en bruto, puedes usar el comando docker manifest inspect. Este comando es particularmente útil para comprender imágenes multiplataforma.

Inspeccionemos el manifiesto de la imagen alpine que descargamos anteriormente.

docker manifest inspect alpine

Este comando mostrará un objeto JSON que representa el manifiesto de la imagen. Para una imagen multiplataforma como alpine, este manifiesto será una "lista de manifiestos" (también conocida como "índice"). Esta lista contiene entradas para cada arquitectura soportada, apuntando al manifiesto específico de la imagen para esa arquitectura.

Verás una salida similar a esta (el contenido exacto puede variar ligeramente según la versión de la imagen y tu configuración de Docker):

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "arm",
            "os": "linux",
            "variant": "v6"
         }
      },
      ...
   ]
}

Observa el array manifests. Cada objeto en este array representa una imagen específica para una plataforma particular (arquitectura y SO). Puedes ver el campo platform que indica la arquitectura y sistema operativo para cada entrada. El campo digest es el identificador único para el manifiesto de esa imagen específica de plataforma.

Este manifiesto en bruto proporciona una visión más profunda de cómo están estructuradas las imágenes multiplataforma y te permite ver todas las variantes disponibles bajo una sola etiqueta.

Resumen

En este laboratorio, aprendiste a utilizar el comando docker image inspect para examinar los detalles de las imágenes Docker. Comenzaste inspeccionando una imagen de plataforma única, específicamente la imagen hello-world, y viste cómo el comando proporciona una salida JSON completa que contiene información como el ID de la imagen, arquitectura, sistema operativo y configuración.

Luego pasaste a inspeccionar una imagen multiplataforma, entendiendo que la salida para este tipo de imágenes incluye detalles sobre las diferentes plataformas soportadas. Finalmente, exploraste cómo formatear la salida usando plantillas Go (Go templates) para extraer información específica y cómo visualizar el manifiesto JSON en bruto para obtener una visión más profunda de la estructura de la imagen.