GPU-Arbeitslasten in Autopilot bereitstellen

Auf dieser Seite erfahren Sie, wie Sie verschiedene Arten und Mengen von Hardwarebeschleunigern (GPUs) für Ihre Autopilot-Arbeitslasten von Google Kubernetes Engine (GKE) anfordern und die Leistung überwachen.

Beschleuniger in Pods auswählen

Autopilot verwendet die spezielle Accelerator-Computing-Klasse, um GPU-Pods auszuführen Mit dieser Compute-Klasse platziert GKE Pods auf GPU-Knoten und bietet den Pods Zugriff auf erweiterte Funktionen auf der virtuellen Maschine (VM). Führen Sie einen der folgenden Schritte aus, um diese Klasse in einer GPU-Arbeitslast zu verwenden, führen Sie je nach GKE-Version folgende Aktionen aus:

  • Version 1.29.4-gke.1427000 und höher: Fordern Sie GPUs in Ihrem Workload-Manifest an. Sie können auch GPU-Freigabefunktionen wie die Zeitfreigabe verwenden. GKE ändert Ihr Workload-Manifest nicht, um einen Knotenselektor oder eine Knotenannotation für die Accelerator-Klasse hinzuzufügen.
  • Version 1.29 bis 1.29.4-gke.142700 (nicht einschließlich): Geben Sie den Knotenselektor cloud.google.com/compute-class: Accelerator in Ihrem Pod-Manifest an und fordern Sie GPUs an. Wenn Sie diesen Knotenselektor angeben, können Sie auch GPU-Freigabefunktionen wie die Zeitfreigabe verwenden.
  • Version 1.28.9-gke.1069000 bis Version 1.29 (nicht einschließlich): Geben Sie den cloud.google.com/compute-class: Accelerator-Knotenselektor im Pod-Manifest zusammen mit den GPU-Selektoren an. Wenn Sie diesen Knotenselektor angeben, können Sie auch GPU-Freigabefunktionen wie die Zeitfreigabe verwenden.

Die Compute-Klasse Accelerator wird nicht in Versionen unterstützt, die älter sind als 1.28.9-gke.1069000. Stattdessen werden GPU-Pods in diesen Versionen ähnlich behandelt wie andere Autopilot-Pods und Ihnen werden die Ressourcenanfragen in Rechnung gestellt. Weitere Informationen finden Sie unter Preise.

Kompatibilität mit GKE-Funktionen

Die folgende Tabelle zeigt die kompatiblen GKE-Funktionen für jede Methode zur Auswahl von Beschleunigern in GKE Autopilot:

Accelerator Computing-Klasse ausgewählt Kompatibilität mit GKE-Funktionen

Preise

In der folgenden Tabelle wird beschrieben, wie das von GKE verwendete Abrechnungsmodell von der GKE-Version Ihres Clusters abhängt. Eine Beschreibung der GKE Autopilot-Abrechnungsmodelle finden Sie unter Autopilot-Preise:

GKE-Version Preise
1.29.4-gke.1427000 und höher

Knotenbasiertes Abrechnungsmodell. Alle GPU-Pods verwenden die Accelerator Compute-Klasse. Ihnen werden die Compute Engine-Hardware, auf der Ihre GPU-Arbeitslasten ausgeführt werden, sowie ein Autopilot-Preisaufschlag für automatische Knotenverwaltung und Skalierbarkeit in Rechnung gestellt. Weitere Informationen finden Sie unter Autopilot-Modus<. Preise.
Von Version 1.29 bis 1.29.4-gke.1427000 (nicht einschließlich)

Das Abrechnungsmodell hängt von der Knotenauswahl ab, die Sie angeben:

  • cloud.google.com/compute-class: Accelerator: Verwendet das Knotenbasierte Abrechnungsmodell und den Compute-Klasse Accelerator.
  • Keine Auswahl für Compute-Klassen: Es wird das Pod-basierte Abrechnungsmodell verwendet.

    • Sie können Funktionen wie GPUs mit mehreren Instanzen oder die Zeitfreigabe nur verwenden, wenn Sie die Knotenselektor-Variable cloud.google.com/compute-class: Accelerator explizit angeben.

    Weitere Informationen finden Sie im Abschnitt „Pods mit bestimmten Hardwareanforderungen“ unter Kubernetes Engine-Preise.
