Comment utiliser la commande docker manifest inspect pour visualiser les manifestes d'images

Introduction

Dans ce laboratoire, vous apprendrez à utiliser la commande docker manifest inspect pour afficher les manifestes d'images. Nous commencerons par télécharger une image Docker multi-architecture, plus précisément l'image alpine, afin de comprendre comment Docker gère les images sur différentes architectures.

Après le téléchargement de l'image, vous utiliserez la commande docker manifest inspect pour examiner la liste des manifestes associée à l'image multi-architecture. Vous approfondirez ensuite votre exploration en inspectant un manifeste d'image spécifique au sein de cette liste et, enfin, vous explorerez l'option d'affichage détaillé de la commande docker manifest inspect pour obtenir une compréhension complète des détails des manifestes d'images.

Skills Graph

Télécharger une image multi-architecture

Dans cette étape, nous apprendrons à télécharger une image Docker multi-architecture. Une image multi-architecture est une étiquette d'image unique qui peut être utilisée sur différentes architectures (comme amd64, arm64, etc.). Lorsque vous téléchargez une image multi-architecture, Docker sélectionne automatiquement la bonne couche d'image pour l'architecture de votre système.

Nous allons télécharger l'image alpine, qui est une distribution Linux légère couramment utilisée dans les conteneurs Docker. L'image alpine est disponible en tant qu'image multi-architecture.

Pour télécharger l'image alpine, ouvrez votre terminal et exécutez la commande suivante :

docker pull alpine

Cette commande demande à Docker de télécharger la dernière version de l'image alpine depuis Docker Hub. Étant donné que alpine est une image multi-architecture, Docker téléchargera les couches d'image appropriées pour l'architecture de votre machine virtuelle LabEx.

Vous devriez voir une sortie similaire à celle-ci, indiquant que Docker télécharge l'image :

Using default tag: latest
latest: Pulling from library/alpine
... (output showing download progress)
Digest: sha256:...
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

La ligne Digest montre l'identifiant unique du manifeste d'image spécifique qui a été téléchargé pour votre architecture.

Une fois la commande terminée, l'image alpine sera disponible sur votre machine virtuelle LabEx et prête à être utilisée pour exécuter des conteneurs.

Inspecter la liste des manifestes de l'image multi-architecture

Dans l'étape précédente, nous avons téléchargé l'image alpine. Étant donné que alpine est une image multi-architecture, l'étiquette alpine:latest fait en réalité référence à une liste de manifestes. Une liste de manifestes est une liste de manifestes d'images, chacun pour une architecture différente. Lorsque vous téléchargez une image multi-architecture, Docker utilise la liste de manifestes pour trouver le bon manifeste d'image pour votre système.

Pour voir la liste de manifestes de l'image alpine:latest, nous pouvons utiliser la commande docker manifest inspect. Cette commande vous permet de voir les détails d'un manifeste d'image ou d'une liste de manifestes.

Exécutez la commande suivante dans votre terminal :

docker manifest inspect alpine:latest

