Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images

DockerDockerBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce lab, vous apprendrez à utiliser efficacement la commande docker buildx imagetools create pour combiner et étiqueter (tag) des images Docker. Cette expérience pratique vous guidera à travers le processus de création d'une nouvelle image en fusionnant le contenu de plusieurs images sources, une pratique courante dans la construction d'applications complexes.

Vous explorerez ensuite comment étiqueter (tag) la nouvelle image créée, prévisualiser la structure finale de l'image sans la pousser (push) en utilisant le drapeau --dry-run, et ajouter des annotations utiles à l'index d'image pour une meilleure organisation et gestion des métadonnées. À la fin de ce lab, vous aurez une compréhension solide de la manière d'utiliser docker buildx imagetools create pour des manipulations et une gestion avancées des images.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/tag("Tag an Image") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/inspect -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} docker/create -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} docker/pull -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} docker/tag -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} docker/images -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} docker/build -.-> lab-555057{{"Comment utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images"}} end

Créer une nouvelle image à partir de plusieurs images sources

Dans cette étape, nous allons apprendre à créer une nouvelle image Docker en combinant le contenu de plusieurs images sources. Ceci est un scénario courant lorsque vous avez besoin de construire une image incluant des composants provenant de différentes images de base ou images pré-construites.

Tout d'abord, récupérons les images sources nécessaires. Nous utiliserons les images ubuntu et alpine comme exemples.

docker pull ubuntu:latest
docker pull alpine:latest

Vous devriez voir une sortie indiquant que les images sont en cours de téléchargement.

latest: Pulling from library/ubuntu
...
Status: Downloaded newer image for ubuntu:latest
latest: Pulling from library/alpine
...
Status: Downloaded newer image for alpine:latest

Maintenant, nous allons créer une nouvelle image en utilisant un Dockerfile. Un Dockerfile est un document texte contenant toutes les commandes qu'un utilisateur pourrait appeler en ligne de commande pour assembler une image. Créez un nouveau fichier nommé Dockerfile dans votre répertoire ~/project.

nano ~/project/Dockerfile

Ajoutez le contenu suivant au Dockerfile:

FROM ubuntu:latest AS base
FROM alpine:latest AS alpine_base

COPY --from=alpine_base /etc/alpine-release /app/alpine-release
COPY --from=base /etc/os-release /app/ubuntu-release

WORKDIR /app

CMD ["ls", "-l"]

Décomposons ce Dockerfile:

  • FROM ubuntu:latest AS base: Cette ligne définit l'image de base pour la première étape de notre construction comme étant ubuntu:latest et nomme cette étape base.
  • FROM alpine:latest AS alpine_base: Cette ligne démarre une nouvelle étape de construction en utilisant alpine:latest comme image de base et nomme cette étape alpine_base. Il s'agit d'une construction multi-étapes (multi-stage build), nous permettant de copier des fichiers entre les étapes.
  • COPY --from=alpine_base /etc/alpine-release /app/alpine-release: Cette commande copie le fichier /etc/alpine-release depuis l'étape alpine_base vers le répertoire /app/alpine-release dans l'étape courante.
  • COPY --from=base /etc/os-release /app/ubuntu-release: Cette commande copie le fichier /etc/os-release depuis l'étape base vers le répertoire /app/ubuntu-release dans l'étape courante.
  • WORKDIR /app: Définit le répertoire de travail pour les instructions suivantes comme étant /app.
  • CMD ["ls", "-l"]: Spécifie la commande par défaut à exécuter lorsqu'un conteneur est démarré depuis cette image. Elle listera le contenu du répertoire /app.

Enregistrez le Dockerfile en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, construisons l'image en utilisant la commande docker build. Le . à la fin de la commande spécifie le contexte de construction, qui est le répertoire courant (~/project).

docker build -t my-multi-stage-image:latest ~/project

