Attivare e utilizzare le GPU NVIDIA nelle VM con il runtime VM su GDC

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questo documento illustra come attivare il supporto della GPU NVIDIA® per le macchine virtuali (VM) in esecuzione utilizzando il runtime VM su GDC. Scopri come installare i driver NVIDIA sui nodi Google Distributed Cloud, verificare la disponibilità delle GPU e assegnarle alle VM.

Prima di iniziare

Per completare questo documento, devi disporre dell'accesso alle seguenti risorse:

• Accesso al cluster Google Distributed Cloud versione 1.12.0 (anthosBareMetalVersion: 1.12.0) o successiva. Puoi utilizzare qualsiasi tipo di cluster in grado di eseguire carichi di lavoro. Se necessario, prova Google Distributed Cloud su Compute Engine o consulta le Panoramica della creazione del cluster.
• Lo strumento client virtctl installato come plug-in per kubectl. Se necessario, installa lo strumento client virtctl.

Schede GPU Nvidia supportate

Google Distributed Cloud versione 1.13 o successiva supporta le seguenti GPU NVIDIA:

• Tesla T4
• Tesla P4
• Tesla V100 SXM2 32 GB
• A100 SXM4 40 GB
• A100 PCIe 40 GB
• A100 SXM4 da 80 GB
• A100 PCIe da 80 GB

Installa i driver NVIDIA sui nodi

Prima che le VM possano utilizzare le GPU NVIDIA, devi configurare i nodi Google Distributed Cloud in modo che supportino i dispositivi GPU. Per installare NVIDIA sui nodi, completa i seguenti passaggi su ciascun nodo del tuo cluster che include una GPU NVIDIA. Questo documento utilizza una versione di Ubuntu supportata per i nodi:

1. Connettiti al nodo Google Distributed Cloud che vuoi configurare per la GPU assistenza in tempo reale.

2. Ottieni la versione del kernel del tuo nodo:

   KERNEL_VERSION="$(uname -r)"
   

3. Aggiorna il tuo nodo Ubuntu e installa le intestazioni del kernel appropriate:

   sudo apt update && \
   apt install -y linux-headers-${KERNEL_VERSION}
   

4. Installa il pacchetto build-essential per poter compilare il modulo Nvidia in un passaggio successivo:

   sudo apt install -y build-essential
   

5. Scarica il pacchetto driver NVIDIA appropriato per la tua GPU. Per un elenco completo dei driver, consulta Download dei driver NVIDIA.

   L'esempio seguente scarica il driver della versione 470.82.01 di Linux x86_64:

   wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
   

6. Installa il pacchetto del driver NVIDIA. Utilizza il nome del pacchetto del driver NVIDIA che hai scaricato nel passaggio precedente:

   sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
     --accept-license \
     --silent \
     --no-nouveau-check
   

7. Carica il modulo del kernel NVIDIA:

   sudo modprobe nvidia
   

8. Ripeti i passaggi di questa sezione su ogni nodo del cluster con una GPU NVIDIA.

Attiva il supporto delle GPU nel runtime VM su GDC

Dopo aver installato i driver NVIDIA sui nodi Google Distributed Cloud, attiva il supporto della GPU nel runtime VM su GDC. Le VM possono quindi accedere alle GPU sui nodi.

Ogni nodo si riavvia come parte del processo seguente. Le VM potrebbero essere interessate da questo processo di riavvio. Se possibile e configurate per farlo, le VM migrabili vengono migrate su altri nodi. Per ulteriori informazioni, scopri come configurare il criterio di rimozione per le VM durante gli eventi di manutenzione.

Per abilitare il supporto GPU nel runtime VM su GDC, completa i seguenti passaggi.

1. Modifica la risorsa personalizzata VMRuntime:

   kubectl edit vmruntime vmruntime
   

2. Aggiungi la proprietà enableGPU: true al file manifest VMRuntime:

   apiVersion: vm.cluster.gke.io/v1
   kind: VMRuntime
   metadata:
     name: vmruntime
   spec:
     enabled: true
     enableGPU: true
   ...
   

3. Salva e chiudi la risorsa personalizzata VMRuntime nell'editor.

4. Controlla lo stato dei controller GPU nello spazio dei nomi vm-system:

   kubectl get pods --namespace vm-system  -w
   

   L'abilitazione dei controller richiede circa cinque minuti. Attendi la visualizzazione di STATUS Running per tutti i controller GPU. L'esempio di output seguente mostra lo stato preferito:

   NAME                                          READY  STATUS    RESTARTS     AGE
   gpu-controller-controller-manager-gwvcb       2/2    Running   0            10m
   kubevirt-gpu-dp-daemonset-2lfkl               1/1    Running   0            10m
   kubevm-gpu-driver-daemonset-5fwh6             1/1    Running   0            10m
   nvidia-gpu-dp-daemonset-9zq2w                 1/1    Running   0            10m
   nvidia-mig-manager-5g7pz                      1/1    Running   0            10m
   vm-controller-controller-manager-7b6df6979b   2/2    Running   2 (13m ago)  14m
   

