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 diese Aufgabe 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.

Voraussetzungen

  • 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.
  • Wenn Sie Funktionen wie die intelligente Standardeinstellung (durch Angabe des Labels kubernetes.io/arch: arm64), die autopilot-arm-spot-ComputeClass oder die autopilot-arm-ComputeClass in GKE-Standardclustern verwenden möchten, die Autopilot-ComputeClasses verwenden, muss Ihr Cluster die Version 1.36.0-gke.3302001 oder höher ausführen.
  • 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

Damit Autopilot Ihre Pods auf Arm-Knoten ausführt, geben Sie einen der folgenden Selektoren (abhängig von Ihrem GKE-Typ und Ihrer GKE-Version) mit einem nodeSelector oder einer Knotenaffinitätsregel an:

  • In Autopilot-Clustern (Smart Defaulting): Geben Sie nur den Architekturtyp an:

    • kubernetes.io/arch: arm64

    Wenn Ihre Arbeitslast in einem Autopilot-Cluster ausgeführt wird, wird die Arm-Plattform für allgemeine Zwecke ausgewählt.

  • In Autopilot-Clustern oder Standardclustern, die Autopilot-Compute-Klassen verwenden (nur Compute-Klasse): Geben Sie die Compute-Klasse an:

    • cloud.google.com/compute-class: autopilot-arm (oder autopilot-arm-spot)

    Wenn Sie diese Klasse auswählen, wird Ihre Arbeitslast auf der containeroptimierten Arm-Plattform (oder ihrer Spot-VM-Variante) geplant und dem Pod wird während der Zulassung automatisch der erforderliche kubernetes.io/arch: arm64-Selektor hinzugefügt.

  • Explizite Auswahl (ältere GKE-Versionen): In Autopilot-Clustern mit Version 1.35.3-gke.1389000 oder höher, aber niedriger als 1.36.0-gke.3302001, müssen Sie beide folgenden Selektoren angeben, um die Allzweck-Arm-Plattform auszuwählen. Diese Kombination wird aus Gründen der Abwärtskompatibilität auch in neueren GKE-Versionen unterstützt:

    • cloud.google.com/compute-class: autopilot-arm
    • kubernetes.io/arch: arm64

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

    • kubernetes.io/arch: arm64 in einem Standardcluster. Standardmäßig platziert GKE die Pods auf C4A-Maschinentypen.
    • cloud.google.com/machine-family: ARM_MACHINE_SERIES. Ersetzen Sie ARM_MACHINE_SERIES durch eine Arm-Maschinenserie 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 das Label cloud.google.com/compute-class: Performance zusammen mit den Labels für Architektur oder Maschinenfamilie hinzu. Weitere Informationen finden Sie unter Leistung von Autopilot-Pods 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 für Container optimierter Arm-Knoten für Autopilot mit Smart Defaulting 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:
        kubernetes.io/arch: arm64
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi

Alternativ können Sie die containeroptimierte Arm-Plattform anfordern, indem Sie die Compute-Klasse autopilot-arm (oder autopilot-arm-spot für Spot-VMs) explizit angeben:

...
    spec:
      nodeSelector:
        cloud.google.com/compute-class: autopilot-arm
...

Wenn Sie bestimmte Hardware anstelle von für Autopilot optimierten Containerknoten anfordern möchten, ersetzen Sie die Compute-Klassen oder fügen Sie cloud.google.com/machine-family: C4A zu Ihrer Auswahl hinzu.

nodeAffinity

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

Im folgenden Beispielmanifest wird ein für Container optimierter Arm-Knoten für Autopilot mit Smart Defaulting 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: kubernetes.io/arch
                operator: In
                values:
                - arm64

Wenn Sie bestimmte Hardware anstelle von Autopilot-Container-optimierten Knoten anfordern möchten, ersetzen Sie kubernetes.io/arch durch bestimmte Regeln für die Affinität von Maschinenfamilien oder Anforderungsklassen wie 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-west2, europe-west4, asia-southeast1 und us-central1.

Fehlerbehebung

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

Nächste Schritte