Comment utiliser la commande docker buildx imagetools inspect pour examiner les détails d'une image

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker buildx imagetools inspect pour examiner les informations détaillées des images Docker. Nous aborderons l'inspection des images mono-plateforme et multi-plateformes, en démontrant comment visualiser leur configuration, leurs couches et leurs métadonnées.

Vous découvrirez également comment formater la sortie de l'inspection à l'aide de modèles Go pour des vues personnalisées, et comment afficher le manifeste JSON brut d'une image afin d'en comprendre pleinement la structure.

Skills Graph

Inspecter une image mono-plateforme

Dans cette étape, vous apprendrez à inspecter une image Docker mono-plateforme en utilisant la commande docker image inspect. Cette commande fournit des informations détaillées sur une image, y compris sa configuration, ses couches et ses métadonnées.

Commencez par télécharger une image simple mono-plateforme. Nous utiliserons l'image hello-world pour cet exemple.

docker pull hello-world

Vous devriez voir une sortie indiquant que l'image est en cours de téléchargement.

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

Maintenant que nous avons l'image, nous pouvons l'inspecter. Utilisez la commande docker image inspect suivie du nom de l'image.

docker image inspect hello-world

Cette commande produira un grand objet JSON contenant diverses informations sur l'image hello-world. Vous verrez des détails tels que l'ID de l'image, la date de création, l'architecture, le système d'exploitation et la configuration.

[
    {
        "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 sortie est un tableau JSON, même si vous inspectez une seule image. Cela s'explique par le fait que la commande peut accepter plusieurs noms d'images comme arguments.

Inspecter une image multi-plateforme

Dans cette étape, vous apprendrez à inspecter une image Docker multi-plateforme. Les images multi-plateformes sont conçues pour fonctionner sur différentes architectures et systèmes d'exploitation. Lorsque vous téléchargez une image multi-plateforme, Docker sélectionne automatiquement l'image adaptée à l'architecture de votre système.

Commençons par télécharger une image multi-plateforme. Nous utiliserons l'image alpine, qui est une distribution Linux légère.

docker pull alpine

Vous verrez une sortie similaire à l'étape précédente, indiquant que l'image est en cours de téléchargement.

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

Maintenant, inspectons l'image alpine en utilisant la commande docker image inspect.

docker image inspect alpine

La sortie sera à nouveau un objet JSON. Notez les champs Architecture et Os. Ceux-ci reflètent l'architecture et le système d'exploitation de l'image téléchargée pour votre environnement spécifique.

[
    {
        "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": {
            ...
        }
    }
]

Bien que la commande inspect affiche les détails de l'image spécifique téléchargée pour votre plateforme, elle ne montre pas directement les informations sur toutes les plateformes prises en charge par l'image dans cette vue par défaut. Nous verrons dans une étape ultérieure comment afficher plus de détails sur le manifeste de l'image.

Formater la sortie avec les templates Go

Dans cette étape, vous apprendrez à formater la sortie de la commande docker image inspect en utilisant des templates Go. Cela vous permet d'extraire des informations spécifiques du volumineux JSON et de les afficher dans un format plus lisible.

La commande docker image inspect supporte le flag --format, qui prend une chaîne de template Go comme argument. Les templates Go permettent d'accéder aux champs du JSON en utilisant la notation par points.

Inspectons à nouveau l'image alpine, mais cette fois en formatant la sortie pour n'afficher que l'ID de l'image et son architecture.

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

Dans cette commande, {{.Id}} accède au champ Id et {{.Architecture}} accède au champ Architecture du JSON.

Vous devriez voir une sortie similaire à ceci, montrant l'ID et l'architecture de l'image téléchargée :

ID: sha256:..., Architecture: amd64

Vous pouvez également accéder aux champs imbriqués. Par exemple, pour obtenir le système d'exploitation, qui se trouve dans l'objet principal, vous utiliseriez {{.Os}}. Essayons d'afficher l'ID, l'architecture et le système d'exploitation.

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

La sortie inclura maintenant le système d'exploitation :

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

Les templates Go offrent des fonctionnalités avancées comme les boucles et les conditions, mais pour une simple extraction de champs, la notation par points suffit. Ce formatage est très utile lorsque vous devez automatiser des opérations basées sur des propriétés spécifiques des images.

Afficher le manifeste JSON brut

Dans cette étape, vous apprendrez à visualiser le manifeste JSON brut d'une image Docker. Ce manifeste fournit des informations détaillées sur l'image, y compris les couches et les configurations pour différentes architectures dans le cas d'une image multi-plateforme.

Pour visualiser le manifeste brut, vous pouvez utiliser la commande docker manifest inspect. Cette commande est particulièrement utile pour comprendre les images multi-plateformes.

Inspectons le manifeste de l'image alpine que nous avons téléchargée précédemment.

docker manifest inspect alpine

Cette commande affichera un objet JSON représentant le manifeste de l'image. Pour une image multi-plateforme comme alpine, ce manifeste sera une "liste de manifestes" (également appelée "index"). Cette liste contient des entrées pour chaque architecture supportée, pointant vers le manifeste spécifique de l'image pour cette architecture.

Vous verrez une sortie similaire à ceci (le contenu exact peut varier légèrement selon la version de l'image et votre configuration 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"
         }
      },
      ...
   ]
}

Notez le tableau manifests. Chaque objet dans ce tableau représente une image spécifique pour une plateforme particulière (architecture et OS). Vous pouvez voir le champ platform indiquant l'architecture et le système d'exploitation pour chaque entrée. Le champ digest est l'identifiant unique du manifeste de cette image spécifique à la plateforme.

Ce manifeste brut offre une vision plus approfondie de la structure des images multi-plateformes et vous permet de voir toutes les différentes variantes disponibles sous un seul tag.

Résumé

Dans ce lab, vous avez appris à utiliser la commande docker image inspect pour examiner les détails des images Docker. Vous avez commencé par inspecter une image mono-plateforme, spécifiquement l'image hello-world, et vu comment la commande fournit une sortie JSON complète contenant des informations comme l'ID de l'image, l'architecture, le système d'exploitation et la configuration.

Vous avez ensuite inspecté une image multi-plateforme, comprenant que la sortie pour ces images inclut des détails sur les différentes plateformes supportées. Enfin, vous avez exploré comment formater la sortie en utilisant des templates Go pour extraire des informations spécifiques et comment visualiser le manifeste JSON brut pour une analyse plus approfondie de la structure de l'image.