Comment utiliser la commande docker image inspect pour visualiser les détails d'une image

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker image inspect pour visualiser les informations détaillées d'une image Docker. Vous commencerez par télécharger une image exemple. Ensuite, vous explorerez comment inspecter l'image en utilisant le format de sortie par défaut, le format JSON et un modèle Go personnalisé pour extraire des détails spécifiques. Cette expérience pratique vous permettra d'acquérir les compétences nécessaires pour examiner efficacement les caractéristiques et la configuration de vos images Docker.

Skills Graph

Télécharger une image exemple

Dans cette étape, vous apprendrez comment télécharger une image Docker depuis un registre. Les images Docker sont les éléments de base des conteneurs. Ce sont des modèles en lecture seule qui contiennent le code applicatif, les bibliothèques, les dépendances et les fichiers de configuration nécessaires pour exécuter une application.

Pour télécharger une image, vous utilisez la commande docker pull suivie du nom de l'image. Si vous ne spécifiez pas de tag (étiquette), Docker téléchargera par défaut le tag latest.

Téléchargeons l'image hello-world, une image très légère utilisée pour tester si Docker est correctement installé.

docker pull hello-world

Vous devriez voir une sortie similaire à ceci, indiquant que l'image est en cours de téléchargement :

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

Cette sortie montre que Docker télécharge le tag latest de l'image hello-world depuis le registre Docker Hub (qui est le registre par défaut). Les lignes avec Pull complete indiquent que les différentes couches de l'image ont été téléchargées.

Inspecter l'image avec le format par défaut

Dans cette étape, vous apprendrez comment inspecter une image Docker pour visualiser des informations détaillées à son sujet. La commande docker inspect fournit une multitude d'informations sur les objets Docker, y compris les images, conteneurs, réseaux et volumes. Par défaut, elle affiche les informations dans un format structuré.

Pour inspecter une image, utilisez la commande docker inspect suivie du nom ou de l'ID de l'image. Inspectons l'image hello-world que vous avez téléchargée à l'étape précédente.

docker inspect hello-world

Cette commande affichera une grande quantité d'informations sur l'image hello-world dans un format par défaut. Le résultat inclut 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: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"
    }
  }
]

Ce résultat par défaut fournit une vue complète de la configuration et des métadonnées de l'image. Dans les prochaines étapes, vous apprendrez comment formater cette sortie pour extraire des informations spécifiques.

Inspecter l'image au format JSON

Dans l'étape précédente, vous avez inspecté l'image hello-world et vu le format de sortie par défaut. Bien que ce format soit informatif, il peut être difficile à analyser programmatiquement. La commande inspect de Docker permet de spécifier le format de sortie à l'aide du drapeau --format. Un format courant et utile est le JSON.

Pour inspecter une image et obtenir la sortie au format JSON, utilisez le drapeau --format json avec la commande docker inspect.

Inspectons à nouveau l'image hello-world, mais cette fois, nous formaterons la sortie en JSON.

docker inspect --format json hello-world

Cette commande produira les mêmes informations qu'auparavant, mais formatées sous forme de tableau JSON contenant un seul objet 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"
    }
  }
]

Le format JSON est particulièrement utile lorsque vous souhaitez traiter la sortie avec d'autres outils ou scripts.

Inspecter l'image avec un template Go personnalisé

En plus des formats par défaut et JSON, la commande docker inspect permet d'utiliser un template Go pour formater la sortie. Cette fonctionnalité est très puissante car elle permet d'extraire des champs spécifiques et de formater la sortie exactement comme vous le souhaitez.

Le drapeau --format accepte une chaîne de template Go. Vous pouvez accéder aux champs de l'objet inspecté en utilisant la notation par points. Par exemple, pour accéder à l'ID de l'image, vous utiliseriez .Id. Pour accéder aux champs imbriqués, vous pouvez chaîner les points, comme .Config.Cmd pour obtenir la commande que le conteneur exécutera.

Inspectons l'image hello-world et extrayons l'ID de l'image ainsi que la commande que le conteneur exécutera.

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

Dans cette commande, nous utilisons une chaîne de template Go 'ID: {{.Id}} Command: {{.Config.Cmd}}'.

• {{.Id}} accède au champ Id de l'objet image.
• {{.Config.Cmd}} accède au champ Cmd dans l'objet Config.

La sortie sera formatée selon le template :

ID: sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591 Command: [/hello]

Vous pouvez utiliser les templates Go pour extraire n'importe quelle information disponible dans la sortie par défaut de docker inspect. Cela est très utile pour le scripting et l'automatisation des tâches.

Résumé

Dans ce lab, vous avez appris à utiliser la commande docker pull pour télécharger une image Docker depuis un registre, en prenant comme exemple le téléchargement de l'image hello-world. Vous avez ensuite exploré la commande docker inspect pour visualiser les informations détaillées de l'image téléchargée.

Vous avez pratiqué l'inspection de l'image en utilisant le format de sortie par défaut, qui fournit une vue d'ensemble complète des caractéristiques de l'image. Les étapes suivantes, bien que non détaillées dans le contenu fourni, impliqueraient probablement l'exploration du formatage de la sortie de docker inspect en utilisant JSON et des templates Go personnalisés pour extraire des informations spécifiques, démontrant ainsi la flexibilité de cette commande pour analyser les détails d'une image.