Esta página se ha traducido con Cloud Translation API.

Habilitar y usar GPUs NVIDIA en máquinas virtuales con VM Runtime en GDC

En este documento se explica cómo habilitar la compatibilidad con GPUs NVIDIA® para máquinas virtuales que se ejecutan con VM Runtime en GDC. Aprenderás a instalar los controladores de NVIDIA en tus nodos de Google Distributed Cloud, verificar que las GPUs estén disponibles y asignar GPUs a las VMs.

Antes de empezar

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

Acceso a un clúster de Google Distributed Cloud versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o posterior. Puedes usar cualquier tipo de clúster que pueda ejecutar cargas de trabajo. Si es necesario, prueba Google Distributed Cloud en Compute Engine o consulta la descripción general de la creación de clústeres.
La herramienta de cliente virtctl instalada como complemento de kubectl. Si es necesario, instala la herramienta de cliente virtctl.

Tarjetas GPU Nvidia compatibles

Google Distributed Cloud versión 1.13 o posterior admite las siguientes GPUs NVIDIA:

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

Instalar controladores de NVIDIA en nodos

Para que tus VMs puedan usar las GPUs de NVIDIA, debes configurar tus nodos de Google Distributed Cloud para que admitan los dispositivos de GPU. Para instalar los controladores de NVIDIA en tus nodos, sigue estos pasos en cada nodo de tu clúster que incluya una GPU de NVIDIA. En este documento se usa una versión de Ubuntu compatible para los nodos:

Conéctate al nodo de Google Distributed Cloud que quieras configurar para que sea compatible con GPUs.
Obtén la versión del kernel de tu nodo:
```
KERNEL_VERSION="$(uname -r)"
```
Actualiza tu nodo de Ubuntu e instala los encabezados del kernel correspondientes:
```
sudo apt update && \
apt install -y linux-headers-${KERNEL_VERSION}
```
Instala el paquete build-essential para poder compilar los controladores de Nvidia en el siguiente paso:
```
sudo apt install -y build-essential
```
Descarga el paquete de controladores de NVIDIA adecuado para tu GPU. Para ver una lista completa de los controladores, consulta Descargas de controladores de NVIDIA.

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

Habilitar la compatibilidad con GPUs en el entorno de ejecución de máquinas virtuales en GDC

Después de instalar los controladores de NVIDIA en los nodos de Google Distributed Cloud, habilita la compatibilidad con GPU en VM Runtime en GDC. De esta forma, tus VMs podrán acceder a las GPUs de los nodos.

Cada nodo se reinicia como parte del siguiente proceso. Es posible que tus VMs se vean afectadas por este proceso de reinicio. Si es posible y está configurado para ello, las VMs migrables se migran a otros nodos. Para obtener más información, consulte cómo configurar la política de desalojo de las VMs durante los eventos de mantenimiento.

Para habilitar la compatibilidad con GPU en VM Runtime en GDC, sigue estos pasos.

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

Añade 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.

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

kubectl get pods --namespace vm-system  -w

Los mandos tardan unos cinco minutos en habilitarse correctamente. Espera a que se muestre STATUS Running en todos los controladores de GPU. En el siguiente ejemplo de salida se 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

Comprueba que las GPUs estén disponibles cuando todos los controladores de GPU indiquen que su estado es Running:
```
kubectl get gpuallocations --namespace vm-system
```
En el siguiente ejemplo de salida se muestra que las GPUs de los nodos están disponibles para su uso. Se muestra cada nodo de tu clúster que admite GPUs. En la siguiente sección, se explica cómo asignarlos a las máquinas virtuales:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Asignar GPUs para usarlas con máquinas virtuales

Una vez que hayas configurado la compatibilidad con GPUs en los nodos del clúster de hardware desnudo y en el tiempo de ejecución de VM en GDC, asigna las GPUs para usarlas con las VMs. De forma predeterminada, las GPUs se asignan para usarse con pods (contenedores).

Edita el GPUAllocation recurso personalizado para usarlo con máquinas virtuales. En este paso se asignan las GPUs de los nodos para usarlas con las VMs:
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
Sustituye NODE_NAME por el nombre del nodo del que quieras asignar GPUs.
Configura cuántas GPUs quieres asignar a las VMs. Inicialmente, todas las GPUs se asignan a pods.

El número total de GPUs asignadas a las VMs y los pods debe ser igual al número de GPUs del nodo. Por ejemplo, puede que tengas cuatro GPUs en tu nodo. Si asignas dos GPUs a las VMs, estas dos GPUs seguirán asignadas a los pods. El manifiesto GPUAllocation se rechaza si intentas asignar dos GPUs a máquinas virtuales y una GPU a pods, ya que una GPU se queda sin asignar.

Actualiza el número de GPUs del nodo que quieras asignar para usarlo con las VMs, tal 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 GPUs instaladas en el nodo se asignan a las VMs. No se asignan GPUs a los pods.
Guarda y cierra el recurso personalizado GPUAllocation en el editor.

Verifica que las GPUs indiquen que su estado ALLOCATED es true:

kubectl get gpuallocations --namespace vm-system

En el siguiente ejemplo de salida se muestra que las GPUs de 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

Crear una VM con compatibilidad con GPU

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

Obtén el nombre de la tarjeta gráfica del host:

kubectl describe node NODE_NAME

Sustituye NODE_NAME por el nombre del host del que quieras obtener el nombre de la GPU.

En el siguiente ejemplo de salida se muestra que el nombre de la 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 prefieras:
```
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 los siguientes ajustes:
- VM_NAME: el nombre de tu máquina virtual.
- GPU_NAME: el nombre de la 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 se conecta eth0 a la red pod-network predeterminada.

El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear y gestionar discos virtuales.
Guarda y cierra el manifiesto de la VM en tu editor.
Crea la VM con kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
Cuando la VM esté en ejecución, conéctate a ella y comprueba que el hardware de la GPU está disponible.

Siguientes pasos

Edita una máquina virtual en Google Distributed Cloud.