Comment utiliser la commande docker manifest annotate pour ajouter des informations sur la plateforme

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser la commande docker manifest annotate pour ajouter des informations sur la plateforme à une liste de manifestes Docker. Nous commencerons par créer une liste de manifestes qui inclut différentes versions d'architecture de l'image alpine.

Après avoir créé la liste de manifestes, vous allez pratiquer l'ajout d'annotations aux manifestes individuels de la liste pour spécifier l'architecture, le système d'exploitation, les fonctionnalités du système d'exploitation, la version et les variantes d'architecture. Enfin, vous inspecterez la liste de manifestes annotée pour vérifier les informations sur la plateforme ajoutées. Ce processus est essentiel pour construire et distribuer efficacement des images Docker multi-architecture.

Skills Graph

Créer une liste de manifestes

Dans cette étape, nous apprendrons à créer une liste de manifestes. Une liste de manifestes est un index de manifestes d'images, vous permettant de référencer plusieurs images pour différentes architectures et systèmes d'exploitation avec un seul nom. Cela est particulièrement utile pour distribuer des images multi-architecture.

Avant de créer une liste de manifestes, nous devons avoir quelques images disponibles. Pour ce laboratoire (lab), nous utiliserons l'image alpine pour différentes architectures. Nous allons télécharger (pull) les versions amd64 et arm64 de l'image alpine.

Tout d'abord, téléchargez la version amd64 de l'image alpine :

docker pull alpine:latest

Vous devriez voir un affichage indiquant que l'image est en cours de téléchargement et d'extraction.

Ensuite, téléchargez la version arm64 de l'image alpine. Notez que nous devons spécifier la plateforme pour ce téléchargement.

docker pull --platform arm64 alpine:latest

Encore une fois, vous verrez un affichage montrant que l'image est en cours de téléchargement.

Maintenant que nous avons les images, nous pouvons créer une liste de manifestes. Nous utiliserons la commande docker manifest create. Cette commande prend le nom de la liste de manifestes que vous souhaitez créer, suivi des noms des images que vous souhaitez inclure dans la liste.

Créons une liste de manifestes nommée my-alpine-list qui inclut les images alpine:latest (amd64) et alpine:latest (arm64).

docker manifest create my-alpine-list alpine:latest alpine:latest --amend --amend

Le drapeau --amend est utilisé pour ajouter ou mettre à jour des entrées dans la liste de manifestes. Nous l'utilisons deux fois ici car nous ajoutons deux images.

Après avoir exécuté cette commande, vous avez créé une liste de manifestes. Cependant, cette liste est uniquement stockée localement pour le moment. Dans une étape ultérieure, nous la pusherons vers un registre.

Annoter un manifeste avec l'architecture et le système d'exploitation

Dans cette étape, nous allons annoter la liste de manifestes que nous avons créée à l'étape précédente. L'annotation d'un manifeste vous permet d'ajouter des métadonnées à celui-ci, telles que l'architecture et le système d'exploitation pour lesquels l'image est destinée. Ces informations sont cruciales pour que Docker puisse sélectionner l'image correcte à partir d'une liste de manifestes en fonction de l'environnement dans lequel le conteneur est exécuté.

Nous utiliserons la commande docker manifest annotate pour ajouter des informations sur l'architecture et le système d'exploitation aux entrées de notre liste de manifestes my-alpine-list. La commande prend le nom de la liste de manifestes, le nom de l'image dans la liste et les indicateurs d'annotation.

Tout d'abord, annotons l'image alpine:latest qui correspond à l'architecture amd64 et au système d'exploitation linux.

docker manifest annotate my-alpine-list alpine:latest --arch amd64 --os linux

Cette commande indique à Docker que l'image alpine:latest dans la liste de manifestes my-alpine-list est destinée à l'architecture amd64 et au système d'exploitation linux.

Ensuite, nous allons annoter l'image alpine:latest qui correspond à l'architecture arm64 et au système d'exploitation linux.

docker manifest annotate my-alpine-list alpine:latest --arch arm64 --os linux

Cette commande annote l'autre image alpine:latest dans la liste, en spécifiant qu'elle est destinée à l'architecture arm64 et au système d'exploitation linux.

En annotant la liste de manifestes avec des informations sur l'architecture et le système d'exploitation, nous permettons à Docker de sélectionner automatiquement l'image correcte lorsqu'un utilisateur télécharge (pull) my-alpine-list sur un système avec une architecture spécifique.

Annoter un manifeste avec les fonctionnalités et la version du système d'exploitation

Dans cette étape, nous continuerons à annoter notre liste de manifestes en ajoutant des informations sur les fonctionnalités et la version du système d'exploitation. Bien que moins courantes pour des images de base comme Alpine, ces annotations peuvent être utiles pour les images qui nécessitent des capacités ou des versions spécifiques du système d'exploitation.

La commande docker manifest annotate nous permet de spécifier les fonctionnalités du système d'exploitation à l'aide du drapeau --os-features et la version du système d'exploitation à l'aide du drapeau --os-version.

