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.

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.

• Consultez les exigences et les limites relatives aux nœuds Arm.
• Vérifiez que vous disposez d'un quota pour les types de machines Compute Engine C4A ou Tau T2A.
• Assurez-vous de disposer d'un pod avec une image de conteneur créée pour l'architecture Arm.

Demander des nœuds Arm dans Autopilot

Pour indiquer à Autopilot d'exécuter vos pods sur des nœuds Arm, spécifiez l'un des libellés suivants dans un nodeSelector ou une règle d'affinité de nœuds :

• kubernetes.io/arch: arm64. GKE place les pods sur des types de machines C4A par défaut pour les clusters exécutant la version 1.31.3-gke.1056000 et ultérieures. Si le cluster exécute une version antérieure, GKE place les pods sur des types de machines T2A.
• cloud.google.com/machine-family: ARM_MACHINE_SERIES. Remplacez ARM_MACHINE_SERIES par une série de machines Arm, comme C4A ou T2A. GKE place les pods sur la série spécifiée.

Par défaut, l'utilisation de l'un ou l'autre de ces libellés permet à GKE de placer d'autres pods sur le même nœud si la capacité est disponible. Pour demander un nœud dédié pour chaque pod, ajoutez le libellé cloud.google.com/compute-class: Performance à votre fichier manifeste. Pour en savoir plus, consultez Optimiser les performances des pods Autopilot en choisissant une série de machines.

Vous pouvez également utiliser le libellé Scale-Out avec le libellé arm64 pour demander T2A. Vous pouvez également demander une architecture Arm pour les pods Spot.

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.

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.

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: Performance
        kubernetes.io/arch: arm64
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi

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:
                - Performance
              - 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 lesGoogle Cloud qui la prennent en charge. Pour en savoir plus, consultez la section Régions et zones disponibles.

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

• Obtenez plus d'informations sur l'architecture des clusters Autopilot.
• Apprenez-en plus sur le cycle de vie des pods.
• Découvrez les classes de calcul Autopilot disponibles.
• Découvrez les requêtes de ressources par défaut, minimales et maximales pour chaque plate-forme.