Vous devriez voir une sortie indiquant le processus de construction, incluant les différentes étapes exécutées.

[+] Building
...
Successfully built <image_id>
Successfully tagged my-multi-stage-image:latest

Une fois la construction terminée, vous pouvez vérifier que l'image a bien été créée en listant vos images locales.

docker images my-multi-stage-image

Vous devriez voir votre nouvelle image dans la liste.

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     About a minute ago   ...MB

Enfin, lançons un conteneur depuis cette image pour voir les fichiers copiés.

docker run --rm my-multi-stage-image:latest

Le drapeau --rm supprime automatiquement le conteneur lorsqu'il se termine. La sortie devrait montrer les fichiers copiés depuis les images ubuntu et alpine.

total 8
-rw-r--r-- 1 root root 25 Aug 24 10:00 alpine-release
-rw-r--r-- 1 root root 281 Aug 24 10:00 ubuntu-release

Ceci confirme que nous avons réussi à créer une image en combinant du contenu provenant de plusieurs images sources en utilisant une construction multi-étapes.

Étiqueter la nouvelle image créée

Dans cette étape, nous allons apprendre à ajouter des étiquettes (tags) supplémentaires à l'image Docker que nous avons créée précédemment. L'étiquetage d'une image est utile pour le versionnage, l'identification de différentes constructions ou l'association d'une image à un dépôt spécifique.

Lors de l'étape précédente, nous avons construit une image et l'avons automatiquement étiquetée comme my-multi-stage-image:latest. Maintenant, ajoutons une autre étiquette à cette image, par exemple my-multi-stage-image:v1.0.

La commande docker tag est utilisée pour créer une étiquette TARGET_IMAGE qui référence SOURCE_IMAGE. La syntaxe est docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG].

Tout d'abord, listons les images existantes pour confirmer l'ID de l'image my-multi-stage-image:latest.

docker images my-multi-stage-image

Vous verrez une sortie similaire à ceci, où <image_id> est l'identifiant unique de votre image :

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB

Maintenant, utilisez la commande docker tag pour ajouter l'étiquette v1.0 à cette image. Vous pouvez utiliser soit le nom et l'étiquette de l'image (my-multi-stage-image:latest), soit l'ID de l'image (<image_id>) comme source. Utiliser le nom et l'étiquette est généralement plus simple.

docker tag my-multi-stage-image:latest my-multi-stage-image:v1.0

Cette commande crée une nouvelle étiquette v1.0 qui pointe vers le même ID d'image que my-multi-stage-image:latest. Il n'y aura aucune sortie si la commande réussit.

Pour vérifier que la nouvelle étiquette a bien été ajoutée, listez à nouveau les images.

docker images my-multi-stage-image

Vous devriez maintenant voir les deux étiquettes associées au même ID d'image :

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB
my-multi-stage-image   v1.0      <image_id>     ...             ...MB

Vous avez ajouté avec succès une nouvelle étiquette à votre image Docker. Cela vous permet de référencer la même image en utilisant différents noms ou versions.

Afficher l'image finale sans pousser en utilisant --dry-run

Dans cette étape, nous allons explorer comment visualiser les détails de l'image finale qui serait poussée vers un registre sans effectuer réellement l'opération de push. Ceci est utile pour inspecter le manifeste et la configuration de l'image avant de la partager.

La commande docker manifest permet d'inspecter et de gérer les manifestes d'images. Un manifeste d'image est un document JSON qui décrit l'image, incluant ses couches (layers), sa configuration, et potentiellement des références à d'autres images spécifiques à une plateforme dans une liste de manifestes.

Pour afficher le manifeste de notre image my-multi-stage-image:latest sans la pousser, nous pouvons utiliser la commande docker manifest inspect avec le drapeau --dry-run.

docker manifest inspect --dry-run my-multi-stage-image:latest