Cette commande affichera un document JSON représentant la liste de manifestes de l'image alpine:latest. La sortie montrera une liste de manifests, chacun correspondant à une architecture différente (comme amd64, arm64, arm/v7, etc.). Chaque manifeste de la liste aura des détails tels que la platform (architecture et système d'exploitation) et le digest (un identifiant unique pour le manifeste d'image de cette architecture spécifique).

Vous verrez une sortie similaire à celle-ci (les digests exacts et le nombre de manifestes peuvent varier) :

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

Cette sortie confirme que alpine:latest est bien une liste de manifestes contenant des manifestes pour diverses architectures. C'est ainsi que Docker sait quelle image spécifique télécharger pour votre système lorsque vous utilisez une étiquette multi-architecture.

Inspecter un manifeste d'image spécifique dans la liste

Dans l'étape précédente, nous avons inspecté la liste de manifestes de alpine:latest. Cette liste contenait plusieurs entrées, chacune pointant vers un manifeste d'image spécifique pour une architecture différente. Maintenant, inspectons l'un de ces manifestes d'image spécifiques.

Pour inspecter un manifeste spécifique, nous avons besoin de son digest. À partir de la sortie de docker manifest inspect alpine:latest, recherchez le digest de l'architecture qui correspond à votre machine virtuelle LabEx (qui est amd64). Le digest ressemblera à quelque chose comme sha256:....

Une fois que vous avez le digest du manifeste amd64, vous pouvez l'inspecter en utilisant la commande docker manifest inspect suivie du nom de l'image et du digest, séparés par un symbole @.

Remplacez YOUR_AMD64_DIGEST par le digest réel que vous avez trouvé pour la plateforme amd64 dans la sortie de l'étape précédente.

docker manifest inspect alpine@YOUR_AMD64_DIGEST

Par exemple, si le digest amd64 était sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227, la commande serait :

docker manifest inspect alpine@sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227

Cette commande affichera un document JSON qui représente le manifeste d'image spécifique pour l'architecture amd64. Ce manifeste contient des détails sur les couches d'image (identifiées par leurs digests) et la configuration de l'image (également identifiée par un digest).

Vous verrez une sortie similaire à celle-ci :

{
  "schemaVersion": 2,
  "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
  "config": {
    "mediaType": "application/vnd.docker.container.image.v1+json",
    "size": 1510,
    "digest": "sha256:..."
  },
  "layers": [
    {
      "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
      "size": 2803897,
      "digest": "sha256:..."
    }
  ]
}

Cette sortie montre la structure d'un seul manifeste d'image, listant la configuration et les couches qui composent l'image pour cette architecture spécifique.

Inspecter le manifeste avec une sortie détaillée

Dans les étapes précédentes, nous avons inspecté la liste de manifestes et un manifeste d'image spécifique. La sortie par défaut de docker manifest inspect fournit un résumé du manifeste ou de la liste de manifestes. Pour obtenir des informations plus détaillées, y compris la configuration complète de l'image, nous pouvons utiliser le drapeau --verbose.

Inspectons à nouveau la liste de manifestes de alpine:latest, mais cette fois avec le drapeau --verbose. Cela affichera la liste de manifestes et, pour chaque manifeste de la liste, il affichera également les détails complets de la configuration.

Exécutez la commande suivante dans votre terminal :

docker manifest inspect --verbose alpine:latest

Cette commande affichera un document JSON plus complet. Pour chaque entrée de la liste manifests, vous verrez maintenant un champ supplémentaire appelé Config. Ce champ Config contient la configuration complète de l'image pour cette architecture spécifique, y compris des détails tels que le point d'entrée, la commande, les variables d'environnement, le répertoire de travail, etc.

Vous verrez une sortie similaire à celle-ci (les détails exacts dans la section Config varieront) :

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         },
         "Config": {
            "Env": [
               "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Entrypoint": [
               "/bin/sh"
            ],
            "Cmd": null,
            "WorkingDir": "/",
            ...
         }
      },
      ...
   ]
}

L'utilisation du drapeau --verbose est utile lorsque vous avez besoin de voir la configuration détaillée des images dans une liste de manifestes, ce qui peut être utile pour le débogage ou pour comprendre comment une image spécifique est configurée.

Résumé

Dans ce laboratoire (lab), nous avons appris à utiliser la commande docker manifest inspect pour visualiser les manifestes d'images. Nous avons commencé par télécharger (pull) une image multi-architecture, alpine, en comprenant qu'une seule étiquette (tag) peut représenter des images pour différentes architectures.

Nous avons ensuite utilisé docker manifest inspect pour visualiser la liste de manifestes associée à l'image multi-architecture, qui détaille les manifestes d'images disponibles pour diverses architectures. Enfin, nous avons exploré comment inspecter un manifeste d'image spécifique dans la liste et comment obtenir des informations plus détaillées en utilisant l'option de sortie détaillée (verbose output).