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

Questa pagina ti aiuta a decidere quando utilizzare l'operatore GPU NVIDIA e 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 che vanno oltre ciò che fornisce 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 GPU di 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 delle seguenti opzioni:

In alternativa, l'operatore GPU NVIDIA potrebbe essere un'opzione adatta se cerchi un'esperienza coerente su 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 quando scegli tra queste opzioni, consulta Gestire lo stack GPU tramite GKE o NVIDIA GPU Operator su GKE.

Limitazioni

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

  • L'operatore GPU NVIDIA è supportato su GKE a partire dalla versione 24.6.0 dell'operatore GPU o successive.
  • 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 operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva 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 gcloud components update.
  • Assicurati di soddisfare i requisiti indicati in Esegui GPU nei node pool Standard.

  • Verifica di aver installato Helm nell'ambiente di sviluppo. Helm è preinstallato su Cloud Shell.

    Sebbene non esista un requisito specifico per la versione di Helm, puoi utilizzare il seguente comando per verificare che Helm sia installato.

    helm version

    Se l'output è simile a Command helm not found, puoi installare Helm CLI 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:

  1. Crea un pool di nodi GPU seguendo le istruzioni su come creare un node pool GPU con le seguenti modifiche:

    • Imposta gpu-driver-version=disabled per ignorare l'installazione automatica del driver GPU, poiché non è supportata quando utilizzi l'operatore GPU NVIDIA.
    • Imposta --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" su per disattivare il DaemonSet del plug-in del dispositivo GPU gestito da GKE.

    Esegui il seguente comando e aggiungi altri flag per la creazione del pool di nodi GPU in base alle esigenze:

    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 che hai 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

  2. 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 posizione di Compute Engine del control plane del tuo 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.

  3. (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.

  4. 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

  5. Crea una quota 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

  6. Visualizza la quota delle 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

  7. Installa manualmente i driver sui nodi Container-Optimized OS o Ubuntu. Per istruzioni dettagliate, consulta Installare manualmente i driver GPU NVIDIA.

    • Se utilizzi COS, esegui i seguenti comandi per eseguire il deployment di DaemonSet di installazione e installare la versione predefinita del driver GPU:

      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 che esegui il deployment dipende dal tipo di GPU e dalla versione del nodo GKE, come descritto nella sezione Ubuntu delle istruzioni.

  8. 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 è riuscita, 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.

  1. Aggiungi il repository Helm di NVIDIA:

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

  2. Installa l'operatore GPU NVIDIA utilizzando Helm con le seguenti opzioni di configurazione:

    • Assicurati che la versione di GPU Operator sia 24.6.0 o successiva.
    • Configura il percorso di installazione del driver in GPU Operator con hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
    • Imposta il percorso di installazione del toolkit toolkit.installDir=/home/kubernetes/bin/nvidia sia per COS che per Ubuntu. In COS, la directory/home è scrivibile e funge da posizione stateful per l'archiviazione dei file binari di runtime NVIDIA. Per saperne di più, consulta la panoramica su dischi e file system di COS.
    • Attiva Container Device Interface (CDI) in GPU Operator con cdi.enabled=true e cdi.default=true poiché la modalità legacy non è supportata. CDI è richiesto sia per COS che per Ubuntu su GKE.
    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

    Per scoprire di più su queste impostazioni, consulta le sezioni Opzioni comuni di personalizzazione dei grafici e Scenari di implementazione comuni nella documentazione di NVIDIA.

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

    1. Per verificare che gli operandi di GPU Operator siano in esecuzione correttamente, esegui questo comando.

      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

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

      kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

      Sostituisci GPU_NODE_NAME con il nome del nodo con 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

    3. Per verificare che il carico di lavoro della 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 questo comando:

      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

Passaggi successivi