Algumas ou todas as informações nesta página podem não se aplicar à Trusted Cloud da S3NS. Consulte Diferenças do Google Cloud para saber mais.

Esta página foi traduzida pela API Cloud Translation.

Faça a gestão da pilha de GPUs com o operador de GPUs da NVIDIA no Google Kubernetes Engine (GKE)

Padrão

Esta página ajuda a decidir quando usar o operador de GPU da NVIDIA e mostra-lhe como ativar o operador de GPU da NVIDIA no GKE.

Vista geral

Os operadores são extensões de software do Kubernetes que permitem aos utilizadores criar recursos personalizados que gerem aplicações e os respetivos componentes. Pode usar operadores para automatizar tarefas complexas além do que o próprio Kubernetes oferece, como implementar e atualizar aplicações.

O operador de GPU da NVIDIA é um operador do Kubernetes que fornece uma infraestrutura e uma API comuns para implementar, configurar e gerir componentes de software necessários para aprovisionar GPUs da NVIDIA num cluster do Kubernetes. O operador de GPU da NVIDIA oferece uma experiência consistente, simplifica a gestão de recursos de GPU e otimiza a integração de cargas de trabalho aceleradas por GPU no Kubernetes.

Por que motivo deve usar o operador de GPU da NVIDIA?

Recomendamos que use a gestão de GPUs do GKE para os seus nós de GPU, porque o GKE gere totalmente o ciclo de vida dos nós de GPU. Para começar a usar o GKE para gerir os seus nós de GPU, escolha uma destas opções:

Em alternativa, o operador de GPU da NVIDIA pode ser uma opção adequada para si se procurar uma experiência consistente em vários fornecedores de serviços na nuvem, já estiver a usar o operador de GPU da NVIDIA ou se estiver a usar software que dependa do operador de GPU da NVIDIA.

Para mais considerações ao decidir entre estas opções, consulte o artigo Faça a gestão da pilha de GPUs através do GKE ou do operador de GPUs NVIDIA no GKE.

Limitações

O operador de GPU da NVIDIA é suportado em imagens de nós do SO otimizado para contentores (COS) e do Ubuntu com as seguintes limitações:

O operador de GPU da NVIDIA é suportado no GKE a partir da versão 24.6.0 do operador de GPU ou posterior.
O operador de GPU da NVIDIA não é suportado em clusters do Autopilot.
O operador de GPU da NVIDIA não é suportado em imagens de nós do Windows.
O operador de GPU da NVIDIA não é gerido pelo GKE. Para atualizar o operador de GPU da NVIDIA, consulte a documentação da NVIDIA.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ative a API Google Kubernetes Engine

Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Certifique-se de que cumpre os requisitos em Execute GPUs em pools de nós padrão.
Verifique se tem o Helm instalado no seu ambiente de desenvolvimento. O Helm vem pré-instalado no Cloud Shell.

Embora não exista um requisito específico da versão do Helm, pode usar o seguinte comando para verificar se tem o Helm instalado.
```
helm version
```
Se o resultado for semelhante a Command helm not found, pode instalar a CLI Helm executando este comando:
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh
```

Crie e configure o node pool de GPU

Para criar e configurar o conjunto de nós da GPU, siga estes passos:

Crie um node pool de GPU seguindo as instruções sobre como criar um node pool de GPU com as seguintes modificações:
- Defina gpu-driver-version=disabled para ignorar a instalação automática do controlador da GPU, uma vez que não é suportada quando usa o operador de GPU da NVIDIA.
- Defina --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" para desativar o DaemonSet do plug-in de dispositivo GPU gerido do GKE.
Execute o seguinte comando e anexe outras flags para a criação do node pool de GPU conforme necessário:
```
gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=disabled \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true"
```
Substitua o seguinte:
- POOL_NAME o nome que escolheu para o conjunto de nós.
- GPU_TYPE: o tipo de acelerador de GPU que quer usar. Por exemplo, nvidia-h100-80gb.
- AMOUNT: o número de GPUs a associar aos nós no node pool.
Por exemplo, o seguinte comando cria um node pool do GKE, a3nodepool, com GPUs H100 no cluster zonal a3-cluster. Neste exemplo, o DaemonSet do plugin de dispositivo de GPU do GKE e a instalação automática de controladores estão desativados.
```
gcloud container node-pools create a3nodepool \
  --cluster=a3-cluster \
  --location=us-central1 \
  --node-locations=us-central1-a \
  --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=disabled \
  --machine-type=a3-highgpu-8g \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" \
  --num-nodes=1
```
Execute o seguinte comando para obter as credenciais de autenticação do cluster:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION
```
Substitua o seguinte:
- CLUSTER_NAME: o nome do cluster que contém o seu conjunto de nós.
- CONTROL_PLANE_LOCATION: a localização do Compute Engine do plano de controlo do seu cluster. Indique uma região para clusters regionais ou uma zona para clusters zonais.
O resultado é semelhante ao seguinte:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
(Opcional) Confirme se consegue estabelecer ligação ao cluster.
```
kubectl get nodes -o wide
```
Deve ver uma lista de todos os seus nós em execução neste cluster.
Crie o espaço de nomes gpu-operator para o operador de GPU da NVIDIA executando o seguinte comando:
```
kubectl create ns gpu-operator
```
O resultado é semelhante ao seguinte:
```
namespace/gpu-operator created
```

Execute este comando para criar uma quota de recursos no espaço de nomes gpu-operator:

kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

O resultado é semelhante ao seguinte:

resourcequota/gpu-operator-quota created

Veja a quota de recursos para o espaço de nomes gpu-operator:

