Créer des images multi-architecture pour les charges de travail Arm

Cette page explique ce que sont les images multi-architecture (multi-arch), pourquoi les architectures des nœuds et des images de conteneurs sont importantes, et pourquoi les images multi-arch facilitent le déploiement de charges de travail sur les clusters GKE. Cette page explique également comment vérifier si vos charges de travail sont prêtes à s'exécuter sur Arm et comment créer des images multi-arch.

Pour consulter un tutoriel sur le déploiement dans plusieurs architectures avec des images multi-arch, consultez la page Migrer une application x86 sur GKE vers une architecture multi-arch avec Arm.

Qu'est-ce qu'une image multi-arch ?

Une image multi-arch est une image qui est compatible avec plusieurs architectures. Elle ressemble à une seule image avec un seul tag, mais il s'agit d'une liste d'images ciblant plusieurs architectures organisées par une liste de fichiers manifestes. Les images multi-arch sont compatibles avec Image Manifest V2 Scheme 2 de Docker et avec les spécifications Image Index d'OCI. Lorsque vous déployez une image multi-arch sur un cluster, GKE choisit automatiquement la bonne image qui est compatible avec l'architecture du nœud sur lequel elle est déployée. Une fois que vous disposez d'une image multi-arch pour une charge de travail, vous pouvez déployer cette charge de travail de manière fluide dans plusieurs architectures.

Les images multi-arch sont particulièrement utiles lorsque vous souhaitez utiliser la même charge de travail dans plusieurs architectures. Vous pouvez également utiliser des images de conteneurs avec une seule architecture avec n'importe quel type de nœuds GKE. Si vous n'utilisez une charge de travail que sur une architecture et que vous disposez déjà d'une image compatible, vous n'avez pas besoin de créer une image multi-arch.

Si vous utilisez une image à architecture unique ou une image multi-arch qui est compatible avec Arm et que vous souhaitez la déployer sur un nœud Arm, vous devez suivre les instructions pour inclure les champs nécessaires afin que GKE planifie la charge de travail comme prévu. Pour en savoir plus, consultez la page Préparer une charge de travail Arm pour le déploiement. Vous n'avez pas besoin d'ajouter ces champs pour planifier des charges de travail si elles ne doivent être planifiées que sur des nœuds basés sur x86.

Pourquoi l'architecture d'un nœud GKE est-elle importante pour les charges de travail ?

Les nœuds GKE sont des instances de VM Compute Engine individuelles que GKE crée et gère en votre nom. Chaque nœud est d'un type de machine standard (par exemple t2a-standard-1) qui utilise des processeurs x86 (Intel ou AMD) ou Arm. Pour en savoir plus, consultez la page Plates-formes de processeur.

Vous devez utiliser des images de conteneurs qui soient compatibles avec l'architecture du nœud sur lequel vous souhaitez exécuter les charges de travail. Par exemple, si vous souhaitez exécuter une image de conteneur avec l'architecture arm64, vous devez disposer d'un type de machine compatible avec les charges de travail Arm, tel que le type t2a-standard-1, associé à la série de machines Tau T2A. Vous pouvez utiliser des nœuds avec plusieurs types d'architecture dans un même cluster GKE. Si vous souhaitez utiliser une charge de travail sur plusieurs types d'architecture, vous devez organiser toutes les images de conteneurs et les fichiers de déploiement pour les images spécifiques à l'architecture. Les images multi-arch simplifient le processus de déploiement sur plusieurs types d'architecture.

Créer une image multi-arch à déployer sur les nœuds x86 et Arm

Les instructions suivantes sont destinées aux développeurs d'applications qui ont déjà les éléments suivants :

  • Un environnement de compilation avec un outil de conteneur téléchargé (par exemple Docker).
  • Une image de conteneur existante.

Les commandes suivantes utilisent Docker, mais vous pouvez peut-être utiliser d'autres outils de conteneur pour effectuer les mêmes tâches.

Ma charge de travail est-elle prête pour Arm ?

Si vous disposez déjà d'une image de conteneur, vous pouvez vérifier si cette charge de travail est prête à être exécutée sur un nœud Arm. Les sections suivantes expliquent comment procéder en utilisant docker run pour tenter d'exécuter le conteneur avec l'architecture Arm.

Préparer Docker dans votre environnement x86 pour vérifier une image de conteneur

Si vous exécutez Docker dans un environnement x86, vous devez télécharger des packages supplémentaires pour exécuter une image de conteneur arm64. Ces instructions utilisent apt pour la gestion des packages, mais vous pouvez utiliser le gestionnaire de packages de votre environnement pour télécharger les packages requis.

Si vous exécutez Docker dans un environnement Arm, vous pouvez ignorer cette section.