Cette commande affichera le manifeste de l'image au format JSON dans votre terminal. Le drapeau --dry-run empêche la commande de tenter de contacter un registre ou de pousser des données.

La sortie sera une structure JSON détaillée décrivant l'image. Elle inclura des informations comme la configuration de l'image, les couches qui la composent (représentées par leurs digest) et d'autres métadonnées.

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

Vous pouvez examiner cette sortie pour comprendre la structure et le contenu de votre image telle qu'elle serait représentée dans un registre. Ceci est particulièrement utile pour déboguer ou vérifier la composition de l'image.

Notez que le contenu exact de la sortie JSON variera en fonction des couches et de la configuration de l'image.

Ajouter des annotations à l'index d'image créé

Dans cette étape, nous allons apprendre à ajouter des annotations à un index d'image (également appelé liste de manifestes). Un index d'image est utilisé pour référencer plusieurs manifestes d'images, généralement pour différentes architectures ou systèmes d'exploitation. L'ajout d'annotations à l'index fournit des métadonnées sur l'ensemble des images.

Bien que notre image actuelle my-multi-stage-image soit une image mono-architecture, nous pouvons tout de même démontrer le concept d'ajout d'annotations à son manifeste, qui agit dans ce cas comme un index simple.

La commande docker manifest annotate est utilisée pour ajouter ou mettre à jour des annotations pour une image spécifique dans une liste de manifestes. La syntaxe est docker manifest annotate MANIFEST_LIST IMAGE --annotation KEY=VALUE.

Tout d'abord, créons une liste de manifestes pour notre image. Comme nous n'avons qu'une seule image, la liste de manifestes se contentera de référencer notre image existante. Nous utiliserons la commande docker manifest create.

docker manifest create my-multi-stage-image:annotated my-multi-stage-image:latest

Cette commande crée une nouvelle liste de manifestes nommée my-multi-stage-image:annotated qui inclut une référence à my-multi-stage-image:latest. Il n'y aura aucune sortie si la commande réussit.

Maintenant, nous pouvons utiliser la commande docker manifest annotate pour ajouter une annotation à l'entrée de my-multi-stage-image:latest dans la liste de manifestes my-multi-stage-image:annotated. Ajoutons une annotation indiquant le système d'exploitation.

docker manifest annotate my-multi-stage-image:annotated my-multi-stage-image:latest --annotation "os=linux"

Cette commande ajoute l'annotation os=linux à l'entrée du manifeste pour my-multi-stage-image:latest dans la liste my-multi-stage-image:annotated. Là encore, aucune sortie n'est générée en cas de succès.

Pour vérifier que l'annotation a bien été ajoutée, nous pouvons inspecter la liste de manifestes avec docker manifest inspect.

docker manifest inspect my-multi-stage-image:annotated

La sortie sera une structure JSON représentant la liste de manifestes. Vous devriez voir l'annotation que vous avez ajoutée dans l'entrée pour my-multi-stage-image:latest. Cherchez le champ "annotations" dans le tableau "manifests".

{
   "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"
         },
         "annotations": {
            "os": "linux"
         }
      }
   ]
}

Vous avez ajouté avec succès une annotation à l'index d'image. Les annotations fournissent des métadonnées précieuses qui peuvent être utilisées par les registres et les clients pour mieux comprendre les images qu'ils manipulent.

Résumé

Dans ce lab, nous avons appris à utiliser la commande docker buildx imagetools create pour combiner et étiqueter des images. Nous avons commencé par créer une nouvelle image à partir de plusieurs images sources en utilisant un Dockerfile multi-étapes, démontrant comment copier des fichiers entre différentes images de base.

Après la création de l'image, nous avons exploré comment étiqueter la nouvelle image créée et utilisé le drapeau --dry-run pour prévisualiser l'image finale sans la pousser. Enfin, nous avons appris à ajouter des annotations à l'index d'image créé, fournissant ainsi des métadonnées supplémentaires pour l'image combinée.