kubectl get -n gpu-operator resourcequota gpu-operator-quota

O resultado é semelhante ao seguinte:

NAME                 AGE     REQUEST       LIMIT
gpu-operator-quota   2m27s   pods: 0/100

Instale manualmente os controladores nos nós do SO otimizado para contentores ou do Ubuntu. Para obter instruções detalhadas, consulte o artigo Instale manualmente os controladores da GPU NVIDIA.
- Se usar o COS, execute os seguintes comandos para implementar o DaemonSet e instalar a versão do controlador de GPU predefinida:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Se usar o Ubuntu, o DaemonSet de instalação que implementa depende do tipo de GPU e da versão do nó do GKE, conforme descrito na secção do Ubuntu das instruções.

Execute este comando para verificar a versão do controlador da GPU:

kubectl logs -l k8s-app=nvidia-driver-installer  \
  -c "nvidia-driver-installer" --tail=-1 -n kube-system

Se a instalação do controlador da GPU for bem-sucedida, o resultado é semelhante ao seguinte:

I0716 03:17:38.863927    6293 cache.go:66] DRIVER_VERSION=535.183.01
…
I0716 03:17:38.863955    6293 installer.go:58] Verifying GPU driver installation
I0716 03:17:41.534387    6293 install.go:543] Finished installing the drivers.

Instale o operador de GPU da NVIDIA

Esta secção mostra como instalar o operador de GPU da NVIDIA através do Helm. Para saber mais, consulte a documentação da NVIDIA sobre a instalação do operador de GPU da NVIDIA.

Adicione o repositório Helm da NVIDIA:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

Instale o operador de GPU da NVIDIA através do Helm com as seguintes opções de configuração:
- Certifique-se de que a versão do operador de GPU é a 24.6.0 ou posterior.
- Configure o caminho de instalação do controlador no operador de GPU com hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Defina o caminho de instalação do conjunto de ferramentas toolkit.installDir=/home/kubernetes/bin/nvidia para o COS e o Ubuntu. No COS, o diretório /home é gravável e serve como uma localização com estado para armazenar os binários de tempo de execução da NVIDIA. Para saber mais, consulte a vista geral dos discos e do sistema de ficheiros do COS.
- Ative a interface do dispositivo do contentor (CDI) no operador de GPU com cdi.enabled=true e cdi.default=true, uma vez que o modo antigo não é suportado. A CDI é necessária para o COS e o Ubuntu no GKE.
```
helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
  --set toolkit.installDir=/home/kubernetes/bin/nvidia \
  --set cdi.enabled=true \
  --set cdi.default=true \
  --set driver.enabled=false
```
Para saber mais acerca destas definições, consulte as Opções comuns de personalização de gráficos e os Cenários de implementação comuns na documentação da NVIDIA.

Verifique se o operador de GPU da NVIDIA está instalado com êxito.

Para verificar se os operandos do operador de GPU estão a ser executados corretamente, execute o seguinte comando.

kubectl get pods -n gpu-operator

O resultado tem um aspeto semelhante ao seguinte:

NAME                                                          READY    STATUS
RESTARTS   AGE
gpu-operator-5c7cf8b4f6-bx4rg                                 1/1      Running   0          11m
gpu-operator-node-feature-discovery-gc-79d6d968bb-g7gv9       1/1      Running   0          11m
gpu-operator-node-feature-discovery-master-6d9f8d497c-thhlz   1/1      Running   0          11m
gpu-operator-node-feature-discovery-worker-wn79l              1/1      Running   0          11m
gpu-feature-discovery-fs9gw                                   1/1      Running   0          8m14s
gpu-operator-node-feature-discovery-worker-bdqnv              1/1      Running   0          9m5s
nvidia-container-toolkit-daemonset-vr8fv                      1/1      Running   0          8m15s
nvidia-cuda-validator-4nljj                                   0/1      Completed 0          2m24s
nvidia-dcgm-exporter-4mjvh                                    1/1      Running   0          8m15s
nvidia-device-plugin-daemonset-jfbcj                          1/1      Running   0          8m15s
nvidia-mig-manager-kzncr                                      1/1      Running   0          2m5s
nvidia-operator-validator-fcrr6                               1/1      Running   0          8m15s

Para verificar se a contagem de GPUs está configurada corretamente no campo "Allocatable" do nó, execute o seguinte comando:

kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

Substitua GPU_NODE_NAME pelo nome do nó que tem GPUs.

O resultado é semelhante ao seguinte:

Allocatable:
cpu:                11900m
ephemeral-storage:  47060071478
hugepages-1Gi:      0
hugepages-2Mi:      0
memory:             80403000Ki
nvidia.com/gpu:     1           # showing correct count of GPU associated with the nods
pods:               110

Para verificar se a carga de trabalho da GPU é executada corretamente, pode usar a ferramenta cuda-vectoradd:

cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
  name: cuda-vectoradd
spec:
  restartPolicy: OnFailure
  containers:
  - name: vectoradd
    image: nvidia/samples:vectoradd-cuda11.2.1
    resources:
      limits:
        nvidia.com/gpu: 1
EOF

Em seguida, execute o seguinte comando:

kubectl logs cuda-vectoradd

O resultado é semelhante ao seguinte:

[Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done

Faça a gestão da pilha de GPUs com o operador de GPUs da NVIDIA no Google Kubernetes Engine (GKE)

Vista geral

Por que motivo deve usar o operador de GPU da NVIDIA?

Limitações

Antes de começar

Crie e configure o node pool de GPU

Instale o operador de GPU da NVIDIA

O que se segue?