Habilita y usa las GPU de NVIDIA en VM con entorno de ejecución de VM en Google Distributed Cloud

En este documento, se muestra cómo habilitar la compatibilidad con GPU de NVIDIA® en las máquinas virtuales (VM) que se ejecutan mediante el entorno de ejecución de VM en Google Distributed Cloud. Aprenderás a instalar los controladores NVIDIA en tus nodos de GKE en Bare Metal, verificar que las GPU estén disponibles y asignar GPU a las VM.

Antes de comenzar

Para completar este documento, necesitas acceso a los siguientes recursos:

Acceso al clúster de GKE en Bare Metal versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o superior. Puedes usar cualquier tipo de clúster capaz de ejecutar cargas de trabajo. Si es necesario, prueba GKE en Bare Metal en Compute Engine o consulta la descripción general de la creación de clústeres.
La herramienta de cliente virtctl instalada como un complemento para kubectl. Si es necesario, instala la herramienta cliente de virtctl.

Tarjetas de GPU Nvidia compatibles

GKE en Bare Metal versión 1.13 o posterior es compatible con las siguientes GPU NVIDIA:

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

Instala controladores de NVIDIA en los nodos

Antes de que tus VM puedan usar las GPU de NVIDIA, debes configurar tus nodos de GKE en Bare Metal para admitir los dispositivos de GPU. Para instalar los controladores NVIDIA en los nodos, completa los siguientes pasos en cada nodo en el clúster que incluye una GPU NVIDIA. En este documento, se usa una versión de Ubuntu compatible para los nodos:

Conéctate al nodo de GKE en Bare Metal que deseas configurar para la compatibilidad con GPU.
Obtén la versión de kernel de tu nodo:
```
KERNEL_VERSION="$(uname -r)"
```

Actualiza tu nodo de Ubuntu e instala los encabezados de kernel adecuados:

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

Instala el paquete build-essential para que puedas compilar los controladores Nvidia en el siguiente paso:
```
sudo apt install -y build-essential
```
Descarga el paquete del controlador NVIDIA adecuado para tu GPU. Para obtener una lista completa de controladores, consulta Descargas de controladores NVIDIA.

En el siguiente ejemplo, se descarga el controlador Linux x86_64 versión 470.82.01:
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```
Instala el paquete del controlador NVIDIA. Usa el nombre del paquete de controladores NVIDIA que descargaste en el paso anterior:
```
sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
  --accept-license \
  --silent \
  --no-nouveau-check
```
Carga el módulo kernel de NVIDIA:
```
sudo modprobe nvidia
```
Repite los pasos de esta sección en cada nodo del clúster que tenga una GPU de NVIDIA.

Habilita la compatibilidad con GPU en el entorno de ejecución de VM en Google Distributed Cloud.

Después de instalar los controladores NVIDIA en tus nodos de GKE en Bare Metal, habilita la compatibilidad con GPU en el entorno de ejecución de VM en Google Distributed Cloud. Tus VM pueden acceder a las GPU en los nodos.

Cada nodo se reinicia como parte del siguiente proceso. Este proceso de reinicio puede afectar a tus VM. Si es posible y se configura para hacerlo, las VM que se pueden migrar lo hacen a otros nodos. A fin de obtener más información, consulta cómo configurar la política de expulsión para las VM durante los eventos de mantenimiento.

Para habilitar la compatibilidad con GPU en el entorno de ejecución de VM en Google Distributed Cloud, completa los siguientes pasos.

Edita el recurso personalizado VMRuntime:
```
kubectl edit vmruntime vmruntime
```

Agrega la propiedad enableGPU: true al manifiesto VMRuntime:

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

Guarda y cierra el recurso personalizado VMRuntime en el editor.

Verifica el estado de los controladores de GPU en el espacio de nombres vm-system:

kubectl get pods --namespace vm-system  -w

Los controladores tardan unos cinco minutos en habilitarse de forma correcta. Espera a que STATUS muestre Running para todos los controladores de GPU. El siguiente resultado de ejemplo muestra el estado deseado:

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 que las GPU estén disponibles para su uso cuando todos los controladores de GPU informen su estado como Running:
```
kubectl get gpuallocations --namespace vm-system
```
En el siguiente resultado de ejemplo, se muestra que las GPU en los nodos están disponibles para su uso. Se muestra cada nodo del clúster que admite GPU. En la siguiente sección, las asignarás a las VM:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Asigna GPU para usarlas con VM

Con la compatibilidad con GPU configurada en los clústeres de Anthos alojados en nodos de Bare Metal y en el entorno de ejecución de VM en Google Distributed Cloud, asigna las GPU para usarlas con las VMs. De forma predeterminada, las GPU se asignan para su uso con Pods (contenedores).

Edita el recurso personalizado GPUAllocation para usarlo con las VM. En este paso, se asignan las GPU en los nodos para usarlas con las VM:
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
Reemplaza NODE_NAME por el nombre del nodo desde el que deseas asignar las GPU.
Configura cuántas GPU se asignarán a las VM. En un principio, todas las GPU se asignan a los Pods.

La cantidad total de GPU asignadas a las VM y a los Pods debe ser igual a la cantidad de GPU en el nodo. Por ejemplo, puedes tener cuatro GPU en tu nodo. Si asignas dos GPU a las VM, quedan dos GPU asignadas a los Pods. El manifiesto GPUAllocation se rechaza si intentas asignar dos GPU a las VM y una GPU a los Pods, ya que queda una GPU sin asignar.

Actualiza la cantidad de GPU en el nodo que deseas asignar para usarlas con VM, como se muestra en el siguiente ejemplo:
```
apiVersion: gpu.cluster.gke.io/v1
kind: GPUAllocation
metadata:
  name: gpu-w2
  namespace: vm-system
spec:
  node: gpu-w2
  pod: 0
  vm: 4
```
En este ejemplo, las cuatro GPU instaladas en el nodo se asignan a las VM. No hay GPU asignadas a los Pods.
Guarda y cierra el recurso personalizado GPUAllocation en el editor.

Verifica que las GPU informen su estado ALLOCATED como true:

kubectl get gpuallocations --namespace vm-system

En el siguiente resultado de ejemplo, se muestra que las GPU en los nodos están disponibles para su uso:

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

Crea una VM con asistencia de GPU

Ahora puedes crear una VM que use la GPU desde el nodo. En el recurso personalizado de VM, especifica el nombre y la cantidad de GPU que se asignarán desde el nodo.

Obtén el nombre de la tarjeta de GPU del host:

kubectl describe node NODE_NAME

Reemplaza NODE_NAME por el nombre del host del que deseas obtener el nombre de la GPU.

En el siguiente resultado de ejemplo, se muestra que el nombre de GPU asignable en este nodo es 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 manifiesto VirtualMachine, como my-gpu-vm.yaml, en el editor que elijas:
```
nano my-gpu-vm.yaml
```
Copia y pega el siguiente manifiesto 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
```
En este archivo YAML, define la siguiente configuración:
- VM_NAME: el nombre de tu VM.
- GPU_NAME: Es el nombre de GPU del nodo que se asignará a la VM.
  - Este nombre de GPU se muestra en el resultado del comando kubectl describe node de un paso anterior, como NVIDIA_A100_SXM4_40GB.
La VM conecta eth0 a la red pod-network predeterminada.

El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Si deseas obtener más información, consulta Crea y administra discos virtuales.
Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM mediante kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
Cuando la VM se esté ejecutando, conéctate a la VM y verifica que el hardware de GPU esté disponible.

¿Qué sigue?

Edita una VM en GKE alojado en Bare Metal.