Diese Seite wurde von der Cloud Translation API übersetzt.

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 den NVIDIA GPU-Operator 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 Verwendung der GKE-GPU-Verwaltung für Ihre GPU-Knoten, 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-Dienstanbietern benötigen, den NVIDIA GPU-Operator bereits verwenden oder Software verwenden, 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 für Container-Optimized OS- als auch für Ubuntu-Knoten-Images unterstützt. Es gelten jedoch die folgenden Einschränkungen:

Der NVIDIA GPU-Operator wird in GKE ab GPU-Operatorversion 24.6.0 oder höher 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 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.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Achten Sie darauf, dass Sie die Anforderungen unter GPUs in Standardknotenpools ausführen erfüllen.
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 in etwa so aussieht: Command helm not found, 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:

Erstellen Sie einen GPU-Knotenpool. Folgen Sie dazu der Anleitung unter GPU-Knotenpool erstellen und nehmen Sie die folgenden Änderungen vor:
- 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 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.
Mit dem folgenden Befehl wird beispielsweise der 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
```
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.
```
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 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
```

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

Ressourcenkontingent für den Namespace gpu-operator ansehen:

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

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.

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.

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 und den folgenden Konfigurationsoptionen:
- Achten Sie darauf, dass die GPU Operator-Version 24.6.0 oder höher ist.
- Konfigurieren Sie den Installationspfad des Treibers 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 von COS.
- 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 \
  -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 Common Chart Customization Options (Häufige Optionen zum Anpassen von Diagrammen) und Common Deployment Scenarios (Häufige Bereitstellungsszenarien).

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

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

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

Mit dem Tool cuda-vectoradd können Sie prüfen, ob eine 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

GPU-Stack mit dem NVIDIA GPU-Operator in Google Kubernetes Engine (GKE) verwalten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Warum den NVIDIA GPU-Operator verwenden?

Beschränkungen

Hinweise

GPU-Knotenpool erstellen und einrichten

NVIDIA GPU-Operator installieren

Nächste Schritte

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