GPU-Arbeitslasten in Autopilot bereitstellen

Auf dieser Seite erfahren Sie, wie Sie GPUs anfordern, um Aufgaben in Ihren Autopilot-Arbeitslasten von Google Kubernetes Engine (GKE) zu beschleunigen. Auf dieser Seite wird auch beschrieben, wie GPUs in Autopilot ausgeführt werden, wie sich Ihr Abrechnungsmodell je nach GKE-Version ändert, wie Sie Ressourcenanfragen und ‑limits für Pods festlegen und wie Sie GPU-Arbeitslasten überwachen.

Diese Seite richtet sich an Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die GPUs für Arbeitslasten anfordern möchten, bei denen Aufgaben wie das Training oder die Inferenz von maschinellem Lernen (ML) ausgeführt werden. Weitere Informationen zu den gängigen Rollen, Verantwortlichkeiten und Beispielaufgaben, auf die wir in Google Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und ‑Aufgaben.

Machen Sie sich mit den folgenden Konzepten vertraut, bevor Sie fortfahren:

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 von Beschleunigern 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.

Beachten Sie die folgenden Preisüberlegungen für Autopilot-GPUs:

  • Alle A100-GPU-Knoten (80 GB) verwenden lokale SSDs für Knoten-Bootlaufwerke mit festen Größen, die auf der Anzahl der GPUs basieren. Die angehängten lokalen SSDs werden separat in Rechnung gestellt. Diese Preise gelten nicht für A100-GPUs (40 GB).

  • Die Preise für GKE Sandbox sind dieselben wie die Standardpreise für Autopilot. Weitere Informationen zum Sandboxing von Beschleuniger-Arbeitslasten finden Sie unter GKE Sandbox und Erste Schritte mit GKE Sandbox.

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 diesen Task 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.

  • Prüfen Sie, ob Sie einen GKE Autopilot-Cluster haben, auf dem eine der folgenden Versionen ausgeführt wird, um die folgenden GPUs oder Funktionen zu verwenden:

    • NVIDIA B200-GPUs (180 GB): 1.32.2-gke.1422000 oder höher
    • NVIDIA H200-GPUs (141 GB): 1.31.4-gke.1183000 oder höher
    • NVIDIA H100 Mega-GPUs (80 GB): 1.28.9-gke.1250000 oder höher und 1.29.4-gke.1542000 oder höher
    • NVIDIA H100-GPUs (80 GB): 1.28.6-gke.1369000 oder höher und 1.29.1-gke.1575000 oder höher
    • Mehrere GPU-Pods pro VM: 1.29.2-gke.1355000 oder höher
    • Andere GPUs: alle unterstützten Versionen

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 dazu, wie Sie ein GPU-Modell nach Region oder Zone finden, 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 in 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 nutzen. 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. Auf einem Knoten mit einem gke-accelerator-count von 4 können beispielsweise bis zu vier Pods untergebracht werden, die jeweils eine GPU anfordern.

Das Platzieren mehrerer Pods auf einem einzelnen GPU-Knoten ist in den folgenden Situationen sinnvoll:

  • 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:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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-gb200: NVIDIA GB200 (Vorschau)
    • nvidia-b200: NVIDIA B200 (180 GB)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
    • nvidia-h100-80gb: NVIDIA H100 (80 GB)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (80 GB)
    • nvidia-l4; NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
    oder wenn Sie GKE Sandbox verwenden, eine der folgenden Optionen:
    • nvidia-gb200: NVIDIA GB200 (Vorschau)
    • nvidia-b200: NVIDIA B200 (180 GB) (Vorschau)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB) (Vorschau)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
    • nvidia-h100-80gb: NVIDIA H100 (80 GB)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (80 GB)
    • nvidia-l4; NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
    Weitere Informationen finden Sie unter Unterstützung von GPU-Modellen.

  • 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.

  • Optional runtimeClassname: gvisor: Mit dieser Einstellung können Sie diesen Pod in GKE Sandbox ausführen. Entfernen Sie die Kommentarzeichen für diese Zeile, um sie zu verwenden. Weitere Informationen finden Sie unter GKE Sandbox.

