Comment utiliser la commande docker manifest create pour construire des images multi-architecture

Introduction

Dans ce laboratoire (lab), vous apprendrez à construire et à gérer des images Docker multi-architecture à l'aide de la commande docker manifest create. Les images multi-architecture sont essentielles pour déployer des applications dans divers environnements avec différentes architectures CPU, telles que amd64 et arm64.

Le laboratoire vous guidera tout au long du processus de préparation des images multi-architecture en activant les fonctionnalités expérimentales et en créant une instance de générateur (builder) multi-architecture. Vous créerez ensuite une liste de manifeste qui regroupe ces images, inspecterez la liste de manifeste créée pour vérifier son contenu, et enfin pousserez (push) la liste de manifeste vers un registre, rendant votre image multi-architecture disponible pour le déploiement sur diverses plateformes.

Skills Graph

Préparer des images multi-architecture

Dans cette étape, nous allons préparer des images multi-architecture. Les images multi-architecture vous permettent de construire et de pousser (push) des images qui peuvent s'exécuter sur différentes architectures, telles que amd64 et arm64. Cela est utile pour déployer des applications dans divers environnements, y compris des serveurs cloud, des appareils de périphérie (edge devices) et des machines locales.

Tout d'abord, nous devons activer les fonctionnalités expérimentales dans Docker. Cela nous permet d'utiliser la commande buildx, qui est nécessaire pour construire des images multi-architecture. Nous pouvons le faire en créant ou en modifiant le fichier de configuration Docker.

Ouvrez le fichier de configuration Docker à l'aide de nano :

nano ~/.docker/config.json

Si le fichier n'existe pas, nano le créera. Ajoutez le contenu suivant au fichier. Si le fichier existe déjà, ajoutez la ligne "experimental": "enabled" à l'intérieur de l'objet JSON principal.

{
  "experimental": "enabled"
}

Enregistrez le fichier en appuyant sur Ctrl + X, puis Y, et Enter.

Ensuite, nous devons créer une nouvelle instance de générateur (builder) qui prend en charge plusieurs architectures. Une instance de générateur est un composant Docker qui gère le processus de construction.

Créez une nouvelle instance de générateur nommée mybuilder :

docker buildx create --name mybuilder --use

Cette commande crée une nouvelle instance de générateur nommée mybuilder et la définit comme générateur par défaut pour les opérations de construction suivantes. La sortie devrait indiquer que le générateur a été créé et est utilisé.

Maintenant, construisons une simple image multi-architecture. Nous utiliserons un fichier Dockerfile de base qui crée une image basée sur Alpine Linux.

Créez un répertoire pour notre projet et accédez-y :

mkdir ~/project/multiarch-demo
cd ~/project/multiarch-demo

Créez un fichier Dockerfile dans ce répertoire :

nano Dockerfile

Ajoutez le contenu suivant au fichier Dockerfile :

FROM alpine:latest
CMD ["echo", "Hello from multi-architecture image!"]

Enregistrez le fichier Dockerfile en appuyant sur Ctrl + X, puis Y, et Enter.

Maintenant, construisez l'image pour les architectures linux/amd64 et linux/arm64 et poussez-la vers un registre factice. Nous utiliserons localhost:5000 comme emplacement pour le registre. Dans un scénario réel, vous remplaceriez cela par l'adresse de votre registre réel.

Construisez et poussez l'image multi-architecture :

docker buildx build --platform linux/amd64,linux/arm64 -t localhost:5000/multiarch-demo:latest --push .

Cette commande construit l'image pour les plateformes spécifiées (linux/amd64 et linux/arm64), la tagge (tag) comme localhost:5000/multiarch-demo:latest et la pousse vers le registre localhost:5000. La sortie montrera le processus de construction pour chaque architecture et l'opération de poussée.

Créer une liste de manifeste pour les images

Dans cette étape, nous allons créer une liste de manifeste pour les images multi-architecture que nous avons construites à l'étape précédente. Une liste de manifeste est une liste de manifestes d'images, chacun pour une architecture différente. Lorsque vous téléchargez (pull) une image à l'aide d'une liste de manifeste, Docker sélectionne automatiquement l'image appropriée pour votre architecture.

Nous allons utiliser la commande docker manifest create pour créer la liste de manifeste. Cette commande prend le nom de la liste de manifeste que vous souhaitez créer, suivi des noms des images que vous souhaitez inclure dans la liste.

