Déployer des charges de travail Autopilot sur l'architecture Arm

Cette page explique comment configurer vos déploiements Autopilot pour Google Kubernetes Engine (GKE) afin de demander des nœuds qui s'appuient sur l'architecture Arm.

À propos de l'architecture Arm dans Autopilot

Les clusters Autopilot proposent des classes de calcul pour les charges de travail qui nécessitent des exigences matérielles spécifiques. Certaines de ces classes de calcul sont compatibles avec plusieurs architectures de processeur, telles que amd64 et arm64.

Cas d'utilisation des nœuds Arm

Les nœuds à l'architecture Arm offrent des performances plus économiques que les nœuds x86 similaires. Vous devez sélectionner Arm pour vos charges de travail Autopilot dans les situations suivantes :

  • Votre environnement repose sur l'architecture Arm pour créer et tester.
  • Vous développez des applications pour des appareils Android qui s'exécutent sur des processeurs Arm.
  • Vous utilisez des images multi-arch et souhaitez optimiser les coûts lors de l'exécution de vos charges de travail.

Demander des nœuds Arm dans Autopilot

Pour demander des nœuds Arm pour vos pods, vous devez demander des nœuds avec l'architecture Arm et une classe de calcul compatible avec les nœuds Arm. Les sections suivantes vous expliquent comment demander la classe de calcul et l'architecture Arm à l'aide d'un sélecteur de nœud ou d'une règle d'affinité de nœuds dans la spécification de votre pod.

Pour obtenir la liste des classes de calcul compatibles avec l'architecture Arm, consultez la section Classes de calcul dans Autopilot.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
    • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  • Assurez-vous de disposer d'un cluster GKE Autopilot exécutant GKE version 1.24.1-gke.1400 ou ultérieure. Pour définir la version, utilisez l'option --cluster-version dans votre commande create ou mettre à niveau.
  • Vérifiez que vous disposez d'un quota pour le type de machine Compute Engine T2A.
  • Assurez-vous de disposer d'un pod avec une image de conteneur créée pour l'architecture Arm.

Demander une classe de calcul et une architecture Arm

Pour indiquer à Autopilot de placer vos pods sur une classe de calcul compatible avec l'architecture Arm, spécifiez les deux libellés suivants dans un nodeSelector ou la règle d'affinité de nœuds :

cloud.google.com/compute-class: COMPUTE_CLASS
kubernetes.io/arch: arm64

Remplacez COMPUTE_CLASS par le nom d'une classe de calcul compatible avec l'architecture Arm, telle que Scale-Out.

Lorsque vous déployez votre charge de travail, Autopilot effectue les opérations suivantes :

  1. Provisionne automatiquement les nœuds Arm pour exécuter vos pods.
  2. Rejette automatiquement les nouveaux nœuds afin d'éviter que les pods non Arm soient planifiés sur ces nœuds.
  3. Ajoute automatiquement une tolérance à vos pods Arm afin de permettre la planification sur les nouveaux nœuds.

Vous pouvez également demander une architecture Arm pour les pods Spot.

Exemple de requête pour l'architecture Arm

Les exemples de spécifications suivants montrent comment utiliser un sélecteur de nœud ou une règle d'affinité de nœud pour demander une architecture Arm dans Autopilot.

nodeSelector

L'exemple de fichier manifeste suivant montre comment demander des nœuds Arm dans un sélecteur de nœud :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-arm
  template:
    metadata:
      labels:
        app: nginx-arm
    spec:
      nodeSelector:
        cloud.google.com/compute-class: Scale-Out
        kubernetes.io/arch: arm64
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi

nodeAffinity

Vous pouvez utiliser l'affinité de nœuds pour demander des nœuds Arm. Vous pouvez également spécifier le type d'affinité de nœuds à utiliser :

  • requiredDuringSchedulingIgnoredDuringExecution : doit utiliser la classe et l'architecture de calcul spécifiées.
  • preferredDuringSchedulingIgnoredDuringExecution : utilise la classe et l'architecture de calcul spécifiées de la manière la plus optimale possible. Par exemple, si un nœud x86 existant peut être alloué, GKE place votre pod sur le nœud x86 au lieu de provisionner un nouveau nœud Arm. À moins d'utiliser un fichier manifeste d'image multi-arch, votre pod plante. Nous vous recommandons vivement de demander explicitement l'architecture spécifique que vous souhaitez.

L'exemple de fichier manifeste suivant requiert la classe Scale-Out et les nœuds Arm :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-arm
  template:
    metadata:
      labels:
        app: nginx-arm
    spec:
      terminationGracePeriodSeconds: 25
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi
            ephemeral-storage: 1Gi
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: cloud.google.com/compute-class
                operator: In
                values:
                - Scale-Out
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64

Recommandations

  • Créez et utilisez des images multi-arch dans le cadre de votre pipeline. Les images multi-arch garantissent que vos pods s'exécutent même s'ils sont placés sur des nœuds x86.
  • Demandez explicitement des classes d'architecture et de calcul dans vos fichiers manifestes de charge de travail. Si vous ne le faites pas, Autopilot utilise l'architecture par défaut de la classe de calcul sélectionnée, qui peut ne pas être Arm.

Disponibilité

Vous pouvez déployer des charges de travail Autopilot sur l'architecture Arm dans les régions Google Cloud suivantes :

  • us-central1
  • europe-west4
  • asia-southeast1

Dépannage

Pour obtenir des informations sur les erreurs courante et le dépannage, consultez la section Résoudre les problèmes liés aux charges de travail Arm.

Étape suivante