Questa pagina è stata tradotta dall'API Cloud Translation.

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

Questo documento mostra come attivare il supporto della GPU NVIDIA® per le macchine virtuali (VM) che vengono eseguite utilizzando VM Runtime su GDC. Scopri come installare i driver NVIDIA sui nodi Google Distributed Cloud, verificare che le GPU siano disponibili e assegnare le GPU alle VM.

Prima di iniziare

Per completare questo documento, devi avere accesso alle seguenti risorse:

Accesso a Google Distributed Cloud versione 1.12.0 (anthosBareMetalVersion: 1.12.0) o cluster successivi. Puoi utilizzare qualsiasi tipo di cluster in grado di eseguire carichi di lavoro. Se necessario, prova Google Distributed Cloud su Compute Engine o consulta la 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 successive supportano le seguenti GPU NVIDIA:

Tesla T4
Tesla P4
Tesla V100 SXM2 32 GB
A100 SXM4 da 40 GB
A100 PCIe da 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 per supportare i dispositivi GPU. Per installare i driver NVIDIA sui nodi, completa i seguenti passaggi su ogni nodo del cluster che include una GPU NVIDIA. Questo documento utilizza una versione di Ubuntu supportata per i nodi:

Connettiti al nodo Google Distributed Cloud che vuoi configurare per il supporto della GPU.
Ottieni la versione del kernel del tuo nodo:
```
KERNEL_VERSION="$(uname -r)"
```

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

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

Installa il pacchetto build-essential per poter compilare i driver Nvidia in un passaggio successivo:
```
sudo apt install -y build-essential
```
Scarica il pacchetto di driver NVIDIA appropriato per la tua GPU. Per un elenco completo dei driver, consulta Download dei driver NVIDIA.

L'esempio seguente scarica il driver Linux x86_64 versione 470.82.01:
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```
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
```
Carica il modulo kernel NVIDIA:
```
sudo modprobe nvidia
```
Ripeti i passaggi di questa sezione su ogni nodo del cluster con una GPU NVIDIA.

Attiva il supporto GPU in VM Runtime su GDC

Dopo aver installato i driver NVIDIA sui nodi Google Distributed Cloud, devi attivare il supporto GPU in VM Runtime su GDC. Le VM possono quindi accedere alle GPU sui nodi.

Ogni nodo viene riavviato nell'ambito della seguente procedura. Le tue VM potrebbero essere interessate da questa procedura di riavvio. Se possibile e configurate in questo modo, le VM di cui è possibile eseguire la migrazione vengono migrate ad altri nodi. Per saperne di più, scopri come configurare la policy di sfratto per le VM durante gli eventi di manutenzione.

Per attivare il supporto GPU in VM Runtime su GDC, completa i seguenti passaggi.

Modifica la risorsa personalizzata VMRuntime:
```
kubectl edit vmruntime vmruntime
```

Aggiungi la proprietà enableGPU: true al manifest VMRuntime:

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

Salva e chiudi la risorsa personalizzata VMRuntime nell'editor.

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

kubectl get pods --namespace vm-system  -w

L'attivazione dei controller richiede circa cinque minuti. Attendi che venga visualizzato STATUS Running per tutti i controller GPU. L'output di esempio seguente mostra lo stato desiderato:

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

Verifica che le GPU siano disponibili per l'uso quando tutti i controller GPU segnalano lo stato Running:
```
kubectl get gpuallocations --namespace vm-system
```
L'output di esempio seguente mostra che le GPU sui nodi sono disponibili per l'uso. Viene visualizzato ogni nodo del cluster con supporto GPU. Li assegnerai alle VM nella sezione successiva:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Allocare GPU per l'utilizzo con le VM

Con il supporto GPU configurato nei nodi del cluster bare metal e in VM Runtime su GDC, alloca le GPU da utilizzare con le VM. Per impostazione predefinita, le GPU vengono allocate per l'utilizzo con i pod (container).

Modifica la risorsa personalizzata GPUAllocation da utilizzare con le VM. Questo passaggio assegna le GPU sui 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.
Configura il numero di GPU da allocare alle VM. Inizialmente, tutte le GPU vengono 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. Il manifest GPUAllocation viene rifiutato se provi ad allocare due GPU alle VM e una GPU ai pod, in quanto una GPU rimane non allocata.

Aggiorna il numero di GPU sul nodo che vuoi allocare per l'utilizzo con le 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.
Salva e chiudi la risorsa personalizzata GPUAllocation nell'editor.

Verifica che le GPU segnalino lo stato ALLOCATED come 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

Crea una VM con supporto GPU

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

Recupera il nome della scheda GPU dall'host:

kubectl describe node NODE_NAME

Sostituisci NODE_NAME con il nome dell'host da cui vuoi recuperare il nome della 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
[...]

Crea un manifest VirtualMachine, ad esempio my-gpu-vm.yaml, nell'editor che preferisci:
```
nano my-gpu-vm.yaml
```
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 si connette eth0 alla rete pod-network predefinita.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per saperne di più, consulta la pagina Creare e gestire dischi virtuali.
Salva e chiudi il manifest della VM nell'editor.
Crea la VM utilizzando kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
Quando la VM è in esecuzione, connettiti alla VM e verifica che l'hardware GPU sia disponibile.

Passaggi successivi

Modifica una VM in Google Distributed Cloud.