Les commandes suivantes téléchargent des packages et enregistrent QEMU en tant qu'interpréteur binfmt pour les architectures non compatibles avec votre machine :

sudo apt-get install qemu binfmt-support qemu-user-static
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

Après avoir défini vos interpréteurs binfmt, vous pouvez exécuter l'image arm64 dans votre environnement x86.

Vérifier la charge de travail pour l'aptitude Arm

Si vous exécutez Docker dans un environnement Arm ou si vous avez préparé votre environnement x86 pour exécuter des images Arm, exécutez la commande suivante :

docker run --platform linux/arm64 IMAGE_NAME

Remplacez IMAGE_NAME par le nom de l'image de conteneur.

La sortie suivante indique que votre image de conteneur est prête à s'exécuter sur des nœuds Arm avec votre cluster GKE :

Hello from Docker!
This message shows that your installation appears to be working correctly.

Si votre charge de travail est prête à être exécutée sur Arm, vous pouvez passer à la section Préparer une charge de travail Arm pour le déploiement.

La sortie suivante indique que votre image n'est pas prête à s'exécuter sur Arm :

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
93288797bd35: Pull complete
Digest: sha256:507ecde44b8eb741278274653120c2bf793b174c06ff4eaa672b713b3263477b
Status: Downloaded newer image for hello-world:latest
standard_init_linux.go:219: exec user process caused: exec format error

Cette sortie indique qu'il s'agit d'une image x86_64 ou amd64, et vous devez créer une image arm64. Passez à la section suivante, Créer une image multi-arch, dans laquelle vous pouvez utiliser une image de conteneur non compatible avec Arm, un Dockerfile, et créer une image multi-arch qui peut s'exécuter sur différents types d'architecture.

Créer une image multi-arch

Si vous disposez d'un Dockerfile, vous pouvez l'utiliser pour créer une image multi-arch compatible avec Arm et x86 que vous pouvez déployer sur des nœuds de différents types d'architecture.

Vous devez télécharger Docker Buildx pour effectuer les étapes suivantes. Vous devez également disposer d'un Dockerfile existant.

Préparer votre environnement si vous disposez d'une VM x86 et d'une VM Arm

Les commandes suivantes supposent que vous disposez à la fois d'une VM de compilation Arm et d'une VM de compilation x86 dans votre environnement de compilation, et que votre VM x86 peut se connecter en SSH en mode root à votre VM Arm. Si vous n'avez qu'une VM x86 dans votre environnement de compilation, suivez les instructions de la section suivante, Préparer votre environnement si vous ne disposez que d'une VM x86.

Préparez votre environnement pour créer des images multi-arch :

  1. Créez un contexte pour le nœud x86 à l'aide du socket local et un contexte pour le nœud Arm à l'aide de SSH :

     docker context create amd_node --docker "host=unix:///var/run/docker.sock"
 docker context create arm_node --docker "host=ssh://root@NODE_IP"

    Remplacez NODE_IP par l'adresse IP du nœud Arm.

  2. Créez un compilateur à l'aide du nœud x86 :

    docker buildx create --use --name BUILDER_NAME --platform linux/amd64 amd_node
docker buildx create --append --name BUILDER_NAME --platform linux/arm64 arm_node

    Remplacez BUILDER_NAME par le nom de votre choix pour le compilateur Buildx.

Préparer votre environnement si vous ne disposez que d'une VM x86

Si votre environnement de compilation ne comporte qu'une VM x86, vous pouvez suivre les étapes ci-dessous pour préparer votre environnement afin de créer des images multi-arch. Avec cette option, l'étape de compilation peut prendre plus de temps.

  1. Installez les packages QEMU :

    docker run --rm --privileged multiarch/qemu-user-static

  2. Créez un compilateur multi-arch (le compilateur par défaut n'est pas compatible avec une configuration multi-arch):

    docker buildx create --name BUILDER_NAME --use

    Remplacez BUILDER_NAME par le nom de votre choix pour le compilateur Buildx.

Créer l'image

Maintenant que votre environnement est prêt, exécutez la commande suivante pour créer une image multi-arch :

docker buildx build . -t PATH_TO_REGISTRY  --platform linux/amd64,linux/arm64 --push

Remplacez PATH_TO_REGISTRY par le chemin d'accès à votre registre, se terminant par le nom de votre image de conteneur et un tag (par exemple gcr.io/myproject/myimage:latest).

Si vous recevez un message d'erreur à cette étape, reportez-vous au guide Docker et à la documentation associée pour résoudre le problème.

Une fois que vous avez créé une image multi-arch, votre charge de travail est prête à être exécutée sur Arm. Passez à la page Préparer une charge de travail Arm pour le déploiement.

Étape suivante