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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Voraussetzungen

  • Wenn Sie die Compute-Klasse autopilot-arm verwenden möchten, muss auf Ihrem Cluster GKE-Version 1.35.3-gke.1389000 oder höher ausgeführt werden.
  • Wenn Sie Funktionen wie die intelligente Standardeinstellung (durch Angabe des kubernetes.io/arch: arm64 Labels), die autopilot-arm-spot Compute-Klasse oder die autopilot-arm Compute-Klasse in GKE Standard-Clustern verwenden möchten, die Autopilot-Compute-Klassen verwenden, muss auf Ihrem Cluster Version 1.36.0-gke.3302001 oder höher ausgeführt werden.
  • Achten Sie darauf, dass Sie ein Kontingent für die C4A, N4A, oder Tau T2A Compute Engine-Maschinentypen 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 mit einer nodeSelector oder Knotenaffinität regel einen der folgenden Selektoren an (je nach GKE-Typ und -Version):

  • In Autopilot-Clustern (intelligente Standardeinstellung) : Geben Sie nur den Architekturtyp an:

    • kubernetes.io/arch: arm64

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

  • In Autopilot-Clustern oder Standard-Clustern, 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 während der Zulassung automatisch der erforderliche Selektor kubernetes.io/arch: arm64 hinzugefügt.

  • Explizite Auswahl (ältere GKE-Versionen) : Geben Sie in Autopilot-Clustern mit Version 1.35.3-gke.1389000 oder höher, aber älter als 1.36.0-gke.3302001, beide folgenden Selektoren an, um die Arm-Plattform für allgemeine Zwecke 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 bestimmten Hardwareanforderungen:Geben Sie eine der folgenden Optionen an:

    • kubernetes.io/arch: arm64 in einem Standard-Cluster. 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 in der angegebenen Serie.

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

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

Das folgende Beispielmanifest fordert einen containeroptimierten Autopilot-Arm-Knoten mit intelligenter Standardeinstellung an:

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 containeroptimierten Autopilot-Knoten anfordern möchten, ersetzen Sie die Compute-Klassen oder fügen Sie Ihrem Selektor cloud.google.com/machine-family: C4A hinzu.

nodeAffinity

Sie können Knotenaffinität verwenden, um Arm-Knoten anzufordern.

Das folgende Beispielmanifest fordert einen containeroptimierten Autopilot-Arm-Knoten mit intelligenter Standardeinstellung an:

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 containeroptimierten Autopilot-Knoten anfordern möchten, ersetzen Sie kubernetes.io/arch durch bestimmte Regeln für die Affinität von Maschinenfamilien oder fordern Sie Klassen wie Performance oder Scale-Out an.

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