Esta página foi traduzida pela API Cloud Translation.

Ativar e usar GPUs NVIDIA em VMs com o ambiente de execução de VMs do GDC

Neste documento, mostramos como ativar o suporte a GPUs NVIDIA® em máquinas virtuais (VMs) executadas com o ambiente de execução de VMs no GDC. Você vai aprender a instalar os drivers NVIDIA nos nós do Google Distributed Cloud, verificar se as GPUs estão disponíveis e atribuir GPUs às VMs.

Antes de começar

Para concluir este documento, você precisa de acesso aos seguintes recursos:

Acesso ao Google Distributed Cloud versão 1.12.0 (anthosBareMetalVersion: 1.12.0) ou um cluster superior. Utilize qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, teste o Google Distributed Cloud no Compute Engine ou consulte a visão geral de criação do cluster.
A ferramenta do cliente virtctl instalada como um plug-in para o kubectl. Se necessário, instale a ferramenta de cliente virtctl.

Placas de GPU Nvidia compatíveis

O Google Distributed Cloud 1.13 ou mais recente é compatível com as seguintes GPUs 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

Instalar drivers da NVIDIA nos nós

Para que as VMs possam usar as GPUs NVIDIA, você precisa configurar os nós do Google Distributed Cloud para aceitar os dispositivos de GPU. Para instalar os drivers da NVIDIA nos nós, siga as etapas a seguir em cada nó do cluster que inclui uma GPU NVIDIA. Neste documento, usamos uma versão compatível do Ubuntu para os nós:

Conecte-se ao nó do Google Distributed Cloud que você quer configurar para suporte a GPUs.
Encontre a versão do kernel do nó:
```
KERNEL_VERSION="$(uname -r)"
```

Atualize o nó do Ubuntu e instale os cabeçalhos do kernel apropriados:

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

Instale o pacote build-essential para poder compilar os drivers da Nvidia em uma etapa a seguir:
```
sudo apt install -y build-essential
```
Faça o download do pacote de driver da NVIDIA adequado para sua GPU. Para ver a lista completa de drivers, consulte Downloads de drivers da NVIDIA.

O exemplo a seguir faz o download do driver Linux x86_64 versão 470.82.01:
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```
Instale o pacote de driver da NVIDIA. Use o nome do pacote de driver da NVIDIA de que você fez o download na etapa anterior:
```
sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
  --accept-license \
  --silent \
  --no-nouveau-check
```
Carregue o módulo do kernel da NVIDIA:
```
sudo modprobe nvidia
```
Repita as etapas nesta seção em cada nó do cluster que tem uma GPU NVIDIA.

Ativar o suporte a GPUs no ambiente de execução de VMs do GDC

Depois de instalar os drivers NVIDIA nos nós do Google Distributed Cloud, ative o suporte a GPUs no ambiente de execução de VMs no GDC. Suas VMs poderão acessar as GPUs nos nós.

Cada nó é reinicializado como parte do processo a seguir. Suas VMs podem ser afetadas por esse processo de reinicialização. Se puderem e estiverem configuradas para isso, as VMs poderão ser migradas para outros nós. Para mais informações, consulte como configurar a política de remoção de VMs durante eventos de manutenção.

Para ativar o suporte a GPUs no ambiente de execução de VMs no GDC, siga as etapas a seguir.

Edite o recurso personalizado VMRuntime:
```
kubectl edit vmruntime vmruntime
```

Adicione o property enableGPU: true ao manifesto VMRuntime:

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

Salve e feche o recurso personalizado VMRuntime no editor.

Verifique o status dos controladores de GPU no namespace vm-system:

kubectl get pods --namespace vm-system  -w

Leva cerca de cinco minutos para que os controladores sejam ativados. Aguarde até que STATUS mostre Running para todos os controladores de GPU. O exemplo de saída a seguir mostra o estado pretendido:

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

Verifique se as GPUs estão disponíveis para uso com todos os controladores de GPU exibindo o status Running:
```
kubectl get gpuallocations --namespace vm-system
```
O exemplo de saída a seguir mostra que as GPUs nos nós estão disponíveis para uso. Cada nó do cluster com suporte a GPUs é exibido. Aloque-os para as VMs na próxima seção:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Alocar GPUs para uso com VMs

Com o suporte a GPUs configurado nos nós do cluster bare metal e no ambiente de execução de VMs no GDC, aloque as GPUs para serem usadas com as VMs. Por padrão, as GPUs são alocadas para uso com pods (contêineres).

Edite o recurso personalizado GPUAllocation para uso com as VMs. Esta etapa atribui as GPUs nos nós para uso com VMs:
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
Substitua NODE_NAME pelo nome do nó de que quer alocar GPUs.
Configure quantas GPUs serão alocadas para as VMs. Inicialmente, todas as GPUs são alocadas para pods.

O número total de GPUs alocadas para VMs e pods precisa ser igual ao número de GPUs no nó. Por exemplo, você pode ter quatro GPUs no nó. Se você alocar duas GPUs para VMs, essas GPUs permanecerão alocadas para pods. O manifesto GPUAllocation será rejeitado se você tentar alocar duas GPUs para VMs e uma para pods, já que uma GPU não será alocada.

Atualize o número de GPUs no nó que você quer alocar para uso com VMs, como mostrado no exemplo a seguir:
```
apiVersion: gpu.cluster.gke.io/v1
kind: GPUAllocation
metadata:
  name: gpu-w2
  namespace: vm-system
spec:
  node: gpu-w2
  pod: 0
  vm: 4
```
Neste exemplo, todas as quatro GPUs instaladas no nó são alocadas para VMs. Nenhuma GPU é alocada para pods.
Salve e feche o recurso personalizado GPUAllocation no editor.

Verifique se as GPUs exibem o status ALLOCATED como true:

kubectl get gpuallocations --namespace vm-system

O exemplo de saída a seguir mostra que as GPUs nos nós estão disponíveis para uso:

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

Criar uma VM com suporte a GPUs

Agora, é possível criar uma VM que usa a GPU do nó. No recurso personalizado da VM, você especifica o nome e a quantidade de GPUs a serem alocadas do nó.

Veja o nome da placa de GPU no host:

kubectl describe node NODE_NAME

Substitua NODE_NAME pelo nome do host em que quer ver o nome da GPU.

A saída de exemplo a seguir mostra que o nome da GPU alocável nesse nó é NVIDIA_A100_SXM4_40GB:

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

Crie um manifesto de VirtualMachine, como my-gpu-vm.yaml, no editor de sua escolha:
```
nano my-gpu-vm.yaml
```
Copie e cole o seguinte manifesto 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
```
Nesse arquivo YAML, defina as seguintes configurações:
- VM_NAME: o nome da VM.
- GPU_NAME: o nome da GPU do nó que será alocado para a VM.
  - Esse nome da GPU é mostrado na saída do comando kubectl describe node de uma etapa anterior, como NVIDIA_A100_SXM4_40GB.
A VM conecta eth0 à rede pod-network padrão.

O disco de inicialização chamado VM_NAME-boot-dv já precisa existir. Para mais informações, consulte Criar e gerenciar discos virtuais.
Salve e feche o manifesto da VM no editor.
Crie a VM usando kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
Quando a VM estiver em execução, conecte-se à VM e verifique se o hardware da GPU está disponível.

A seguir

Edite uma VM no Google Distributed Cloud.