Autopilot-Arbeitslasten in der Arm-Architektur bereitstellen

Auf dieser Seite erfahren Sie, wie Sie Ihre GKE-Autopilot-Bereitstellungen (Google Kubernetes Engine) konfigurieren, um Knoten anzufordern, die von Arm-Architektur unterstützt werden.

Über Arm-Architektur in Autopilot

Autopilot-Cluster bieten Compute-Klassen für Arbeitslasten, die bestimmte Hardwareanforderungen haben. Einige dieser Rechenklassen unterstützen mehrere CPU-Architekturen wie amd64 und arm64.

Anwendungsfälle für Arm-Knoten

Knoten mit der Arm-Architektur bieten eine kostengünstigere Leistung als ähnliche x86-Knoten. Sie sollten Arm für Ihre Autopilot-Arbeitslasten in Situationen wie der folgenden auswählen:

  • Ihre Umgebung basiert auf der Arm-Architektur zum Erstellen und Testen.
  • Sie entwickeln Anwendungen für Android-Geräte, die auf Arm-CPUs ausgeführt werden.
  • Sie verwenden Images für mehrere Architekturen und möchten die Kosten optimieren, während Sie Ihre Arbeitslasten ausführen.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
    • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
  • Sehen Sie sich die Anforderungen und Einschränkungen für Arm-Knoten an.
  • Wenn Sie die autopilot-arm ComputeClass verwenden möchten, muss auf Ihrem Cluster die GKE-Version 1.35.3-gke.1389000 oder höher ausgeführt werden.
  • Achten Sie darauf, dass Sie ein Kontingent für die Compute Engine-Maschinentypen C4A, N4A oder Tau T2A haben.
  • Prüfen Sie, ob Sie einen Pod mit einem Container-Image haben, das für die Arm-Architektur erstellt wurde.

Arm-Knoten im Autopilot anfordern

Wenn Sie Autopilot anweisen möchten, Ihre Pods auf Arm-Knoten auszuführen, verwenden Sie je nach Ihren Anforderungen eine der folgenden Methoden. Sie geben diese mit einem nodeSelector oder einer Knotenaffinitätsregel an:

  • Für Arbeitslasten für allgemeine Zwecke:Fordern Sie die containeroptimierte Arm-Plattform an, indem Sie Folgendes angeben:
    • cloud.google.com/compute-class: autopilot-arm
    • kubernetes.io/arch: arm64

  • Für Arbeitslasten mit bestimmten Hardwareanforderungen:Geben Sie eine der folgenden Optionen an:

    • kubernetes.io/arch: arm64. In Clustern mit Version 1.31.3-gke.1056000 und höher platziert GKE Pods standardmäßig auf C4A-Maschinentypen. Wenn auf dem Cluster eine frühere Version ausgeführt wird, platziert GKE Pods auf T2A-Maschinentypen.

    • cloud.google.com/machine-family: ARM_MACHINE_SERIES. Ersetzen Sie ARM_MACHINE_SERIES durch eine Arm-Maschinenreihe wie C4A, N4A oder T2A. GKE platziert Pods auf der angegebenen Serie.

Wenn Sie eines der Labels außer Performance verwenden, kann GKE standardmäßig andere Pods auf demselben Knoten platzieren, sofern auf diesem Knoten Kapazität verfügbar ist. Wenn Sie einen dedizierten Knoten für jeden Pod anfordern möchten, fügen Sie dem Manifest neben den Architektur- oder Maschinenfamilienlabels das Label cloud.google.com/compute-class: Performance hinzu. Weitere Informationen finden Sie unter Autopilot-Pod-Leistung durch Auswahl einer Maschinenserie optimieren.

Alternativ können Sie das Label Scale-Out mit dem Label arm64 verwenden, um T2A anzufordern. Sie können auch die Arm-Architektur für Spot-Pods anfordern.

Zum Bereitstellen Ihrer Arbeitslast führt Autopilot Folgendes aus:

  1. Stellt automatisch Arm-Knoten bereit, um Ihre Pods auszuführen.
  2. Die neuen Knoten werden automatisch markiert, damit keine Nicht-Arm-Pods auf diesen Knoten geplant werden.
  3. Fügt Ihren Arm-Pods automatisch eine Toleranz hinzu, um die Planung auf den neuen Knoten zu ermöglichen.

Beispielanfrage für die Arm-Architektur

Die folgenden Beispielspezifikationen zeigen, wie Sie eine Knotenauswahl oder eine Knotenaffinitätsregel verwenden, um die Arm-Architektur in Autopilot anzufordern.

nodeSelector

Im folgenden Beispielmanifest wird ein containeroptimierter Arm-Knoten in Autopilot angefordert:

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

Wenn Sie bestimmte Hardware anstelle von für Autopilot optimierten Containern anfordern möchten, ersetzen Sie autopilot-arm in der nodeSelector durch Performance oder Scale-Out.

nodeAffinity

Sie können Arm-Knoten mithilfe der Knotenaffinität anfordern.

Im folgenden Beispielmanifest wird ein containeroptimierter Arm-Knoten in Autopilot angefordert:

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:
                - autopilot-arm
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64

Wenn Sie anstelle von für Autopilot optimierten Containern bestimmte Hardware anfordern möchten, ersetzen Sie autopilot-arm in den nodeAffinity-Regeln durch Performance oder Scale-Out.

Empfehlungen

  • Images für mehrere Architekturen als Teil Ihrer Pipeline erstellen und verwenden. Images für mehrere Architekturen sorgen dafür, dass Ihre Pods auch dann ausgeführt werden, wenn sie auf x86-Knoten platziert werden.
  • Fordern Sie explizit Architektur und Compute-Klassen in Ihren Arbeitslastmanifesten an. Wenn nicht, verwendet Autopilot die Standardarchitektur der ausgewählten Compute-Klasse, die möglicherweise nicht "Arm" ist.

Verfügbarkeit

Sie können Autopilot-Arbeitslasten in der Arm-Architektur in den folgenden Regionen bereitstellen: us-east1, us-west1, europe-west1, europe-west4 und us-central1.

Fehlerbehebung

Allgemeine Fehler und Informationen zur Fehlerbehebung finden Sie unter Fehlerbehebung bei Arm-Arbeitslasten.

Nächste Schritte