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. Mit Operatoren können Sie komplexe Aufgaben automatisieren, die über die Funktionen von Kubernetes 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 Verwendung der GKE-GPU-Verwaltung für Ihre GPU-Knoten, da GKE den Lebenszyklus der GPU-Knoten vollständig verwaltet. Wenn Sie GKE zur Verwaltung Ihrer GPU-Knoten verwenden möchten, haben Sie folgende Möglichkeiten:

Alternativ kann der NVIDIA GPU-Operator eine geeignete Option für Sie sein, wenn Sie eine einheitliche Oberfläche für mehrere Cloud-Anbieter suchen, den NVIDIA GPU-Operator bereits verwenden oder Software verwenden, die vom NVIDIA GPU-Operator abhängig ist.

Weitere Überlegungen zur 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 für Knoten-Images von Container-Optimized OS (COS) als auch für Ubuntu unterstützt, mit den folgenden Einschränkungen:

  • Der NVIDIA GPU-Operator wird in GKE ab der GPU-Operator-Version 24.6.0 oder höher unterstützt.
  • Der NVIDIA GPU-Operator wird für Autopilot-Cluster nicht unterstützt.
  • Der NVIDIA GPU-Operator wird für 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 diesen Task verwenden möchten, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
  • 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 Cloud Shell vorinstalliert.

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

    helm version

    Wenn die Ausgabe ähnlich wie Command helm not found aussieht, 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 gemäß der Anleitung unter GPU-Knotenpool erstellen mit den folgenden Änderungen:

    • Legen Sie gpu-driver-version=disabled fest, um die automatische GPU-Treiberinstallation 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 fügen Sie bei Bedarf weitere Flags für die Erstellung des 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.

    Der folgende Befehl erstellt beispielsweise einen GKE-Knotenpool a3nodepool mit H100-GPUs im zonalen Cluster a3-cluster. 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 mit dem folgenden Befehl ab:

    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 mit diesem Befehl ein Ressourcenkontingent im Namespace gpu-operator:

    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. 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 detaillierte Anleitung finden Sie unter NVIDIA-GPU-Treiber manuell installieren.

    • Wenn Sie COS verwenden, führen Sie die folgenden Befehle aus, um das Installations- DaemonSet 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 DaemonSet für die Installation, 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 GPU-Treiberinstallation erfolgreich ist, sieht die Ausgabe 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 unter NVIDIA GPU Operator installieren.

  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:

    • Achten Sie darauf, dass die GPU-Operator-Version 24.6.0 oder höher ist.
    • Konfigurieren Sie den Installationspfad für den Treiber im GPU-Operator mit hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.

    • Legen Sie den Installationspfad für das Toolkit toolkit.installDir=/home/kubernetes/bin/nvidia sowohl für COS als auch für Ubuntu fest. In COS ist das Verzeichnis /home beschreibbar und dient als zustandsorientierter Speicherort für die NVIDIA-Laufzeitbinärdateien. Weitere Informationen finden Sie unter COS Festplatten und Dateisystemübersicht.

    Version 25.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

    Version 25.3.4 oder früher

    • Aktivieren Sie die 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 GPU-Operator-Operanden 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 ordnungsgemäß 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