GPU-Arbeitslasten in Autopilot bereitstellen

Auf dieser Seite erfahren Sie, wie Sie Hardwarebeschleuniger (GPUs) in Ihren Autopilot-Arbeitslasten von Google Kubernetes Engine (GKE) anfordern.

Autopilot bietet die spezielle Compute-Klasse Accelerator zum Ausführen von GPU-Pods. Mit dieser Compute-Klasse platziert GKE Pods auf GPU-Knoten und bietet den Pods Zugriff auf erweiterte Funktionen auf der virtuellen Maschine (VM). Sie können GPU-Pods optional auch ausführen, ohne die Compute-Klasse Accelerator auszuwählen. Weitere Informationen zu den Vorteilen der Compute-Klasse Accelerator finden Sie unter Wann werden bestimmte Compute-Klassen verwendet?.

Preise

Autopilot berechnet Ihnen unterschiedliche Gebühren, je nachdem, ob Sie die Compute-Klasse Accelerator zum Ausführen Ihrer GPU-Arbeitslasten angefordert haben.

Verwenden Sie die Compute-Klasse Accelerator? Preise Kompatibilität mit GKE-Funktionen
Ihnen werden die Compute Engine-Hardware, auf der Ihre GPU-Arbeitslasten ausgeführt werden, sowie ein Autopilot-Premium für die automatische Knotenverwaltung und Skalierbarkeit in Rechnung gestellt. Weitere Informationen finden Sie unter Preise für Autopilot-Modus.

Kompatibel mit Folgendem:
Die Abrechnung erfolgt auf Basis der GPU-Pod-Ressourcenanfragen. Weitere Informationen finden Sie im Abschnitt „GPU-Pods“ unter Kubernetes Engine-Preise.

Kompatibel mit Folgendem:

Hinweise

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 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 zu einem GPU-Modell 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 nur einer GPU aus. Wenn Sie also einen Pod pro Knoten bereitstellen, würden die anderen GPUs auf dieser Maschine verschwendet werden.
  • Sie haben GPU-Arbeitslasten, die auf demselben Host ausgeführt werden müssen

In diesen Fällen empfehlen wir, alle GPUs auf dem Knoten zu verwenden, indem Sie sicherstellen, dass die Summe der Pod-GPU-Ressourcenanfragen auf dem Knoten der Anzahl der mit dem Knoten verknüpften GPUs entspricht.

GPUs in Containern anfordern

Zum Anfordern von GPU-Ressourcen für Ihre Container fügen Sie der Pod-Spezifikation die folgenden Felder hinzu. Abhängig von Ihren Arbeitslastanforderungen können Sie die Felder cloud.google.com/compute-class: "Accelerator" und cloud.google.com/gke-accelerator-count optional weglassen.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    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-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_COUNT: die Gesamtzahl der GPUs, die an den Knoten angehängt 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.

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 standardmäßigen NVIDIA-Treiber für die GKE-Knotenversion. 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 Ihre GKE-Version des Knotens. Wenn Sie den nodeSelector in Ihrem Manifest weglassen, ist dies die Standardoption.
  • latest ist die neueste verfügbare Treiberversion für Ihre GKE-Knotenversion.

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/compute-class: "Accelerator"
    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 für CPU- und Arbeitsspeicherressourcen limits 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 Compute-Klasse Accelerator 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 für diese GPUs nicht 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 automatisch NVIDIA-Gerätetreiber 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 --label=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-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-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.

GPU-Knoten ü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 Überwachen 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.

Nächste Schritte