Von Version 1.28.6-gke.1095000 bis 1.29 (nicht einschließlich)

Knotenbasiertes Abrechnungsmodell, unabhängig davon, ob Sie die Compute-Klasse „Accelerator“ in Ihren Pod-Manifesten angeben.

Sie können Funktionen wie GPUs mit mehreren Instanzen oder die Zeitfreigabe nur verwenden, wenn Sie die Knotenselektor-Variable cloud.google.com/compute-class: Accelerator explizit angeben.

Weitere Informationen finden Sie im Abschnitt „Pods mit bestimmten Hardwareanforderungen“ unter Kubernetes Engine-Preise.
Versionen vor 1.28.6-gke.1095000

Pod-basiertes Abrechnungsmodell. Die Abrechnung erfolgt nach GPU-Pod Ressourcenanfragen. Weitere Informationen finden Sie im Abschnitt „Pods mit bestimmten Hardwareanforderungen“ unter Kubernetes Engine-Preise.

Hinweise

Führen Sie die folgenden Schritte durch, 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 gcloud components update ab.

Beschränkungen

  • GPUs mit Dateifreigabe und GPUs mit mehreren Instanzen sind mit Autopilot in GKE Version 1.29.3-gke.1093000 und höher verfügbar.
  • Die GPU-Verfügbarkeit hängt von der Google Cloud-Region Ihres Autopilot-Clusters und Ihrem GPU-Kontingent ab. Informationen zum Ermitteln eines GPU-Modells nach Region oder Zone finden Sie unter Verfügbarkeit von GPU-Regionen und -Zonen.
  • Für NVIDIA A100-GPUs (80 GB) wird ein Festpreis für die lokalen SSDs berechnet, die an die Knoten angehängt sind, unabhängig davon, ob Ihre Pods diese Kapazität verwenden.
  • Wenn Sie bei GKE-Versionen vor 1.29.2-gke.1355000 explizit einen bestimmten vorhandenen GPU-Knoten für Ihren Pod anfordern, muss der Pod alle GPU-Ressourcen auf dem Knoten verbrauchen. Wenn der vorhandene Knoten beispielsweise 8 GPUs hat und die Container Ihres Pods insgesamt 4 GPUs anfordern, lehnt Autopilot den Pod ab.
  • Wenn Sie in der GKE-Version 1.29.2-gke.1355000 oder höher mehrere GPU-Pods in einen einzelnen Knoten einfügen möchten, muss die Summe der GPU-Anfragen für diese Pods kleiner oder gleich der Anzahl der GPU-Ressourcen sein, die diesem Knoten zugeordnet sind. Beispielsweise kann ein Knoten mit einem gke-accelerator-count von 4 bis zu vier Pods aufnehmen, die jeweils eine GPU anfordern.

Das Platzieren mehrerer Pods auf einem einzelnen GPU-Knoten ist in Situationen wie den folgenden nützlich:

  • Sie haben Kapazitätsreservierungen für große Accelerator-Maschinentypen und führen Arbeitslasten mit einer einzelnen GPU aus. Entsprechend würde die Bereitstellung eines Pods pro Knoten die anderen GPUs auf dieser Maschine verschwenden
  • Sie haben GPU-Arbeitslasten, die auf demselben Host ausgeführt werden müssen.

In diesen Situationen empfehlen wir, alle GPUs auf dem Knoten zu verwenden. Dazu muss die Summe der Pod-GPU-Ressourcenanfragen auf dem Knoten der Anzahl der GPUs entsprechen, die dem Knoten zugeordnet sind.

GPUs in Containern anfordern