5. Verifica che le GPU siano disponibili per l'uso quando i controller GPU Segnala il proprio stato come Running:

   kubectl get gpuallocations --namespace vm-system
   

   L'esempio di output seguente mostra che le GPU sui nodi sono disponibili per l'utilizzo. Viene mostrato ogni nodo del cluster con il supporto della GPU. Devi assegnare alle VM nella prossima sezione:

   NAME       ALLOCATED   DEVICEMODEL
   bm-node1   true        Tesla A100 SXM4 40GB
   bm-node2   true        Tesla A100 SXM4 40GB
   

Alloca le GPU per l'utilizzo con le VM

Con il supporto GPU configurato nei Anthos clusters on bare metal e nelle Durante il runtime VM su GDC, alloca le GPU da utilizzare con le VM. Per impostazione predefinita, Le GPU vengono allocate per l'utilizzo con i pod (container).

1. Modifica la risorsa personalizzata GPUAllocation da utilizzare con le VM. Questo passaggio assegna le GPU ai nodi per l'utilizzo con le VM:

   kubectl edit gpuallocation NODE_NAME --namespace vm-system
   

   Sostituisci NODE_NAME con il nome del nodo da cui vuoi allocare le GPU.

2. Configura il numero di GPU da allocare alle VM. Inizialmente, tutte le GPU sono allocate ai pod.

   Il numero totale di GPU allocate a VM e pod deve essere uguale al numero di GPU nel nodo. Ad esempio, potresti avere quattro GPU nel nodo. Se allochi due GPU alle VM, due GPU rimangono allocate ai pod. La Il manifest GPUAllocation viene rifiutato se provi ad allocare due GPU alle VM e una GPU ai pod, poiché una GPU non viene allocata.

   Aggiorna il numero di GPU sul nodo che vuoi allocare per l'utilizzo con VM, come mostrato nell'esempio seguente:

   apiVersion: gpu.cluster.gke.io/v1
   kind: GPUAllocation
   metadata:
     name: gpu-w2
     namespace: vm-system
   spec:
     node: gpu-w2
     pod: 0
     vm: 4
   

   In questo esempio, tutte e quattro le GPU installate nel nodo vengono allocate alle VM. Nessuna GPU viene allocata ai pod.

3. Salva e chiudi la risorsa personalizzata GPUAllocation nell'editor.

4. Verifica che lo stato ALLOCATED delle GPU sia true:

   kubectl get gpuallocations --namespace vm-system
   

   L'output di esempio seguente mostra che le GPU sui nodi sono disponibili per l'uso:

   NAME     ALLOCATED   DEVICEMODEL
   gpu-w1   true        Tesla A100 SXM4 40GB
   gpu-w2   true        Tesla A100 SXM4 40GB
   

Creare una VM con il supporto GPU

Ora puoi creare una VM che utilizza la GPU del nodo. Nella VM personalizzata devi specificare il nome e la quantità di GPU da allocare dal nodo.

1. Ottieni il nome della scheda GPU dall'host:

   kubectl describe node NODE_NAME
   

   Sostituisci NODE_NAME con il nome dell'host desiderato da cui recuperare il nome GPU.

   L'output di esempio seguente mostra che il nome della GPU allocabile su questo nodo è NVIDIA_A100_SXM4_40GB:

   Name:               bm-node1
   Roles:              worker
   [...]
   Allocatable:
     cpu:                                         47810m
     [...]
     memory:                                      336929400Ki
     nvidia.com/gpu-vm-NVIDIA_A100_SXM4_40GB:     1
   [...]
   

2. Crea un manifest VirtualMachine, ad esempio my-gpu-vm.yaml, nell'editor di tua scelta:

   nano my-gpu-vm.yaml
   

3. Copia e incolla il seguente manifest YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
         gpu:
           model: nvidia.com/gpu-vm-GPU_NAME
           quantity: 1
   

   In questo file YAML, definisci le seguenti impostazioni:

   • VM_NAME: il nome della VM.
   • GPU_NAME: il nome della GPU dal nodo da allocare alla VM.
     • Questo nome della GPU viene mostrato nell'output del comando kubectl describe node di un passaggio precedente, ad esempio NVIDIA_A100_SXM4_40GB.

   La VM connette eth0 alla rete pod-network predefinita.

   Il disco di avvio denominato VM_NAME-boot-dv debe già esistere. Per ulteriori informazioni, vedi Creare e gestire dischi virtuali.

4. Salva e chiudi il file manifest della VM nell'editor.

5. Crea la VM utilizzando kubectl:

   kubectl apply -f my-gpu-vm.yaml
   

6. Quando la VM è in esecuzione, connettiti alla VM e verifica che l'hardware della GPU sia disponibile.

Passaggi successivi

• Modifica una VM in Google Distributed Cloud.