Compute-Klassen in Autopilot


Auf dieser Seite werden die Computing-Klassen beschrieben, mit denen Sie Google Kubernetes Engine-Arbeitslasten (GKE) mit bestimmten Hardwareanforderungen ausführen können. Eine Anleitung finden Sie unter Autopilot-Pods auf bestimmten Compute-Klassen ausführen.

Übersicht über Autopilot-Computing-Klassen

Standardmäßig werden GKE Autopilot-Pods auf einer Computing-Plattform ausgeführt, die für allgemeine Arbeitslasten wie Web-Serving und Batchjobs mit mittlerer Intensität optimiert ist. Diese allgemeine Plattform bietet eine zuverlässige, kostenoptimierte Hardwarekonfiguration, die die Anforderungen der meisten Arbeitslasten bewältigen kann.

Wenn Sie Arbeitslasten mit besonderen Hardwareanforderungen haben, z. B. maschinelles Lernen oder KI-Aufgaben ausführen, Datenbanken mit hohem Traffic in Echtzeit ausführen oder bestimmte CPU-Plattformen und -Architekturen benötigen, bietet Autopilot Computing Klassen: Diese Compute-Klassen sind eine ausgewählte Teilmenge der Compute Engine-Maschinenserie und bieten mehr Flexibilität als die Standard-Autopilot-Computing-Klasse. Die Compute-Klasse Scale-Out verwendet beispielsweise VMs, die das gleichzeitige Multi-Threading deaktivieren und für die horizontale Skalierung optimiert sind.

Sie können Knoten anfordern, die von bestimmten Compute-Klassen unterstützt werden. Dies hängt von den Anforderungen der einzelnen Arbeitslasten ab. Ähnlich wie die Standard-Computing-Klasse für allgemeine Zwecke verwaltet Autopilot die Größe und Ressourcenzuweisung der angeforderten Compute-Klassen basierend auf den ausgeführten Pods. Sie können Compute-Klassen auf Pod-Ebene anfordern, um die Kosteneffizienz zu optimieren, indem Sie die beste Lösung für die Anforderungen jedes Pods auswählen.

Bestimmte CPU-Architektur auswählen

Wenn Ihre Arbeitslasten für bestimmte CPU-Plattformen oder -Architekturen vorgesehen sind, können Sie diese Plattformen oder Architekturen optional in Ihren Pod-Spezifikationen auswählen. Wenn Ihre Pods beispielsweise auf Knoten ausgeführt werden sollen, die die Armor-Architektur verwenden, können Sie arm64 in der Compute-Klasse Scale-Out auswählen.

Preise

Die Preise für GKE Autopilot-Pods richten sich nach den Knoten, auf denen die Pods geplant sind. Preisinformationen zu allgemeinen Arbeitslasten und Spot-Pods in bestimmten Compute-Klassen sowie Informationen zu Rabatten für zugesicherte Nutzung finden Sie unter Preise für Autopilot-Modus.

Spot-Pods auf allgemeinen oder speziellen Compute-Klassen sind nicht für Rabatte für zugesicherte Nutzung qualifiziert.

Wann werden bestimmte Compute-Klassen verwendet?

Die folgende Tabelle bietet einen technischen Überblick über die von Autopilot unterstützten Computing-Klassen sowie Beispielanwendungsfälle für Pods, die auf jeder Plattform ausgeführt werden. Wenn Sie keine Computing-Klasse anfordern, platziert Autopilot Ihre Pods auf der Computing-Plattform für allgemeine Zwecke, die für die optimale Ausführung der meisten Arbeitslasten ausgelegt ist.

Arbeitslastanforderung Compute-Klasse Beschreibung Beispielanwendungsfälle
Arbeitslasten, die keine bestimmte Hardware erfordern Allgemeiner Zweck

Autopilot verwendet die allgemeine Computing-Plattform, wenn Sie in Ihrer Pod-Spezifikation nicht explizit eine Compute-Klasse anfordern.

Sie können die allgemeine Plattform in Ihrer Spezifikation nicht explizit auswählen.

Unterstützt von der E2-Maschinenserie.

  • Webserver
  • Kleine bis mittelgroße Datenbanken
  • Entwicklungsumgebungen
Arbeitslasten, die GPUs erfordern Accelerator
  • Pods können jederzeit auf Rechenressourcen zugreifen
  • Keine Pod-Speicher- oder CPU-Limits

Kompatible GPU-Typen sind die folgenden:

  • nvidia-h100-80gb: NVIDIA H100 (80 GB) (nur mit Accelerator-Computing-Klasse verfügbar)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (80 GB)
  • nvidia-l4; NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4

  • GPU-orientiertes KI/ML-Training und -Inferenz
