Activer et utiliser des GPU NVIDIA sur des VM avec l'environnement d'exécution des VM sur GDC

Ce document explique comment activer la compatibilité des GPU NVIDIA® pour les machines virtuelles (VM) exécutées à l'aide de l'environnement d'exécution VM sur GDC. Vous apprendrez à installer les pilotes NVIDIA sur vos nœuds GKE sur bare metal, à vérifier que les GPU sont disponibles et à attribuer des GPU aux VM.

Avant de commencer

Pour suivre les instructions de ce document, vous devez disposer des ressources suivantes :

Accès à GKE sur un cluster Bare Metal version 1.12.0 (anthosBareMetalVersion: 1.12.0) ou ultérieure. Vous pouvez utiliser n'importe quel type de cluster capable d'exécuter des charges de travail. Si nécessaire, essayez GDCV pour Bare Metal sur Compute Engine ou consultez la présentation de la création de clusters.
L'outil client virtctl, installé en tant que plug-in de kubectl. Si nécessaire, installez l'outil client virtctl.

Cartes de GPU Nvidia compatibles

GKE sur Bare Metal version 1.13 ou ultérieure est compatible avec les GPU NVIDIA suivants:

Tesla T4
Tesla P4
Tesla V100 SXM2 32 Go
A100 SXM4 40 Go
A100 PCIe 40 Go
A100 SXM4 80 Go
A100 PCIe 80 Go

Installer des pilotes NVIDIA sur des nœuds

Avant que vos VM puissent utiliser les GPU NVIDIA, vous devez configurer vos nœuds GKE sur Bare Metal pour qu'ils soient compatibles avec les appareils GPU. Pour installer les pilotes NVIDIA sur vos nœuds, procédez comme suit sur chaque nœud de votre cluster comprenant un GPU NVIDIA. Ce document utilise une version d'Ubuntu compatible pour les nœuds :

Connectez-vous au nœud GKE sur Bare Metal que vous souhaitez configurer pour la compatibilité GPU.
Obtenez la version de noyau de votre nœud :
```
KERNEL_VERSION="$(uname -r)"
```
Mettez à jour votre nœud Ubuntu et installez les en-têtes de noyau appropriés :
```
sudo apt update && \
apt install -y linux-headers-${KERNEL_VERSION}
```
Installez le package build-essential pour pouvoir compiler les pilotes Nvidia dans une étape suivante :
```
sudo apt install -y build-essential
```
Téléchargez le package de pilotes NVIDIA approprié pour votre GPU. Pour obtenir la liste complète des pilotes, consultez la page Téléchargements des pilotes NVIDIA.

L'exemple suivant télécharge la version 470.82.01 du pilote Linux x86_64 :
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```
Installez le package de pilotes NVIDIA. Utilisez le nom du package de pilotes NVIDIA que vous avez téléchargé à l'étape précédente :
```
sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
  --accept-license \
  --silent \
  --no-nouveau-check
