GPU-Stack mit dem NVIDIA GPU-Operator in Google Kubernetes Engine (GKE) verwalten

Auf dieser Seite erfahren Sie, wann Sie den NVIDIA GPU-Operator verwenden sollten, und wie Sie ihn in GKE aktivieren.

Übersicht

Operatoren sind Kubernetes-Softwareerweiterungen, mit denen Nutzer benutzerdefinierte Ressourcen erstellen können, die Anwendungen und ihre Komponenten verwalten. Sie können Operatoren verwenden, um komplexe Aufgaben zu automatisieren, die über die von Kubernetes selbst bereitgestellten Funktionen hinausgehen, z. B. das Bereitstellen und Aktualisieren von Anwendungen.

Der NVIDIA GPU-Operator ist ein Kubernetes-Operator, der eine gemeinsame Infrastruktur und API zum Bereitstellen, Konfigurieren und Verwalten von Softwarekomponenten bereitstellt, die für die Bereitstellung von NVIDIA-GPUs in einem Kubernetes-Cluster erforderlich sind. Der NVIDIA GPU-Operator bietet eine einheitliche Oberfläche, vereinfacht die GPU-Ressourcenverwaltung und optimiert die Einbindung von GPU-beschleunigten Arbeitslasten in Kubernetes.

Warum den NVIDIA GPU-Operator verwenden?

Wir empfehlen, die GKE-GPU-Verwaltung für Ihre GPU-Knoten zu verwenden, da GKE den Lebenszyklus der GPU-Knoten vollständig verwaltet. Wählen Sie eine der folgenden Optionen aus, um mit der Verwaltung Ihrer GPU-Knoten mit GKE zu beginnen:

Alternativ kann der NVIDIA GPU-Operator eine geeignete Option für Sie sein, wenn Sie eine konsistente Umgebung bei mehreren Cloud-Anbietern benötigen, den NVIDIA GPU-Operator bereits verwenden oder Software nutzen, die vom NVIDIA GPU-Operator abhängt.

Weitere Überlegungen bei der Entscheidung zwischen diesen Optionen finden Sie unter GPU-Stack über GKE oder den NVIDIA GPU-Operator in GKE verwalten.

Beschränkungen

Der NVIDIA GPU-Operator wird sowohl auf Container-Optimized OS- (COS) als auch auf Ubuntu-Knoten-Images mit den folgenden Einschränkungen unterstützt:

  • Der NVIDIA GPU-Operator wird in GKE ab GPU-Operatorversion 24.6.0 oder höher unterstützt.
  • Der NVIDIA GPU-Operator wird auf Autopilot-Clustern nicht unterstützt.
  • Der NVIDIA GPU-Operator wird auf Windows-Knoten-Images nicht unterstützt.
  • Der NVIDIA GPU-Operator wird nicht von GKE verwaltet. Informationen zum Upgrade des NVIDIA GPU-Betriebssystems finden Sie in der NVIDIA-Dokumentation.

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.
  • Achten Sie darauf, dass die Anforderungen unter GPUs in Standardknotenpools ausführen erfüllt sind.

  • Prüfen Sie, ob Helm in Ihrer Entwicklungsumgebung installiert ist. Helm ist in der Cloud Shell vorinstalliert.

    Es gibt keine spezifische Helm-Versionsanforderung. Sie können jedoch mit dem folgenden Befehl prüfen, ob Helm installiert ist.

    helm version

    Wenn die Ausgabe ähnlich wie Command helm not found ist, können Sie die Helm-CLI mit diesem Befehl installieren:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh

GPU-Knotenpool erstellen und einrichten

