GPU-Arbeitslasten in Autopilot bereitstellen

Sie können GPUs anfordern, um Aufgaben in Ihren Autopilot-Arbeitslasten von Google Kubernetes Engine (GKE) zu beschleunigen. In diesem Dokument wird beschrieben, wie Sie GPUs in Autopilot ausführen, Pod-Ressourcenanfragen und -limits festlegen und GPU-Arbeitslasten überwachen.

Dieses Dokument richtet sich an Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die GPUs für Arbeitslasten anfordern möchten, bei denen Aufgaben wie ML-Training (maschinelles Lernen) oder ‑Inferenz 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 vor dem Fortfahren mit den folgenden Konzepten vertraut:

Sie fordern GPUs mithilfe von ComputeClasses oder Knotenauswahlen in Ihrer Pod-Spezifikation an. GKE platziert diese Pods auf Knoten, die diese GPUs haben. Sie können auch GPU-Freigabefunktionen wie die Zeitfreigabe verwenden.

Preise

Das knotenbasierte Abrechnungsmodell von Autopilot gilt für GPU-Pods. Sowohl der Autopilot-Verwaltungsaufschlag für die Knoten als auch die tatsächliche GPU-Hardware in Compute Engine sind für flexible Rabatte für zugesicherte Nutzung (CUDs) berechtigt.

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.
  • Wenn Sie die NVIDIA RTX PRO 6000-GPUs (G4-Maschinenserie) im Autopilot-Modus verwenden, stellt die GKE ab dem 1. Oktober 2026 zusätzlich zu den bestehenden anwendbaren Gebühren für die zugrunde liegende Hardware die Autopilot-Knotenverwaltungsgebühr in Rechnung. Diese bestehenden Gebühren fallen sowohl vor als auch nach diesem Datum an. Weitere Informationen zur Abrechnung beim Anfordern bestimmter Hardware mit Autopilot-Arbeitslasten finden Sie unter Autopilot-Arbeitslasten, die bestimmte Hardware auswählen.

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, 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 Features zu verwenden:

    • NVIDIA B200-GPUs (180 GB): 1.32.2-gke.1422000 oder höher
    • NVIDIA RTX PRO 6000-GPUs:
      • Maschinentypen mit einer oder mehreren GPUs: 1.34.1-gke.1829001 oder höher
      • Maschinentypen mit weniger als einer GPU: 1.35.2-gke.1485000 oder höher

    Alle anderen GPU-Typen werden in allen verfügbaren GKE-Versionen unterstützt.

Beschränkungen

  • 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 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 folgenden Situationen 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:
  # 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-rtx-pro-6000: NVIDIA RTX PRO 6000
    • 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) (Vorabversion)
    • 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-rtx-pro-6000: NVIDIA RTX PRO 6000 (Vorschau) (außer bei G4-Maschinentypen mit weniger als einer GPU)
    • 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: Die Einstellung, mit der Sie diesen Pod in GKE Sandbox ausführen können. Entfernen Sie die Kommentarzeichen in dieser Zeile, um sie zu verwenden. Weitere Informationen finden Sie unter GKE Sandbox.

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. Optional können Sie die neueste Treiberversion für diese GKE-Version installieren, indem Sie Ihrem Manifest die folgende Knotenauswahl 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: Die Einstellung, mit der Sie diesen Pod in GKE Sandbox ausführen können. Entfernen Sie die Kommentarzeichen in dieser Zeile, um sie zu verwenden. Weitere Informationen finden Sie unter GKE Sandbox.

In diesem Manifest wird limits für CPU- und Arbeitsspeicherressourcen angegeben. Wenn Sie limits für CPU oder Arbeitsspeicher 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 Ressourcenanfragen 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 mit den folgenden Konfigurationen verwenden:

  • Verwenden Sie NVIDIA RTX PRO 6000-GPUs und führen Sie eine GKE-Patchversion aus, die die im Abschnitt Vorbereitung aufgeführten Versionsanforderungen erfüllt. Die Konfiguration mit einem Achtel der GPU unterstützt keinen flüchtigen Speicher.
  • NVIDIA L4-GPUs verwenden

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 diese Knotenauswahl 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 eine bestimmte Maschine explizit anfordern, indem Sie benutzerdefinierte Compute-Klassen verwenden. Damit können Sie ein Knotenkonfigurationsprofil definieren, in dem der Maschinentyp und die GPU angegeben werden. Wenn Sie die G4-Maschinentypen mit weniger als einer GPU verwenden möchten, müssen Sie der Anleitung im nächsten Abschnitt folgen, um einen Maschinentyp explizit anzufordern.

