Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Gestisci lo stack GPU con l'operatore GPU NVIDIA su Google Kubernetes Engine (GKE)

Standard

Questa pagina ti aiuta a decidere quando utilizzare l'operatore GPU NVIDIA e ti mostra come abilitarlo su GKE.

Panoramica

Gli operatori sono estensioni software di Kubernetes che consentono agli utenti di creare risorse personalizzate che gestiscono le applicazioni e i relativi componenti. Puoi utilizzare gli operatori per automatizzare attività complesse oltre a quelle fornite da Kubernetes, come il deployment e l'upgrade delle applicazioni.

L'operatore GPU NVIDIA è un operatore Kubernetes che fornisce un'infrastruttura e un'API comuni per il deployment, la configurazione e la gestione dei componenti software necessari per il provisioning delle GPU NVIDIA in un cluster Kubernetes. L'operatore GPU NVIDIA offre un'esperienza coerente, semplifica la gestione delle risorse GPU e ottimizza l'integrazione dei carichi di lavoro con accelerazione GPU in Kubernetes.

Perché utilizzare l'operatore GPU NVIDIA?

Ti consigliamo di utilizzare la gestione delle GPU GKE per i nodi GPU, perché GKE gestisce completamente il ciclo di vita dei nodi GPU. Per iniziare a utilizzare GKE per gestire i nodi GPU, scegli una di queste opzioni:

In alternativa, l'operatore GPU NVIDIA potrebbe essere un'opzione adatta se cerchi un'esperienza coerente tra più fornitori di servizi cloud, se utilizzi già l'operatore GPU NVIDIA o se utilizzi software che dipende dall'operatore GPU NVIDIA.

Per ulteriori considerazioni sulla scelta tra queste opzioni, consulta Gestire lo stack GPU tramite GKE o l'operatore GPU NVIDIA su GKE.

Limitazioni

L'operatore GPU NVIDIA è supportato sia sulle immagini dei nodi Container-Optimized OS (COS) sia su Ubuntu con le seguenti limitazioni:

L'operatore GPU NVIDIA è supportato su GKE a partire da versione 24.6.0 dell'operatore GPU o successiva.
L'operatore GPU NVIDIA non è supportato sui cluster Autopilot.
L'operatore GPU NVIDIA non è supportato sulle immagini dei nodi Windows.
L'operatore GPU NVIDIA non è gestito da GKE. Per eseguire l'upgrade dell'operatore GPU NVIDIA, consulta la documentazione NVIDIA.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI assicurati di impostare la compute/region proprietà. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Assicurati di soddisfare i requisiti indicati in Esegui le GPU nei node pool Standard.
Verifica di aver installato Helm nel tuo ambiente di sviluppo. Helm è preinstallato in Cloud Shell.

Sebbene non esista un requisito specifico per la versione di Helm, puoi utilizzare il seguente comando per verificare di aver installato Helm.
```
helm version
```
Se l'output è simile a Command helm not found, puoi installare l'interfaccia a riga di comando Helm eseguendo questo comando:
```
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
```

Crea e configura il pool di nodi GPU

Per creare e configurare il pool di nodi GPU, segui questi passaggi:

Crea un pool di nodi GPU seguendo le istruzioni riportate in Crea un node pool GPU con le seguenti modifiche:
- Imposta gpu-driver-version=disabled per saltare l'installazione automatica dei driver GPU, poiché non è supportata quando utilizzi l'operatore GPU NVIDIA.
- Imposta --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" per disabilitare il DaemonSet del plug-in del dispositivo GPU gestito da GKE.
Esegui il seguente comando e aggiungi altri flag per la creazione pool di nodi GPU, se necessario:
```
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"
```
Sostituisci quanto segue:
- POOL_NAME il nome scelto per il pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU che vuoi utilizzare. Ad esempio, nvidia-h100-80gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi.
Ad esempio, il seguente comando crea un pool di nodi GKE, a3nodepool, con GPU H100 nel cluster zonale a3-cluster. In questo esempio, il DaemonSet del plug-in del dispositivo GPU GKE e l'installazione automatica dei driver sono disabilitati.
```
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
```
Recupera le credenziali di autenticazione per il cluster eseguendo il comando seguente:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del cluster contenente il pool di nodi.
- CONTROL_PLANE_LOCATION: la località di Compute Engine del piano di controllo del cluster. Fornisci una regione per i cluster regionali o una zona per i cluster zonali.
L'output è simile al seguente:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
(Facoltativo) Verifica di poter connetterti al cluster.
```
kubectl get nodes -o wide
```
Dovresti vedere un elenco di tutti i nodi in esecuzione in questo cluster.
Crea lo spazio dei nomi gpu-operator per l'operatore GPU NVIDIA eseguendo questo comando:
```
kubectl create ns gpu-operator
```
L'output è simile al seguente:
```
namespace/gpu-operator created
```