```
Chargez le module de noyau NVIDIA :
```
sudo modprobe nvidia
```
Répétez les étapes de cette section sur chaque nœud de votre cluster disposant d'un GPU NVIDIA.

Activer la prise en charge des GPU dans l'environnement d'exécution des VM sur GDC

Après avoir installé les pilotes NVIDIA sur vos nœuds GKE sur bare metal, vous activez la compatibilité avec les GPU dans l'environnement d'exécution des VM sur GDC. Vos VM peuvent ensuite accéder aux GPU sur les nœuds.

Chaque nœud redémarre dans le cadre du processus suivant. Vos VM peuvent être affectées par ce processus de redémarrage. Si possible et si leur configuration le permet, les VM pouvant être migrées sont migrées vers d'autres nœuds. Pour en savoir plus, découvrez comment configurer la règle d'éviction des VM lors des événements de maintenance.

Pour activer la compatibilité GPU dans l'environnement d'exécution des VM sur GDC, procédez comme suit.

Modifiez la ressource personnalisée VMRuntime :
```
kubectl edit vmruntime vmruntime
```

Ajoutez la propriété enableGPU: true au fichier manifeste VMRuntime :

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

Enregistrez et fermez la ressource personnalisée VMRuntime dans votre éditeur.

Vérifiez l'état des contrôleurs de GPU dans l'espace de noms vm-system :

kubectl get pods --namespace vm-system  -w

L'activation des contrôleurs prend environ cinq minutes. Attendez que l'état (STATUS) affiche Running pour tous les contrôleurs de GPU. L'exemple de sortie suivante affiche l'état souhaité :

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

Vérifiez que les GPU sont disponibles lorsque les contrôleurs de GPU indiquent tous leur état comme Running :
```
kubectl get gpuallocations --namespace vm-system
```
L'exemple de sortie suivante montre que les GPU des nœuds peuvent être utilisés. Chaque nœud de votre cluster compatible avec les GPU s'affiche. Dans la section suivante, vous allez les allouer à des VM :
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Allouer des GPU à utiliser avec les VM

Une fois la compatibilité GPU configurée dans les clusters Anthos sur nœuds bare metal et dans l'environnement d'exécution des VM sur GDC, allouez les GPU à utiliser avec des VM. Par défaut, les GPU sont alloués pour être utilisés avec les pods (conteneurs).

Modifiez la ressource personnalisée GPUAllocation à utiliser avec les VM. Cette étape attribue les GPU sur les nœuds à utiliser avec les VM :
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
Remplacez NODE_NAME par le nom du nœud à partir duquel vous souhaitez allouer des GPU.
Configurez le nombre de GPU à allouer aux VM. Initialement, tous les GPU sont alloués aux pods.

Le nombre total de GPU alloués aux VM et aux pods doit être égal au nombre de GPU dans le nœud. Par exemple, votre nœud peut comporter quatre GPU. Si vous allouez deux GPU aux VM, deux GPU restent alloués aux pods. Le fichier manifeste GPUAllocation est rejeté si vous essayez d'allouer deux GPU aux VM et un GPU aux pods, car un GPU n'est pas alloué.

Mettez à jour le nombre de GPU sur le nœud que vous souhaitez allouer pour l'utilisation avec des VM, comme indiqué dans l'exemple suivant :
```
apiVersion: gpu.cluster.gke.io/v1
kind: GPUAllocation
metadata:
  name: gpu-w2
  namespace: vm-system
spec:
  node: gpu-w2
  pod: 0
  vm: 4
```
Dans cet exemple, les quatre GPU installés dans le nœud sont alloués aux VM. Aucun GPU n'est alloué aux pods.
Enregistrez et fermez la ressource personnalisée GPUAllocation dans votre éditeur.

Vérifiez que les GPU signalent leur état ALLOCATED comme true :

kubectl get gpuallocations --namespace vm-system

L'exemple de sortie suivante montre que les GPU des nœuds peuvent être utilisés :

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

Créer une VM compatible avec les GPU

Vous pouvez maintenant créer une VM qui utilise le GPU du nœud. Dans la ressource personnalisée de VM, vous spécifiez le nom et la quantité de GPU du nœud à allouer.

Obtenez le nom de la carte GPU à partir de l'hôte :

kubectl describe node NODE_NAME

Remplacez NODE_NAME par le nom de l'hôte à partir duquel vous souhaitez obtenir le nom du GPU.

L'exemple de sortie suivante montre que le nom du GPU pouvant être alloué sur ce nœud est NVIDIA_A100_SXM4_40GB :

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

Créez un fichier manifeste VirtualMachine, tel que my-gpu-vm.yaml, dans l'éditeur de votre choix :
```
nano my-gpu-vm.yaml
```
Copiez et collez le fichier manifeste YAML suivant :
```
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
```
Dans ce fichier YAML, définissez les paramètres suivants :
- VM_NAME : nom de votre VM.
- GPU_NAME : nom du GPU du nœud à allouer à la VM.
  - Ce nom de GPU est affiché dans la sortie de la commande kubectl describe node d'une étape précédente, tel que NVIDIA_A100_SXM4_40GB.
La VM connecte eth0 au réseau pod-network par défaut.

Le disque de démarrage nommé VM_NAME-boot-dv doit déjà exister. Pour plus d'informations, consultez la page Créer et gérer des disques virtuels.
Enregistrez et fermez le fichier manifeste de VM dans votre éditeur.
Créez la VM en utilisant kubectl :
```
kubectl apply -f my-gpu-vm.yaml
```
Une fois votre VM en cours d'exécution, connectez-vous à celle-ci et vérifiez que le matériel GPU est disponible.

Étapes suivantes

Modifiez une VM dans GDCV pour une solution Bare Metal.