Allgemeine Informationen zu Compute-Klassen finden Sie unter Benutzerdefinierte Compute-Klassen.

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

  1. Manifest für eine benutzerdefinierte ComputeClass erstellen Speichern Sie für dieses Beispiel Folgendes 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.
    • Die Felder gpu geben den Typ und die Anzahl der GPUs an, 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 Compute-Klasse in Ihrem Pod-Manifest mit der Knotenauswahl 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.

G4-Maschinentypen mit weniger als einer GPU anfordern

Die G4-Maschinentypen verwenden die NVIDIA RTX PRO 6000-GPU. Wenn Sie G4-Maschinentypen mit weniger als einer GPU anfordern möchten, müssen Sie der Anleitung im vorherigen Abschnitt folgen und die folgenden Felder festlegen:

  • machineType auf einen der folgenden Werte:

    • g4-standard-6 (ein Achtel einer GPU)
    • g4-standard-12 (ein Viertel einer GPU)
    • g4-standard-24 (eine halbe GPU)

  • gpu.count: 1

  • gpu.type: nvidia-rtx-pro-6000

Zuordnung der bereitgestellten 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 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

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-rtx-pro-6000: NVIDIA RTX PRO 6000
  • 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) (Vorabversion)
  • 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-rtx-pro-6000: NVIDIA RTX PRO 6000 (Vorschau) (außer bei G4-Maschinentypen mit weniger als einer GPU)
  • 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. Wenn Sie eine GPU-Menge anfordern, die für diesen Typ nicht unterstützt wird, lehnt Autopilot Ihren Pod ab.

GPU-Mengen
NVIDIA B200 (180 GB)
nvidia-b200		 8
NVIDIA H200 (141 GB)
nvidia-h200-141gb		 8
NVIDIA H100 Mega (80 GB)
nvidia-h100-mega-80gb		 8
NVIDIA H100 (80 GB)
nvidia-h100-80gb		 1, 2, 4, 8
NVIDIA A100 (80 GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA A100 (40 GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA RTX PRO 6000
nvidia-rtx-pro-6000		 1/8, 1/4, 1/2, 1, 2, 4, 8
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4

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 Stichprobenzeitraum (10 Sekunden), in der der Beschleuniger aktiv Daten verarbeitet hat. 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 -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. Bei Standardclustern müssen Sie die NVIDIA-Treiber installieren.

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

JobSet- und Knotenstatusmesswerte für GPU-Arbeitslasten

Zusätzlich zu DCGM-Messwerten können Sie die folgenden Messwerte verwenden, um den Zustand und die Leistung Ihrer GPU-Arbeitslasten zu überwachen, insbesondere wenn Sie sie als JobSets ausführen.

JobSet-Messwerte

Die folgenden Messwerte gelten sowohl für GPU- als auch für TPU-JobSets mit einem einzelnen replizierten Job:

  • kubernetes.io/jobset/times_between_interruptions
  • kubernetes.io/jobset/times_to_recover
  • kubernetes.io/jobset/uptime

Weitere Informationen zu diesen Systemmesswerten finden Sie unter Kubernetes-Messwerte.

Sie können auch das JobSet-Dashboard in der Google Cloud Console verwenden, um Ihre GPU-Arbeitslasten zu visualisieren und zu überwachen:

Zu Deployments

Messwerte zum Knotenzustand

Die folgenden Messwerte auf Knotenebene gelten für alle Knoten, einschließlich der Knoten mit GPUs:

  • kubernetes.io/node/status_condition: Für diesen Messwert ist die GKE-Version 1.32.1-gke.1357001 oder höher erforderlich.

Messwerte für Knotenunterbrechungen und Knotenpoolunterbrechungen gelten auch für Nicht-TPU-Knoten.

Kube-State-Metrics für JobSets

Die kube-state-metrics für JobSets können mit GPUs verwendet werden. Für die Erfassung dieser Messwerte ist GKE-Version 1.32.1-gke.1357001 oder höher erforderlich. Weitere Informationen finden Sie in der Dokumentation zu JobSet-Messwerten.

Nächste Schritte