Cómo usar el comando docker image inspect para ver detalles de imágenes

Introducción

En este laboratorio, aprenderás a utilizar el comando docker image inspect para ver información detallada sobre una imagen de Docker. Comenzarás descargando una imagen de ejemplo. Luego, explorarás cómo inspeccionar la imagen utilizando el formato de salida predeterminado, el formato JSON y una plantilla personalizada de Go para extraer detalles específicos. Esta experiencia práctica te proporcionará las habilidades necesarias para examinar eficazmente las características y configuración de tus imágenes de Docker.

Skills Graph

Descargar una imagen de ejemplo

En este paso, aprenderás cómo descargar una imagen de Docker desde un registro (registry). Las imágenes de Docker son los bloques fundamentales de los contenedores. Son plantillas de solo lectura que contienen el código de la aplicación, bibliotecas, dependencias y archivos de configuración necesarios para ejecutar una aplicación.

Para descargar una imagen, utilizas el comando docker pull seguido del nombre de la imagen. Si no especificas una etiqueta (tag), Docker descargará la etiqueta latest por defecto.

Vamos a descargar la imagen hello-world, que es una imagen muy pequeña utilizada para probar si Docker está instalado correctamente.

docker pull hello-world

Deberías ver una salida similar a esta, indicando que la imagen se está descargando:

Using default tag: latest
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest

Esta salida muestra que Docker está descargando la etiqueta latest de la imagen hello-world desde el registro Docker Hub (que es el registro predeterminado). Las líneas con Pull complete indican que las diferentes capas (layers) de la imagen han sido descargadas.

Inspeccionar la imagen con formato predeterminado

En este paso, aprenderás cómo inspeccionar una imagen de Docker para ver información detallada sobre ella. El comando docker inspect proporciona una gran cantidad de información sobre objetos Docker, incluyendo imágenes, contenedores, redes y volúmenes. Por defecto, muestra la información en un formato estructurado.

Para inspeccionar una imagen, utilizas el comando docker inspect seguido del nombre o ID de la imagen. Vamos a inspeccionar la imagen hello-world que descargaste en el paso anterior.

docker inspect hello-world

Este comando mostrará una gran cantidad de información sobre la imagen hello-world en formato predeterminado. La salida incluye detalles como el ID de la imagen, fecha de creación, arquitectura, sistema operativo y configuración.

[
  {
    "Id": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
    "RepoTags": ["hello-world:latest"],
    "RepoDigests": [
      "hello-world@sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591"
    ],
    "Parent": "",
    "Comment": "",
    "Created": "2023-03-07T21:50:09.004511104Z",
    "Container": "a928b81f51a91111111111111111111111111111111111111111111111111111",
    "ContainerConfig": {
      "Hostname": "a928b81f51a9",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": {}
    },
    "DockerVersion": "20.10.21",
    "Author": "",
    "Config": {
      "Hostname": "",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": null
    },
    "Architecture": "amd64",
    "Os": "linux",
    "Size": 1330,
    "VirtualSize": 1330,
    "GraphDriver": {
      "Data": null,
      "Name": "overlay2"
    },
    "RootFS": {
      "Type": "layers",
      "Layers": [
        "sha256:2db29710123e5455b34e722505b562504b39e55355e344405b54d3153a94650b"
      ]
    },
    "Metadata": {
      "LastTagTime": "0001-01-01T00:00:00Z"
    }
  }
]

Esta salida predeterminada proporciona una visión completa de la configuración y metadatos de la imagen. En los siguientes pasos, aprenderás cómo formatear esta salida para extraer información específica.

Inspeccionar la imagen con formato JSON

En el paso anterior, inspeccionaste la imagen hello-world y viste el formato de salida predeterminado. Aunque este formato es informativo, puede ser difícil de analizar programáticamente. El comando inspect de Docker te permite especificar el formato de salida usando la bandera --format. Un formato común y útil es JSON.

Para inspeccionar una imagen y obtener la salida en formato JSON, usas la bandera --format json con el comando docker inspect.

Inspeccionemos nuevamente la imagen hello-world, pero esta vez formatearemos la salida como JSON.

docker inspect --format json hello-world

Este comando mostrará la misma información que antes, pero formateada como un array JSON que contiene un único objeto JSON.

[
  {
    "Id": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
    "RepoTags": ["hello-world:latest"],
    "RepoDigests": [
      "hello-world@sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591"
    ],
    "Parent": "",
    "Comment": "",
    "Created": "2023-03-07T21:50:09.004511104Z",
    "Container": "a928b81f51a91111111111111111111111111111111111111111111111111111",
    "ContainerConfig": {
      "Hostname": "a928b81f51a9",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": {}
    },
    "DockerVersion": "20.10.21",
    "Author": "",
    "Config": {
      "Hostname": "",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": null
    },
    "Architecture": "amd64",
    "Os": "linux",
    "Size": 1330,
    "VirtualSize": 1330,
    "GraphDriver": {
      "Data": null,
      "Name": "overlay2"
    },
    "RootFS": {
      "Type": "layers",
      "Layers": [
        "sha256:2db29710123e5455b34e722505b562504b39e55355e344405b54d3153a94650b"
      ]
    },
    "Metadata": {
      "LastTagTime": "0001-01-01T00:00:00Z"
    }
  }
]

El formato JSON es particularmente útil cuando deseas procesar la salida con otras herramientas o scripts.

Inspeccionar la imagen con una plantilla Go personalizada

Además de los formatos predeterminado y JSON, el comando docker inspect te permite usar una plantilla Go para formatear la salida. Esto es muy potente ya que te permite extraer campos específicos y formatear la salida exactamente como la necesitas.

La bandera --format acepta una cadena de plantilla Go. Puedes acceder a los campos del objeto inspeccionado usando notación de puntos. Por ejemplo, para acceder al ID de la imagen, usarías .Id. Para acceder a campos anidados, puedes encadenar los puntos, como .Config.Cmd para obtener el comando que ejecutará el contenedor.

Inspeccionemos la imagen hello-world y extraigamos el ID de la imagen y el comando que ejecutará el contenedor.

docker inspect --format 'ID: {{.Id}} Command: {{.Config.Cmd}}' hello-world

En este comando, estamos usando una cadena de plantilla Go 'ID: {{.Id}} Command: {{.Config.Cmd}}'.

• {{.Id}} accede al campo Id del objeto imagen.
• {{.Config.Cmd}} accede al campo Cmd dentro del objeto Config.

La salida se formateará según la plantilla:

ID: sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591 Command: [/hello]

Puedes usar plantillas Go para extraer cualquier información disponible en la salida predeterminada de docker inspect. Esto es muy útil para scripting y automatización de tareas.

Resumen

En este laboratorio, aprendiste a usar el comando docker pull para descargar una imagen Docker desde un registro, específicamente utilizando la imagen hello-world como ejemplo. Luego exploraste el comando docker inspect para ver información detallada sobre la imagen descargada.

Practicaste la inspección de la imagen usando el formato de salida predeterminado, que proporciona una visión general completa de las características de la imagen. Los pasos posteriores, aunque no están completamente detallados en el contenido proporcionado, probablemente involucrarían explorar cómo formatear la salida de docker inspect usando JSON y plantillas Go personalizadas para extraer información específica, demostrando la flexibilidad del comando para analizar detalles de imágenes.