Zum Anfordern von GPU-Ressourcen für Ihre Container fügen Sie der Pod-Spezifikation die folgenden Felder hinzu. Je nach Arbeitslastanforderungen können Sie den cloud.google.com/gke-accelerator-count-Selektor optional auslassen.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: GPU_QUANTITY

Ersetzen Sie Folgendes:

  • GPU_TYPE: der Typ der GPU-Hardware. Zulässige Werte sind:
    • nvidia-h100-80gb: NVIDIA H100 (80 GB) (nur mit Accelerator-Compute-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_COUNT: Gesamtzahl der GPUs, die dem Knoten hinzugefügt werden können Muss größer oder gleich GPU_QUANTITY und eine unterstützte GPU-Menge für den ausgewählten GPU-Typ sein. Wenn Sie diesen nodeSelector weglassen, platziert Autopilot einen Pod auf jedem GPU-Knoten.
  • GPU_QUANTITY: Die Anzahl der GPUs, die dem Container zugewiesen werden sollen. Muss kleiner oder gleich GPU_COUNT und eine unterstützte GPU-Menge für den ausgewählten GPU-Typ sein.

Weitere Informationen dazu, wie Ihnen die Nutzung des Accelerators im Autopilot-Modus in Rechnung gestellt wird, finden Sie im Abschnitt Preise.

Sie müssen sowohl den GPU-Typ als auch die GPU-Menge in Ihrer Pod-Spezifikation angeben. Wenn Sie einen dieser Werte weglassen, lehnt Autopilot Ihren Pod ab.

Wenn Sie dieses Manifest bereitstellen, installiert Autopilot automatisch die NVIDIA-Standardtreiber für die GKE-Version des Knotens. In Version 1.29.2-gke.1108000 und höher können Sie optional die neueste Treiberversion für diese GKE-Version installieren. Fügen Sie dazu Ihrem Manifest den folgenden Knotenselektor hinzu:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Ersetzen Sie DRIVER_VERSION durch einen der folgenden Werte:

  • default: der standardmäßige, stabile Treiber für die GKE-Version Ihres Knotens. Wenn Sie den nodeSelector in Ihrem Manifest weglassen, ist dies die Standardoption.
  • latest: die neueste verfügbare Treiberversion für die GKE-Version Ihres Knotens.

CPU- und Arbeitsspeicheranforderungen für Autopilot-GPU-Pods

Beim Definieren Ihrer GPU-Pods sollten Sie auch CPU- und Arbeitsspeicherressourcen anfordern, damit Ihre Container wie erwartet funktionieren. Autopilot erzwingt bestimmte Minimal-, Maximal- und Standardwerte für CPU- und Arbeitsspeicher basierend auf dem GPU-Typ und der GPU-Menge. Wenn Sie mehrere GPU-Pods auf einem einzelnen Knoten ausführen, geben Sie die CPU und den Arbeitsspeicher an. Andernfalls wird standardmäßig die gesamte Kapazität des Knotens verwendet. Weitere Informationen finden Sie unter Ressourcenanfragen in Autopilot.

Ihre Pod-Spezifikation sollte dem folgenden Beispiel ähnlich sein, in dem vier T4-GPUs angefordert werden:

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "nvidia-tesla-t4"
  containers:
  - name: t4-container-1
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 3
        cpu: "54"
        memory: "54Gi"
      requests:
        cpu: "54"
        memory: "54Gi"
  - name: t4-container-2
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1
        cpu: "18"
        memory: "18Gi"
      requests:
        cpu: "18"
        memory: "18Gi"

Dieses Manifest gibt limits für CPU- und Arbeitsspeicherressourcen an. Wenn Sie limits für CPU oder Arbeitsspeicher in GKE-Version 1.29.2-gke.1060000 und höher weglassen, weist GKE Ihren Pods die Dienstqualitätsklasse Burstable zu und lässt Bursts von Ihren Pods in nicht verwendete Ressourcen aus der Summe der Ressourcenanforderungen auf dem Knoten zu. Weitere Informationen finden Sie unter Pod-Bursting in GKE konfigurieren.

Sitzungsspezifische Speicheranfragen für Autopilot-GPU-Pods

Sie können auch sitzungsspezifischen Speicher in Pods anfordern, die einen kurzlebigen Speicher benötigen. Der maximal verfügbare sitzungsspezifische Speicher und die verwendete Speicherhardware hängen vom Typ und der Anzahl der GPUs ab, die der Pod anfordert. Sie können lokale SSDs für sitzungsspezifischen Speicher verwenden, wenn Sie NVIDIA L4-GPUs, die Accelerator-Compute-Klasse und die GKE-Patchversion 1.28.6-gke.1369000 und höher oder 1.29.1-gke.1575000 und höher ausführen.

Wenn Sie eine lokale SSD für sitzungsspezifischen Speicher verwenden möchten, fügen Sie Ihrem Arbeitslastmanifest den nodeSelector cloud.google.com/gke-ephemeral-storage-local-ssd: "true" hinzu. Das Beispielmanifest finden Sie unter Lokalen SSD-gestützten sitzungsspezifischen Speicher mit Autopilot-Clustern verwenden. Die NVIDIA H100-GPUs (80 GB) und NVIDIA A100-GPUs (80 GB) verwenden immer lokale SSDs für sitzungsspezifischen Speicher. Sie können diesen Knotenselektor nicht für diese GPUs angeben.

GPU-Zuordnung überprüfen

Führen Sie den folgenden Befehl aus, um zu prüfen, ob eine bereitgestellte GPU-Arbeitslast die angeforderten GPUs hat:

kubectl describe node NODE_NAME

Ersetzen Sie NODE_NAME durch den Namen des Knotens, auf dem der Pod geplant wurde.

Die Ausgabe sieht in etwa so aus:


apiVersion: v1
kind: Node
metadata:
...
  labels:
    ...
    cloud.google.com/gke-accelerator: nvidia-tesla-t4
    cloud.google.com/gke-accelerator-count: "1"
    cloud.google.com/machine-family: custom-48
    ...
...

GPU-Treiberversion prüfen

In Autopilot-Clustern installiert GKE NVIDIA-Gerätetreiber automatisch auf allen GPU-Knoten. Führen Sie den folgenden Befehl aus, um die Treiberversion zu ermitteln, die GKE in Ihrem Cluster installiert hat:

kubectl logs --selector=k8s-app=nvidia-gpu-device-plugin \
    --container="nvidia-gpu-device-plugin" \
    --tail=-1 \
    --namespace=kube-system | grep Driver

Die Ausgabe sieht in etwa so aus:

I1206 18:37:08.251742    5851 metrics.go:144] nvml initialized successfully. Driver version: 535.104.12