Créez une liste de manifeste nommée localhost:5000/multiarch-demo:latest :

docker manifest create localhost:5000/multiarch-demo:latest \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1) \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1)

Décortiquons cette commande :

• docker manifest create localhost:5000/multiarch-demo:latest : Cela spécifie le nom de la liste de manifeste que nous créons.
• localhost:5000/multiarch-demo:latest@sha256:... : Ce sont les images que nous ajoutons à la liste de manifeste. Nous utilisons le nom de l'image suivi de @sha256: et du digest de l'image. Le digest identifie de manière unique une couche d'image spécifique.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1) : Cette chaîne de commandes récupère le digest de la première image répertoriée par docker buildx imagetools inspect.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1) : Cette chaîne de commandes récupère le digest de la deuxième image répertoriée par docker buildx imagetools inspect.

La sortie de la commande docker manifest create sera le digest de la liste de manifeste nouvellement créée.

Inspecter la liste de manifeste créée

Dans cette étape, nous allons inspecter la liste de manifeste que nous avons créée à l'étape précédente. L'inspection de la liste de manifeste nous permet de voir quelles images sont incluses dans la liste et leurs détails, tels que l'architecture et le système d'exploitation.

Nous allons utiliser la commande docker manifest inspect pour afficher les détails de la liste de manifeste.

Inspectez la liste de manifeste localhost:5000/multiarch-demo:latest :

docker manifest inspect localhost:5000/multiarch-demo:latest

La sortie de cette commande sera un document JSON qui décrit la liste de manifeste. Vous devriez voir un tableau de "manifests", chacun représentant une image pour une architecture différente. Recherchez le champ "platform" dans chaque entrée de manifeste pour voir l'architecture et le système d'exploitation. Vous devriez voir des entrées pour linux/amd64 et linux/arm64.

Cette inspection confirme que notre liste de manifeste inclut correctement les images pour les différentes architectures que nous avons construites.

Pousser la liste de manifeste vers un registre

Dans cette étape, nous allons pousser (push) la liste de manifeste que nous avons créée vers un registre. En poussant la liste de manifeste, elle devient disponible pour que d'autres puissent télécharger (pull) l'image multi-architecture. Lorsque quelqu'un télécharge l'image en utilisant l'étiquette (tag) de la liste de manifeste, Docker téléchargera automatiquement l'image appropriée pour l'architecture de son système.

Nous allons utiliser la commande docker manifest push pour pousser la liste de manifeste.

Poussez la liste de manifeste localhost:5000/multiarch-demo:latest vers le registre :

docker manifest push localhost:5000/multiarch-demo:latest

Cette commande pousse la liste de manifeste et toutes les images qu'elle référence vers le registre spécifié (localhost:5000). Étant donné que nous avons déjà poussé les images individuelles à la première étape en utilisant docker buildx build --push, cette commande pousse principalement la liste de manifeste elle-même.

La sortie montrera la progression du push de la liste de manifeste.

Après avoir poussé la liste de manifeste, vous pouvez vérifier qu'elle est disponible dans le registre. Bien que nous n'ayons pas de registre en cours d'exécution dans cet environnement de laboratoire pour interroger directement, l'exécution réussie de la commande docker manifest push indique que la liste de manifeste est prête à être poussée.

Pour simuler le téléchargement de l'image multi-architecture et vérifier que Docker sélectionne la bonne architecture, vous pourriez essayer de télécharger l'image sur un système avec une architecture différente (si disponible). Cependant, dans cet environnement de laboratoire, nous pouvons nous appuyer sur la commande de push réussie et l'étape d'inspection précédente pour confirmer que la liste de manifeste est prête.

Résumé

Dans ce laboratoire, nous avons appris à préparer des images multi-architecture à l'aide de Docker. Cela implique d'activer les fonctionnalités expérimentales dans Docker pour utiliser la commande buildx, qui est essentielle pour construire des images compatibles avec différentes architectures telles que amd64 et arm64. Nous avons configuré le client Docker en modifiant le fichier config.json pour activer les fonctionnalités expérimentales. Ensuite, nous avons créé une nouvelle instance de générateur (builder) nommée mybuilder en utilisant docker buildx create --name mybuilder --use, capable de gérer les constructions multi-architecture. Enfin, nous avons configuré un répertoire de projet de base et créé un simple Dockerfile basé sur Alpine Linux comme base pour construire notre image multi-architecture.