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

Standard

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, um Anwendungen und ihre Komponenten zu verwalten. Mithilfe von Operatoren können Sie komplexe Aufgaben automatisieren, die über das Angebot von Kubernetes hinausgehen, z. B. das Bereitstellen und Upgraden 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 konsistente Umgebung, vereinfacht die Verwaltung von GPU-Ressourcen und optimiert die Einbindung von GPU-beschleunigten Arbeitslasten in Kubernetes.

Vorteile des NVIDIA GPU-Operators

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

Alternativ ist der NVIDIA GPU Operator möglicherweise eine geeignete Option für Sie, wenn Sie eine konsistente Umgebung für mehrere Cloud-Dienstanbieter wünschen, den NVIDIA GPU-Operator bereits verwenden oder wenn Sie {101 }Software, die vom NVIDIA-GPU-Operator abhängt.

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

Beschränkungen

Der NVIDIA GPU-Operator wird sowohl auf COS- als auch auf Ubuntu-Knoten-Images unterstützt. Dabei gelten die folgenden Einschränkungen:

Der NVIDIA GPU Operator wird in GKE ab Version 24.6.0 unterstützt.
Der NVIDIA GPU Operator wird in 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.

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.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

Prüfen Sie, ob Sie die Anforderungen unter GPUs in Standardknotenpools ausführen erfüllen.
Prüfen Sie, ob Helm in Ihrer Entwicklungsumgebung installiert ist. Helm ist in Cloud Shell vorinstalliert.

Obwohl es keine bestimmte Helm-Versionsanforderung gibt, können Sie mit dem folgenden Befehl prüfen, ob Helm installiert ist.
```
helm version
```
Wenn die Ausgabe Command helm not found ähnelt, können Sie die Helm-Befehlszeile installieren, indem Sie den folgenden Befehl ausführen:
```
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:

Erstellen Sie einen GPU-Knotenpool. Folgen Sie dazu der Anleitung unter GPU-Knotenpool erstellen, wobei Sie die folgenden Änderungen vornehmen:
- Legen Sie gpu-driver-version=disabled fest, um die automatische Installation des GPU-Treibers 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 Daemonset des verwalteten GKE-GPU-Geräte-Plug-ins zu deaktivieren.
Führen Sie den folgenden Befehl aus und fügen Sie nach Bedarf weitere Flags für die Erstellung des GPU-Knotenpools hinzu:
```
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 der GKE-GPU-Geräte-Plug-in-Daemonset und die automatische Treiberinstallation deaktiviert.
```
gcloud container node-pools create a3nodepool \
  --region=us-central1 --cluster=a3-cluster \
  --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
```
Rufen Sie die Anmeldedaten zur Authentifizierung für den Cluster mit dem folgenden Befehl ab:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME [--zone COMPUTE_ZONE] [--region COMPUTE_REGION]
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: der Name des Clusters, der Ihren Knotenpool enthält.
- COMPUTE_REGION oder COMPUTE_ZONE: Geben Sie die Region oder Zone des Clusters an, je nachdem, ob Ihr Cluster ein regionaler oder zonaler Cluster ist.
Die Ausgabe sieht in etwa so aus:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
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.
Erstellen Sie mit dem folgenden Befehl den Namespace gpu-operator für den NVIDIA-GPU-Operator:
```
kubectl create ns gpu-operator
```
Die Ausgabe sieht in etwa so aus:
```
namespace/gpu-operator created
```

Erstellen Sie ein 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

Rufen Sie das Ressourcenkontingent für den Namespace gpu-operator auf:

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

Die Ausgabe sieht in etwa so aus:

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

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 bereitgestellte DaemonSet für die Installation vom GPU-Typ und von der GKE-Knotenversion ab, wie im Abschnitt "Ubuntu" der Anleitung beschrieben.

Prüfen Sie die GPU-Treiberversion mit folgendem 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 war, 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 unter NVIDIA-GPU-Operator installieren.

Fügen Sie das NVIDIA Helm-Repository hinzu:

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

Installieren Sie den NVIDIA-GPU-Operator mit Helm mit den folgenden Konfigurationsoptionen:
- Die GPU Operator-Version muss 24.6.0 oder höher sein.
- Konfigurieren Sie den Installationspfad 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 zustandsabhängiger Speicherort für die NVIDIA-Laufzeit-Binärdateien. Weitere Informationen finden Sie in der COS-Übersicht über Laufwerke und Dateisysteme.
- 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 v24.6.0 \
  -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
```
Weitere Informationen zu diesen Einstellungen finden Sie in der NVIDIA-Dokumentation unter Allgemeine Optionen zur Diagrammanpassung und Allgemeine Bereitstellungsszenarien.

Prüfen Sie, ob der NVIDIA-GPU-Operator installiert ist.

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

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die GPU-Anzahl im Feld „Allocatable“ des Knotens korrekt 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

Mit dem cuda-vectoradd-Tool 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

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

Übersicht

Vorteile des NVIDIA GPU-Operators

Beschränkungen

Hinweise

GPU-Knotenpool erstellen und einrichten

NVIDIA GPU-Operator installieren

Nächste Schritte