So erstellen und richten Sie den GPU-Knotenpool ein:

  1. Erstellen Sie einen GPU-Knotenpool. Folgen Sie dazu der Anleitung unter GPU-Knotenpool erstellen mit den folgenden Änderungen:

    • Legen Sie gpu-driver-version=disabled fest, um die automatische Installation von GPU-Treibern zu überspringen, da sie bei Verwendung des NVIDIA GPU-Operators nicht unterstützt wird.
    • Legen Sie --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" fest, um das von GKE verwaltete GPU-Geräte-Plug-in-DaemonSet zu deaktivieren.

    Führen Sie den folgenden Befehl aus und hängen Sie bei Bedarf weitere Flags für die Erstellung von GPU-Knotenpools an:

    gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=disabled \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true"

    Ersetzen Sie Folgendes:

    • POOL_NAME: Der Name, den Sie für den Knotenpool auswählen.
    • GPU_TYPE:Der Typ des GPU-Beschleunigers , den Sie verwenden möchten. Beispiel: nvidia-h100-80gb
    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen.

    Mit dem folgenden Befehl wird beispielsweise ein GKE-Knotenpool (a3nodepool) mit H100-GPUs im zonalen Cluster a3-cluster erstellt. In diesem Beispiel sind das GKE-GPU-Geräte-Plug-in-DaemonSet und die automatische Treiberinstallation deaktiviert.

    gcloud container node-pools create a3nodepool \
  --cluster=a3-cluster \
  --location=us-central1 \
  --node-locations=us-central1-a \
  --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=disabled \
  --machine-type=a3-highgpu-8g \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" \
  --num-nodes=1

  2. Rufen Sie die Authentifizierungsdaten für den Cluster ab, indem Sie den folgenden Befehl ausführen:

    USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name des Clusters, der Ihren Knotenpool enthält.
    • CONTROL_PLANE_LOCATION: Der Compute Engine-Standort der Steuerungsebene Ihres Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an.

    Die Ausgabe sieht etwa so aus:

    Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.

  3. (Optional) Prüfen Sie, ob Sie eine Verbindung zum Cluster herstellen können.

    kubectl get nodes -o wide

    Sie sollten eine Liste aller Knoten sehen, die in diesem Cluster ausgeführt werden.

  4. Erstellen Sie den Namespace gpu-operator für den NVIDIA GPU-Operator mit diesem Befehl:

    kubectl create ns gpu-operator

    Die Ausgabe sieht in etwa so aus:

    namespace/gpu-operator created

  5. Erstellen Sie das Ressourcenkontingent im Namespace gpu-operator mit dem folgenden Befehl:

    kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

    Die Ausgabe sieht in etwa so aus:

    resourcequota/gpu-operator-quota created

  6. So rufen Sie das Ressourcenkontingent für den Namespace gpu-operator auf:

    kubectl get -n gpu-operator resourcequota gpu-operator-quota

    Die Ausgabe sieht in etwa so aus:

    NAME                 AGE     REQUEST       LIMIT
gpu-operator-quota   2m27s   pods: 0/100

  7. Installieren Sie die Treiber manuell auf Ihren Container-Optimized OS- oder Ubuntu-Knoten. Eine ausführliche Anleitung finden Sie unter NVIDIA-GPU-Treiber manuell installieren.

    • Wenn Sie COS verwenden, führen Sie die folgenden Befehle aus, um das DaemonSet für die Installation bereitzustellen und die Standardversion des GPU-Treibers zu installieren:

      kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

    • Wenn Sie Ubuntu verwenden, hängt das Installations-DaemonSet, das Sie bereitstellen, vom GPU-Typ und von der GKE-Knotenversion ab, wie im Ubuntu-Abschnitt der Anleitung beschrieben.

  8. Prüfen Sie die GPU-Treiberversion mit diesem Befehl:

    kubectl logs -l k8s-app=nvidia-driver-installer  \
  -c "nvidia-driver-installer" --tail=-1 -n kube-system

    Wenn die Installation des GPU-Treibers erfolgreich ist, sieht die Ausgabe in etwa so aus:

    I0716 03:17:38.863927    6293 cache.go:66] DRIVER_VERSION=535.183.01
…
I0716 03:17:38.863955    6293 installer.go:58] Verifying GPU driver installation
I0716 03:17:41.534387    6293 install.go:543] Finished installing the drivers.

NVIDIA-GPU-Operator installieren