CPU- oder Speicheranforderungen, die größer sind als die Limits für Computing-Klassen für allgemeine Zwecke oder bestimmte CPU-Plattformen Balanced
  • Verfügbare CPUs: AMD EPYC Rome, AMD EPYC Milan, Intel Ice Lake, Intel Cascade Lake
  • Verfügbare Architektur: amd64
  • Unterstützte Ressourcenanfragen, die größer als für allgemeine Zwecke sind
  • Möglichkeit, Mindest-CPU-Plattformen für Pods festzulegen, z. B. „Intel Ice Lake oder höher“.

Unterstützt durch die N2-Maschinenserie (Intel) oder die N2D-Maschinenserie (AMD).

  • Webserver
  • Mittlere bis große Datenbanken
  • Caching
  • Streaming und Medienbereitstellung
  • Hyperdisk Throughput und Extrem-Speicher
CPU-intensive Arbeitslasten wie KI/ML-Training oder Hochleistungs-Computing (HPC) Performance
  • Verfügbare Architektur: amd64, arm64
  • Pods können jederzeit auf Rechenressourcen zugreifen
  • Keine Pod-Speicher- oder CPU-Limits

Eine Liste der Compute Engine-Maschinenserien, die mit der Computingklasse "Leistung" verfügbar sind, finden Sie unter Unterstützte Maschinenserien.

  • CPU-orientiertes KI/ML-Training und -Inferenz
  • HPC-Batcharbeitslasten
  • Hyperdisk abgestimmt, Durchsatz und extremer Speicher
Single-Thread-pro-Core-Computing und horizontale Skalierung Scale-Out
  • Verfügbare CPUs: Ampere Altra Arm oder AMD EPYC Milan
  • Compute Engine-Maschinenfamilie: T2A (Arm), T2D (x86)
  • Verfügbare Architektur: arm64 oder amd64
  • SMT aus. Eine vCPU entspricht einem physischen Kern.
  • Max. 3,5 GHz-Takt

Unterstützt durch die Tau T2A-Maschinenserie (Arm) oder die Tau T2D-Maschinenserie (x86).

  • Webserver
  • Containerisierte Mikrodienste
  • Datenlogverarbeitung
  • Umfangreiche Java-Anwendungen
  • Hyperdisk Durchsatz-Speicher

So wählen Sie eine Compute-Klasse in Autopilot aus

Eine ausführliche Anleitung finden Sie unter Computing-Klassen für Autopilot-Pods auswählen.

Damit Autopilot Ihre Pods in einer bestimmten Compute-Klasse platzieren kann, geben Sie das Label cloud.google.com/compute-class in einemnodeSelector oder einer Knotenaffinitätsregel wie in den folgenden Beispielen an:

nodeSelector

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: hello-app
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: hello-app
      template:
        metadata:
          labels:
            app: hello-app
        spec:
          nodeSelector:
            cloud.google.com/compute-class: "COMPUTE_CLASS"
          containers:
          - name: hello-app
            image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
            resources:
              requests:
                cpu: "2000m"
                memory: "2Gi"
    

Ersetzen Sie COMPUTE_CLASS durch den Namen der Compute-Klasse basierend auf Ihrem Anwendungsfall, z. B. Scale-Out. Wenn Sie Accelerator auswählen, müssen Sie auch eine kompatible GPU angeben. Eine Anleitung finden Sie unter GPU-Arbeitslasten in Autopilot bereitstellen. Wenn Sie Performance auswählen, müssen Sie auch eine Compute Engine-Maschinenserie im Knotenselektor auswählen. Eine Anleitung finden Sie unter CPU-intensive Arbeitslasten mit optimaler Leistung ausführen.

nodeAffinity

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: hello-app
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: hello-app
      template:
        metadata:
          labels:
            app: hello-app
        spec:
          terminationGracePeriodSeconds: 25
          containers:
          - name: hello-app
            image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
            resources:
              requests:
                cpu: "2000m"
                memory: "2Gi"
                ephemeral-storage: "1Gi"
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  - key: cloud.google.com/compute-class
                    operator: In
                    values:
                    - "COMPUTE_CLASS"
      

Ersetzen Sie COMPUTE_CLASS durch den Namen der Compute-Klasse entsprechend Ihrem Anwendungsfall, z. B. Scale-Out. Wenn Sie Accelerator auswählen, müssen Sie auch eine kompatible GPU angeben. Ein Anleitung finden Sie unter GPU-Arbeitslasten in Autopilot bereitstellen. Wenn Sie Performance auswählen, müssen Sie auch eine Compute Engine-Maschinenserie im Knotenselektor auswählen. Eine Anleitung finden Sie unter CPU-intensive Arbeitslasten mit optimaler Leistung ausführen.

Zum Bereitstellen der Arbeitslast führt Autopilot Folgendes aus:

  • Stellt automatisch Knoten bereit, die von der angegebenen Konfiguration unterstützt werden, um Ihre Pods auszuführen.
  • Markierungen werden den neuen Knoten automatisch hinzugefügt, um zu verhindern, dass andere Pods auf diesen Knoten geplant werden. Die Markierungen sind für jede Compute-Klasse eindeutig. Wenn Sie auch eine CPU-Architektur auswählen, fügt GKE eine separate Markierung hinzu, die für diese Architektur eindeutig ist.
  • Fügt den bereitgestellten Pods automatisch Toleranzen hinzu, die den angewendeten Markierungen entsprechen, sodass GKE diese Pods auf den neuen Knoten platzieren kann.