Weitere Informationen dazu, wie Ihnen die Nutzung des Accelerator 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 standardmäßigen NVIDIA-Treiber 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, indem Sie Ihrem Manifest den folgenden Knotenselektor hinzufügen:

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 Arbeitsspeicher für Autopilot-GPU-Pods anfordern

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:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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"
  • Optional runtimeClassname: gvisor: Mit dieser Einstellung können Sie diesen Pod in GKE Sandbox ausführen. Entfernen Sie die Kommentarzeichen für diese Zeile, um sie zu verwenden. Weitere Informationen finden Sie unter GKE Sandbox.

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.

Sitzungsspezifischen Speicher für Autopilot-GPU-Pods anfordern

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.

Bestimmte Maschinentypen mit benutzerdefinierten ComputeClasses anfordern

In einigen Fällen müssen Sie Ihre GPU-Arbeitslast auf einem bestimmten Maschinentyp ausführen, z. B. wenn der gewünschte Maschinentyp kein Standardmaschinentyp für Autopilot-Cluster ist. Sie können explizit einen bestimmten Computer anfordern, indem Sie benutzerdefinierte Compute-Klassen verwenden. Damit können Sie ein Knotenkonfigurationsprofil definieren, in dem der Maschinentyp und die GPU angegeben werden.

Allgemeine Informationen zu ComputeClasses finden Sie unter Benutzerdefinierte ComputeClasses.

Führen Sie die folgenden Schritte aus, um einen bestimmten Maschinentyp für Ihre GPU-Arbeitslast anzufordern:

  1. Erstellen Sie ein Manifest für eine benutzerdefinierte ComputeClass. Speichern Sie das Folgende als a3-computeclass.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edge-gpu
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
     count: 8
     type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true

    In diesem Manifest:

    • metadata.name ist der Name Ihrer benutzerdefinierten ComputeClass, auf die Sie in Ihrer Pod-Spezifikation verweisen.
    • machineType ist die spezifische Maschine, die bereitgestellt werden soll.
    • In den Feldern gpu werden der Typ und die Anzahl der GPUs angegeben, die an diese Maschine angehängt sind. Die Werte dieser Felder müssen den Funktionen des angegebenen machineType entsprechen.

  2. Wenden Sie das Manifest mit dem folgenden Befehl an:

    kubectl apply -f a3-computeclass.yaml

  3. Fordern Sie die ComputeClass in Ihrem Pod-Manifest mit dem Knotenselektor cloud.google.com/compute-class an:

    apiVersion: v1
kind: Pod
metadata:
  name: gpu-cc-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: a3-edge-gpu
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:latest
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1

    GKE stellt einen neuen Knoten bereit, der der Definition in der a3-edge-gpu-ComputeClass entspricht, um Ihren Pod auszuführen.

Zuordnung bereitgestellter GPUs prü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 in Ihrem Cluster installiert GKE:

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. So 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

Ersetzen Sie IMAGE_PATH durch den Pfad zum Container-Image.

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. Dies kann einer der folgenden Werte sein:

  • nvidia-gb200: NVIDIA GB200 (Vorschau)
  • nvidia-b200: NVIDIA B200 (180 GB)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
  • nvidia-h100-80gb: NVIDIA H100 (80 GB)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (80 GB)
  • nvidia-l4; NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4
oder wenn Sie GKE Sandbox verwenden, eine der folgenden:

  • nvidia-gb200: NVIDIA GB200 (Vorschau)
  • nvidia-b200: NVIDIA B200 (180 GB) (Vorschau)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB) (Vorschau)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
  • nvidia-h100-80gb: NVIDIA H100 (80 GB)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (80 GB)
  • nvidia-l4; NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4
Weitere Informationen finden Sie unter Unterstützung von GPU-Modellen.

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		 1, 2, 4, 8
NVIDIA H100 Mega (80 GB)
nvidia-h100-mega-80gb		 8
NVIDIA H200 (141 GB)
nvidia-h200-141gb		 8
NVIDIA B200 (180 GB)
nvidia-b200		 8

Leistung von GPU-Knoten-Arbeitslasten ü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.

Diese Messwerte gelten auf Containerebene (container/accelerator) und werden nicht für Container erfasst, die auf einer GPU geplant sind, die GPU-Zeitfreigabe oder NVIDIA MPS verwendet.

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 -Konsole 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. Bei Standardclustern 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