Funktionsweise der GPU-Zuweisung in Autopilot

Nachdem Sie einen GPU-Typ und eine Menge für die Container in einem Pod angefordert und den Pod bereitgestellt haben, geschieht Folgendes:

  1. Wenn kein zuweisbarer GPU-Knoten vorhanden ist, stellt Autopilot einen neuen GPU-Knoten bereit, um den Pod zu planen. Autopilot installiert automatisch NVIDIA-Treiber für die Hardware.
  2. Autopilot fügt dem GPU-Knoten Knotenmarkierungen und dem Pod die entsprechenden Toleranzen hinzu. Dadurch wird verhindert, dass GKE andere Pods auf dem GPU-Knoten plant.

Autopilot platziert genau einen GPU-Pod auf jedem GPU-Knoten sowie von GKE verwaltete Arbeitslasten, die auf allen Knoten ausgeführt werden, und alle DaemonSets, die Sie so konfiguriert haben, dass sie alle Knotenmarkierungen tolerieren.

DaemonSets auf jedem Knoten ausführen

Möglicherweise möchten Sie DaemonSets auf jedem Knoten ausführen, selbst auf Knoten mit angewendeten Markierungen. Beispielsweise müssen einige Logging- und Monitoring-Agents auf jedem Knoten im Cluster ausgeführt werden. Sie können diese DaemonSets so konfigurieren, dass Knotenmarkierungen ignoriert werden, sodass GKE diese Arbeitslasten auf jedem Knoten platziert.