Supposons, à des fins de démonstration, que notre image Alpine pour l'architecture amd64 nécessite une fonctionnalité spécifique du système d'exploitation (par exemple, fips) et est construite pour une version spécifique du système d'exploitation (par exemple, 1.0). Nous allons annoter l'entrée amd64 de notre liste my-alpine-list avec ces informations.

docker manifest annotate my-alpine-list alpine:latest --arch amd64 --os linux --os-features fips --os-version 1.0

Cette commande met à jour l'annotation de l'entrée amd64 dans my-alpine-list, en ajoutant la fonctionnalité et la version spécifiques du système d'exploitation.

De même, supposons que notre image Alpine pour l'architecture arm64 nécessite une autre fonctionnalité du système d'exploitation (par exemple, selinux) et est construite pour une autre version du système d'exploitation (par exemple, 2.0). Nous allons annoter l'entrée arm64.

docker manifest annotate my-alpine-list alpine:latest --arch arm64 --os linux --os-features selinux --os-version 2.0

Cette commande met à jour l'annotation de l'entrée arm64, en ajoutant sa fonctionnalité et sa version spécifiques du système d'exploitation.

En ajoutant ces annotations, vous fournissez des informations plus détaillées sur les exigences et la compatibilité de l'image, qui peuvent être utilisées par Docker ou d'autres outils lors de la sélection d'une image à partir de la liste de manifestes.

Annoter un manifeste avec une variante d'architecture

Dans cette étape, nous allons ajouter des informations sur la variante d'architecture à notre liste de manifestes. Les variantes d'architecture sont utilisées pour distinguer entre différentes versions ou implémentations de la même architecture. Par exemple, l'architecture arm a des variantes telles que v6, v7 et v8.

Nous utilisons la commande docker manifest annotate avec le drapeau --variant pour spécifier la variante d'architecture.

Supposons que notre image Alpine pour l'architecture arm64 est spécifiquement construite pour la variante v8 de l'architecture arm64. Nous allons annoter l'entrée arm64 de notre liste my-alpine-list avec ces informations.

docker manifest annotate my-alpine-list alpine:latest --arch arm64 --os linux --variant v8

Cette commande met à jour l'annotation de l'entrée arm64 dans my-alpine-list, en ajoutant les informations sur la variante v8.

Pour l'architecture amd64, les variantes sont moins courantes, mais vous pourriez en spécifier une si nécessaire. Pour ce laboratoire (lab), nous n'ajouterons pas de variante à l'entrée amd64.

En ajoutant des informations sur la variante d'architecture, vous fournissez des détails encore plus précis sur la compatibilité de l'image, permettant à Docker de sélectionner l'image la plus appropriée pour un système donné.

Inspecter la liste de manifestes annotée

Dans cette étape finale, nous allons inspecter la liste de manifestes que nous avons créée et annotée pour voir les informations que nous avons ajoutées. La commande docker manifest inspect vous permet de visualiser les détails d'une liste de manifestes, y compris les manifestes qu'elle contient et leurs annotations.

Pour inspecter notre liste de manifestes my-alpine-list, exécutez la commande suivante :

docker manifest inspect my-alpine-list

Cette commande affichera un document JSON représentant la liste de manifestes. Vous devriez voir des entrées pour les images amd64 et arm64, ainsi que les annotations que nous avons ajoutées dans les étapes précédentes, telles que architecture, os, os.features, os.version et variant.

Recherchez le tableau manifests dans la sortie. Chaque objet dans ce tableau représente une image incluse dans la liste de manifestes. Vous devriez être en mesure de trouver le champ platform dans chaque objet manifeste, qui contient les informations architecture, os, os.features et os.version. Pour l'entrée arm64, vous devriez également voir le champ variant.

Inspecter la liste de manifestes est un bon moyen de vérifier que vos annotations ont été correctement appliquées et que la liste de manifestes est configurée comme vous le souhaitez.

Résumé

Dans ce laboratoire (lab), nous avons appris à créer une liste de manifestes Docker, qui sert d'index pour plusieurs manifestes d'images, permettant la distribution d'images multi-architectures sous un seul nom. Nous avons commencé par télécharger (pull) les images alpine pour les architectures amd64 et arm64. Ensuite, nous avons utilisé la commande docker manifest create avec le drapeau --amend pour construire une liste de manifestes locale nommée my-alpine-list, en intégrant les images téléchargées.

Après avoir créé la liste de manifestes, nous avons exploré comment annoter les manifestes individuels de la liste à l'aide de la commande docker manifest annotate. Ce processus consistait à ajouter des métadonnées cruciales telles que les informations sur l'architecture et le système d'exploitation. Nous avons spécifiquement démontré comment annoter un manifeste avec les détails de l'architecture et du système d'exploitation, et avons ensuite exploré l'ajout d'informations sur les fonctionnalités du système d'exploitation, la version et la variante d'architecture. Enfin, nous avons appris à inspecter la liste de manifestes annotée pour vérifier les métadonnées ajoutées, en nous assurant que la liste reflète précisément les caractéristiques des images incluses.