Crea una quota di risorse nello spazio dei nomi gpu-operator eseguendo questo comando:

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

L'output è simile al seguente:

resourcequota/gpu-operator-quota created

Visualizza la quota di risorse per lo spazio dei nomi gpu-operator:

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

L'output è simile al seguente:

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

Installa manualmente i driver sui nodi Container-Optimized OS o Ubuntu. Per istruzioni dettagliate, consulta Installare manualmente i driver GPU NVIDIA.
- DaemonSet
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Se utilizzi Ubuntu, il DaemonSet di installazione di cui esegui il deployment dipende dal tipo di GPU e dalla versione del nodo GKE, come descritto nella sezione Ubuntu delle istruzioni.

Verifica la versione del driver GPU eseguendo questo comando:

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

Se l'installazione del driver GPU è andata a buon fine, l'output è simile al seguente:

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.

Installa l'operatore GPU NVIDIA

Questa sezione mostra come installare l'operatore GPU NVIDIA utilizzando Helm. Per saperne di più, consulta la documentazione di NVIDIA sull' installazione dell'operatore GPU NVIDIA.

Aggiungi il repository Helm NVIDIA:

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

Installa l'operatore GPU NVIDIA utilizzando Helm con le seguenti opzioni di configurazione:
- Assicurati che la versione dell'operatore GPU sia 24.6.0 o successive.
- Configura il percorso di installazione del driver nell'operatore GPU con hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Imposta il percorso di installazione del toolkit toolkit.installDir=/home/kubernetes/bin/nvidia sia per COS sia per Ubuntu. In COS, la directory /home è scrivibile e funge da località con stato per l'archiviazione dei file binari di runtime NVIDIA. Per saperne di più, consulta la panoramica dei dischi e del file system COS.
v25.10.0 o versioni successive
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 o versioni precedenti
- Abilita Container Device Interface (CDI) nell'operatore GPU con cdi.enabled=true e cdi.default=true, poiché la modalità legacy non è supportata. CDI è obbligatorio sia per COS sia per Ubuntu su GKE.
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"'
Per saperne di più su queste impostazioni, consulta le opzioni di personalizzazione dei grafici comuni e gli scenari di deployment comuni nella documentazione NVIDIA.

Verifica che l'operatore GPU NVIDIA sia stato installato correttamente.

Per verificare che gli operandi dell'operatore GPU siano in esecuzione correttamente, esegui il comando seguente.

kubectl get pods -n gpu-operator

L'output è simile al seguente:

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

Per verificare che il conteggio delle GPU sia configurato correttamente nel campo "Allocatable" del nodo, esegui il comando seguente:

kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

Sostituisci GPU_NODE_NAME con il nome del nodo con le GPU.

L'output è simile al seguente:

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

Per verificare che il carico di lavoro GPU venga eseguito correttamente, puoi utilizzare lo strumento cuda-vectoradd:

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

Quindi, esegui il comando seguente:

kubectl logs cuda-vectoradd

L'output è simile al seguente:

[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

Gestisci lo stack GPU con l'operatore GPU NVIDIA su Google Kubernetes Engine (GKE) Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Perché utilizzare l'operatore GPU NVIDIA?

Limitazioni

Prima di iniziare

Crea e configura il pool di nodi GPU

Installa l'operatore GPU NVIDIA

v25.10.0 o versioni successive

v25.3.4 o versioni precedenti

Passaggi successivi

Gestisci lo stack GPU con l'operatore GPU NVIDIA su Google Kubernetes Engine (GKE)