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 ti mostra come attivarlo su GKE.

Panoramica

Gli operatori sono estensioni software di Kubernetes che consentono agli utenti di creare risorse personalizzate per gestire le applicazioni e i relativi componenti. Puoi utilizzare gli operatori per eseguire automaticamente attività complesse oltre a quelle fornite da Kubernetes stesso, ad esempio 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 snellisce 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 tuoi nodi GPU, perché GKE gestisce completamente il ciclo di vita dei nodi GPU. Per iniziare a utilizzare GKE per gestire i tuoi nodi GPU, scegli una delle seguenti opzioni:

In alternativa, l'operatore GPU NVIDIA potrebbe essere un'opzione adatta per te se stai cercando 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 al momento di scegliere tra queste opzioni, consulta Gestire lo stack GPU tramite GKE o l'operatore GPU NVIDIA su GKE.

Limitazioni

NVIDIA GPU Operator è supportato sia su Container-Optimized OS (COS) sia su 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 nei cluster Autopilot.
  • L'operatore GPU NVIDIA non è supportato nelle immagini dei nodi Windows.
  • L'operatore GPU NVIDIA non è gestito da GKE. Per eseguire l'upgrade di 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à, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  • Assicurati di soddisfare i requisiti descritti in Eseguire GPU in pool di nodi standard.

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

    Sebbene non sia previsto alcun 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 di 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:

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

    • Imposta gpu-driver-version=disabled per saltare 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" per disattivare il daemonset del plug-in del dispositivo GPU gestito da GKE.

    Esegui il comando seguente e aggiungi altri flag per la creazione del pool di nodi GPU come 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 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 del 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 del driver sono disattivati.

    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

  2. Recupera le credenziali di autenticazione per il cluster eseguendo il seguente comando:

    USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME [--zone COMPUTE_ZONE] [--region COMPUTE_REGION]

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del cluster contenente il pool di nodi.
    • COMPUTE_REGION o COMPUTE_ZONE: specifica la regione o la zona del cluster in base al fatto che si tratti di un cluster regionale o zonale.

    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 la 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

  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 Ubuntu o Container-Optimized OS. Per istruzioni dettagliate, consulta Installare manualmente i driver GPU NVIDIA.

    • Se utilizzi COS, esegui i seguenti comandi per eseguire il deployment del DaemonSet di installazione e installare la versione predefinita del driver della 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 di cui 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 di NVIDIA GPU Operator.

  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 Operatore GPU sia 24.6.0 o successiva.
    • Configura il percorso di installazione del driver in Operatore GPU con hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
    • Imposta il percorso di installazione del toolkittoolkit.installDir=/home/kubernetes/bin/nvidia sia per COS che per Ubuntu. In COS, la directory/home è scrivibile e funge da posizione con stato per l'archiviazione dei binari di runtime NVIDIA. Per saperne di più, consulta la Panoramica su dischi e filesystem di COS.
    • Attiva l'interfaccia CDI (Container Device Interface) in GPU Operator con cdi.enabled=true e cdi.default=true perché la modalità precedente non è supportata. CDI è obbligatorio 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 opzioni di personalizzazione dei grafici comuni e gli scenari di implementazione comuni nella documentazione di NVIDIA.

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

    1. Per verificare che gli operatori GPU funzionino correttamente, esegui il seguente 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 numero di GPU sia configurato correttamente nel campo "Allocatable" del nodo, esegui il seguente comando:

      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

    3. Per verificare che il carico di lavoro della GPU funzioni 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

Passaggi successivi