Fügen Sie Ihrer Spezifikation die folgende Toleranz hinzu, um DaemonSets auf jedem Knoten in Ihrem Cluster auszuführen, einschließlich Ihrer GPU-Knoten:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Fügen Sie Ihrer Spezifikation Folgendes hinzu, um DaemonSets auf bestimmten GPU-Knoten in Ihrem Cluster auszuführen:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "GPU_TYPE"
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Ersetzen Sie GPU_TYPE durch den GPU-Typ in Ihren Zielknoten. folgende Arten von Werten sind möglich:

  • nvidia-h100-80gb: NVIDIA H100 (80 GB) (nur mit Accelerator-Compute-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-Anwendungsfälle in Autopilot

Sie können Containern in Autopilot-Pods GPUs zuweisen, um Arbeitslasten wie die folgenden zu ermöglichen:

  • Inferenz für maschinelles Lernen (ML)
  • ML-Training
  • Rendering

Unterstützte GPU-Mengen

Wenn Sie GPUs in Ihrer Pod-Spezifikation anfordern, müssen Sie die folgenden Mengen basierend auf dem GPU-Typ verwenden:

GPU-Mengen
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40 GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80 GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 (80 GB)
nvidia-h100-80gb		 8

Wenn Sie eine GPU-Menge anfordern, die für diesen Typ nicht unterstützt wird, lehnt Autopilot Ihren Pod ab.

Leistung der GPU-Knoten-Arbeitslast überwachen

Wenn für Ihren GKE-Cluster Systemmesswerte aktiviert sind, stehen in Cloud Monitoring die folgenden Messwerte zur Überwachung der GPU-Arbeitslastleistung zur Verfügung:

  • Arbeitszyklus (container/accelerator/duty_cycle): Prozentsatz der Zeit im vergangenen Beispielzeitraum (10 Sekunden), während dessen der Beschleuniger aktiv verarbeitet wurde. Liegt zwischen 1 und 100.
  • Arbeitsspeichernutzung (container/accelerator/memory_used): Menge des dem Beschleuniger zugeteilten Arbeitsspeichers in Byte.
  • Speicherkapazität (container/accelerator/memory_total): Gesamter Arbeitsspeicher des Beschleunigers in Byte.

Sie können vordefinierte Dashboards verwenden, um Ihre Cluster mit GPU-Knoten zu überwachen. Weitere Informationen finden Sie unter Beobachtbarkeitsmesswerte aufrufen. Allgemeine Informationen zum Monitoring Ihrer Cluster und der zugehörigen Ressourcen finden Sie unter Beobachtbarkeit für GKE.

Nutzungsmesswerte für Arbeitslasten ansehen

Sie können Ihre GPU-Nutzungsmesswerte für Arbeitslasten im Dashboard Arbeitslasten der Google Cloud Console aufrufen.

Gehen Sie zum Abrufen der GPU-Nutzung Ihrer Arbeitslast so vor:

  1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

    Zu Arbeitslasten
  2. Wählen Sie eine Arbeitslast aus.

Im Dashboard „Arbeitslasten” werden die Arbeitsspeichernutzung und -kapazität der GPUs sowie der GPU-Arbeitszyklus in Form von Diagrammen angezeigt.

NVIDIA Data Center GPU Manager-Messwerte (DCGM) ansehen

Sie können NVIDIA DCGM-Messwerte mit Google Cloud Managed Service for Prometheus erfassen und visualisieren. Bei Autopilot-Clustern installiert GKE die Treiber. Für Standardcluster müssen Sie die NVIDIA-Treiber installieren.

Eine Anleitung zum Bereitstellen des von GKE verwalteten DCGM-Pakets finden Sie unter NVIDIA Data Center GPU Manager-Messwerte (DCGM) erfassen und ansehen.

Nächste Schritte