In diesem Abschnitt wird beschrieben, wie Sie den NVIDIA GPU-Operator mit Helm installieren. Weitere Informationen finden Sie in der NVIDIA-Dokumentation zur Installation des NVIDIA-GPU-Operators.

  1. Fügen Sie das NVIDIA-Helm-Repository hinzu:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

  2. Installieren Sie den NVIDIA GPU-Operator mit Helm und den folgenden Konfigurationsoptionen:

    • Die GPU Operator-Version muss 24.6.0 oder höher sein.
    • Konfigurieren Sie den Treiberinstallationspfad im GPU Operator mit hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.

    • Legen Sie den Installationspfad des Toolkits toolkit.installDir=/home/kubernetes/bin/nvidia für COS und Ubuntu fest. In COS ist das Verzeichnis/home beschreibbar und dient als statusbehafteter Speicherort für die NVIDIA-Laufzeitbinärdateien. Weitere Informationen finden Sie in der Übersicht über Laufwerke und Dateisysteme für COS.

    v25.10.0 oder höher

    helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
  --set toolkit.installDir=/home/kubernetes/bin/nvidia \
  --set driver.enabled=false

    v25.3.4 oder älter

    • Aktivieren Sie das Container Device Interface (CDI) im GPU-Operator mit cdi.enabled=true und cdi.default=true, da der Legacy-Modus nicht unterstützt wird. CDI ist sowohl für COS als auch für Ubuntu in GKE erforderlich.
    helm install --wait --generate-name \
  --version=v25.3.4 \
  -n gpu-operator \
  nvidia/gpu-operator \
  --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
  --set toolkit.installDir=/home/kubernetes/bin/nvidia \
  --set cdi.enabled=true \
  --set cdi.default=true \
  --set driver.enabled=false \
  --set operator.runtimeClass=containerd \
  --set 'toolkit.env[0].name=CONTAINERD_CONFIG' \
  --set 'toolkit.env[0].value=/etc/containerd/config.toml' \
  --set 'toolkit.env[1].name=CONTAINERD_SOCKET' \
  --set 'toolkit.env[1].value=/run/containerd/containerd.sock' \
  --set 'toolkit.env[2].name=RUNTIME_CONFIG_SOURCE' \
  --set 'toolkit.env[2].value="command\, file"'

    Weitere Informationen zu diesen Einstellungen finden Sie in der NVIDIA-Dokumentation unter Common Chart Customization Options und Common Deployment Scenarios.

  3. Prüfen Sie, ob der NVIDIA-GPU-Operator erfolgreich installiert wurde.

    1. Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Operanden des GPU-Operators ordnungsgemäß ausgeführt werden.

      kubectl get pods -n gpu-operator

      Die Ausgabe sieht dann ungefähr so aus:

      NAME                                                          READY    STATUS
RESTARTS   AGE
gpu-operator-5c7cf8b4f6-bx4rg                                 1/1      Running   0          11m
gpu-operator-node-feature-discovery-gc-79d6d968bb-g7gv9       1/1      Running   0          11m
gpu-operator-node-feature-discovery-master-6d9f8d497c-thhlz   1/1      Running   0          11m
gpu-operator-node-feature-discovery-worker-wn79l              1/1      Running   0          11m
gpu-feature-discovery-fs9gw                                   1/1      Running   0          8m14s
gpu-operator-node-feature-discovery-worker-bdqnv              1/1      Running   0          9m5s
nvidia-container-toolkit-daemonset-vr8fv                      1/1      Running   0          8m15s
nvidia-cuda-validator-4nljj                                   0/1      Completed 0          2m24s
nvidia-dcgm-exporter-4mjvh                                    1/1      Running   0          8m15s
nvidia-device-plugin-daemonset-jfbcj                          1/1      Running   0          8m15s
nvidia-mig-manager-kzncr                                      1/1      Running   0          2m5s
nvidia-operator-validator-fcrr6                               1/1      Running   0          8m15s

    2. Führen Sie den folgenden Befehl aus, um zu prüfen, ob die GPU-Anzahl im Feld „Allocatable“ des Knotens richtig konfiguriert ist:

      kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

      Ersetzen Sie GPU_NODE_NAME durch den Namen des Knotens mit GPUs.

      Die Ausgabe sieht in etwa so aus:

      Allocatable:
cpu:                11900m
ephemeral-storage:  47060071478
hugepages-1Gi:      0
hugepages-2Mi:      0
memory:             80403000Ki
nvidia.com/gpu:     1           # showing correct count of GPU associated with the nods
pods:               110

    3. Mit dem Tool cuda-vectoradd können Sie prüfen, ob die GPU-Arbeitslast korrekt ausgeführt wird:

      cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
  name: cuda-vectoradd
spec:
  restartPolicy: OnFailure
  containers:
  - name: vectoradd
    image: nvidia/samples:vectoradd-cuda11.2.1
    resources:
      limits:
        nvidia.com/gpu: 1
EOF

      Führen Sie dann den folgenden Befehl aus:

      kubectl logs cuda-vectoradd

      Die Ausgabe sieht in etwa so aus:

      [Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done

Nächste Schritte