Wenn Sie beispielsweise die Compute-Klasse Scale-Out für einen Pod anfordern:

  1. Autopilot fügt für diese Knoten eine Markierung hinzu, die für Scale-Out spezifisch ist.
  2. Autopilot fügt den Scale-Out-Pods eine Toleranz für diese Markierung hinzu.

Pods, die nicht Scale-Out anfordern, erhalten keine Toleranz. Daher plant GKE diese Pods nicht auf den Scale-Out-Knoten.

Wenn Sie in der Arbeitslastspezifikation nicht explizit eine Compute-Klasse anfordern, plant Autopilot Pods auf Knoten, die die Standard-Computing-Klasse für allgemeine Zwecke verwenden. Die meisten Arbeitslasten können ohne Probleme in der Compute-Klasse für allgemeine Zwecke ausgeführt werden.

CPU-Architektur anfordern

In einigen Fällen können Ihre Arbeitslasten für eine bestimmte Architektur wie Arm erstellt werden. Einige Compute-Klassen wie etwa „ausgeglichen“ oder „horizontal skalieren“ unterstützen mehrere CPU-Architekturen. Sie können neben einer Compute-Klasse auch eine bestimmte Architektur anfordern. Geben Sie dazu ein Label in Ihrer Knotenauswahl oder Knotenaffinitätsregel an, wie im folgenden Beispiel gezeigt:

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

Ersetzen Sie ARCHITECTURE durch die gewünschte CPU-Architektur, z. B. arm64 oder amd64.

Wenn Sie nicht explizit eine Architektur anfordern, verwendet Autopilot die Standardarchitektur der angegebenen Compute-Klasse.

Armarchitektur auf Autopilot

Autopilot unterstützt Anfragen für Knoten, die die ARM-CPU-Architektur verwenden. ARM-Knoten sind kostengünstiger als ähnliche x86-Knoten und bieten gleichzeitig Leistungsverbesserungen. Eine Anleitung zum Anfordern von ARM-Knoten finden Sie unter Autopilot-Arbeitslasten in der ARM-Architektur bereitstellen.

Prüfen Sie, ob Sie in Ihren Bereitstellungen die richtigen Images verwenden. Wenn Ihre Pods ARM-Images verwenden und Sie keine ARM-Knoten anfordern, plant Autopilot die Pods auf x86-Knoten und die Pods abstürzen. Ähnlich verhält es sich, wenn Sie versehentlich x86-Images verwenden, aber ARM-Knoten für die Pods anfordern, die dann zum Absturz der Pods führen.

Autopilot-Validierungen für Computing-Klassenarbeitslasten

Autopilot überprüft Ihre Arbeitslastmanifeste, um zu gewährleisten, dass die Anfragen an die Compute-Klasse und -Architektur in Ihrer Knotenauswahl oder in den Knotenaffinitätsregeln korrekt formatiert sind. Es gelten die folgenden Regeln:

  • Nicht mehr als eine Compute-Klasse.
  • Keine nicht unterstützten Compute-Klassen.
  • Die GKE-Version muss die Compute-Klasse unterstützen.
  • Maximal eine ausgewählte Architektur.
  • Die Compute-Klasse muss die ausgewählte Architektur unterstützen.

Wenn Ihr Arbeitslastmanifest eine dieser Validierungen fehlschlägt, lehnt Autopilot die Arbeitslast ab.

Regionale Verfügbarkeit der Compute-Klasse

In der folgenden Tabelle werden die Regionen beschrieben, in denen bestimmte Compute-Klassen und CPU-Architekturen verfügbar sind:

Verfügbarkeit der Compute-Klasse
Allgemeiner Zweck Alle Regionen
Balanced Alle Regionen
Performance Alle Regionen, die eine unterstützte Maschinenserie enthalten.
Scale-Out Alle Regionen, die eine entsprechende Compute Engine-Maschinenserie enthalten. Verwenden Sie die Filter unter Verfügbare Regionen und Zonen, um bestimmte Verfügbarkeiten von Maschinenserien aufzurufen.

Wenn eine Compute-Klasse in einer bestimmten Region verfügbar ist, ist die Hardware in mindestens zwei Zonen in dieser Region verfügbar.

Standard-, Mindest- und Höchstwerte für Ressourcenanfragen

Wenn Sie eine Compute-Klasse für Ihre Autopilot-Arbeitslasten auswählen, müssen Sie Ressourcenanfragen angeben, die die Mindest- und Höchstwerte für diese Computing-Klasse erfüllen. Informationen zu den Standardanfragen sowie zu den Mindest- und Höchstwerten für jede Anfrageklasse finden Sie unter Ressourcenanfragen und -limits in GKE Autopilot.

Nächste Schritte