Esta página foi traduzida pela API Cloud Translation.

Gerenciar a pilha de GPU com o operador de GPU NVIDIA no Google Kubernetes Engine (GKE)

Padrão

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

Visão geral

Operadores são extensões de software do Kubernetes que permitem aos usuários criar recursos personalizados que gerenciam aplicativos e seus componentes. É possível usar operadores para automatizar tarefas complexas além do que o próprio Kubernetes oferece, como implantar e fazer o upgrade de aplicativos.

O operador NVIDIA GPU é um operador do Kubernetes que oferece uma infraestrutura e API para implantação, configuração e gerenciamento de software componentes necessários para provisionar GPUs NVIDIA em um cluster do Kubernetes. O NVIDIA GPU Operator oferece uma experiência consistente, simplifica o gerenciamento de recursos de GPU e a integração de cargas de trabalho aceleradas por GPU no Kubernetes.

Por que usar o operador de GPU NVIDIA?

Recomendamos usar o gerenciamento de GPU do GKE nos nós da GPU porque O GKE gerencia totalmente o ciclo de vida do nó da GPU. Para começar a usar o GKE para gerenciar seus nós de GPU, escolha uma destas opções:

Como alternativa, o Operador de GPU NVIDIA pode ser uma opção adequada se você estiver procurando uma experiência consistente em vários provedores de serviços de nuvem, se já estiver usando o Operador de GPU NVIDIA ou se estiver usando um software que depende do Operador de GPU NVIDIA.

Para mais considerações ao decidir entre essas opções, consulte Gerencie a pilha de GPU com o GKE ou o operador de GPU NVIDIA no GKE.

Limitações

O operador NVIDIA GPU é compatível com o Container-Optimized OS (COS) e imagens de nó do Ubuntu com as seguintes limitações:

O NVIDIA GPU Operator é compatível com o GKE a partir da versão 24.6.0 do GPU Operator ou mais recente.
O operador de GPU da NVIDIA não tem suporte nos clusters do Autopilot.
O operador de GPU NVIDIA não é compatível com imagens de nó do Windows.
O operador de GPU da NVIDIA não é gerenciado pelo GKE. Para fazer upgrade do operador NVIDIA GPU, consulte a documentação da NVIDIA.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
Observação: para instalações atuais da gcloud CLI, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na CLI gcloud, como: One of [--zone, --region] must be supplied: Please specify location.

Verifique se você atende aos requisitos em Executar GPUs em pools de nós padrão.
Verifique se o Helm está instalado no ambiente de desenvolvimento. O Helm vem pré-instalado no Cloud Shell.

Embora não haja um requisito específico de versão do Helm, você pode usar o comando abaixo para verificar se o Helm está instalado.
```
helm version
```
Se a saída for semelhante a Command helm not found, será possível instale a CLI do 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
```

Criar e configurar o pool de nós de GPU

Para criar e configurar o pool de nós da GPU, siga estas etapas:

Crie um pool de nós de GPU seguindo as instruções para Criar um pool de nós de GPU com as seguintes modificações:
- Definir gpu-driver-version=disabled para pular o driver automático de GPU porque ele não é compatível com o operador NVIDIA GPU.
- Definir --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" a desativar o plug-in do dispositivo de GPU gerenciado do GKE Daemonset.
Execute o comando a seguir e adicione outras flags ao final para a criação de pools de nós 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:
- POOL_NAME o nome escolhido para o pool de nós.
- GPU_TYPE: o tipo de acelerador de GPU que você quer usar. Por exemplo, nvidia-h100-80gb.
- AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós.
Por exemplo, o comando a seguir cria um pool de nós do GKE, a3nodepool, com GPUs H100 no cluster zonal a3-cluster. Neste exemplo, o plug-in do dispositivo de GPU do GKE Daemonset e a instalação automática do driver estão desativados.
```
gcloud container node-pools create a3nodepool \
  --region=us-central1 --cluster=a3-cluster \
  --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
```
Para conferir as credenciais de autenticação do cluster, execute o comando abaixo:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME [--zone COMPUTE_ZONE] [--region COMPUTE_REGION]
```
Substitua:
- CLUSTER_NAME: o nome do cluster que contém o pool de nós.
- COMPUTE_REGION ou COMPUTE_ZONE: especifique a região ou zona do cluster com base no fato de ele ser regional ou zonal, respectivamente.
O resultado será assim:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
(Opcional) Verifique se é possível se conectar ao cluster.
```
kubectl get nodes -o wide
```
Você verá uma lista de todos os nós em execução nesse cluster.
Crie o namespace gpu-operator para o operador de GPU da NVIDIA executando este comando:
```
kubectl create ns gpu-operator
```
O resultado será assim:
```
namespace/gpu-operator created
```

Crie uma cota de recursos no namespace gpu-operator executando este comando:

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 será assim:

resourcequota/gpu-operator-quota created

Veja a cota de recursos para o namespace gpu-operator:

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

O resultado será assim:

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

Instale manualmente os drivers no Container-Optimized OS ou nós do Ubuntu. Para instruções detalhadas, consulte Instale manualmente os drivers de GPU NVIDIA.
- Se estiver usando o COS, execute os comandos a seguir para implantar o DaemonSet de instalação e instalar a versão padrão do driver da GPU:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Se estiver usando o Ubuntu, o DaemonSet de instalação implantado dependerá da GPU e na versão do nó do GKE, conforme descrito nas Seção Ubuntu das instruções.

Verifique a versão do driver da GPU executando este comando:

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

Se a instalação do driver de GPU for bem-sucedida, a saída será semelhante a esta:

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.

Instalar o Operador de GPU NVIDIA

Nesta seção, mostramos como instalar o operador de GPU da NVIDIA usando o Helm. Para saber consulte a documentação da NVIDIA Como instalar o NVIDIA GPU Operator.

Adicione o repositório do Helm da NVIDIA:

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

Instale o Operador de GPU NVIDIA usando o Helm com as seguintes opções de configuração:
- Verifique se a versão do GPU Operator é 24.6.0 ou mais recente.
- Configure o caminho de instalação do driver no Operador de GPU com hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Definir o caminho de instalação do kit de ferramentas toolkit.installDir=/home/kubernetes/bin/nvidia para COS e Ubuntu. No COS, o diretório /home é gravável e serve como um endereço para armazenar os binários do ambiente de execução da NVIDIA. Para saber mais, consulte à Visão geral de discos e sistema de arquivos do COS.
- Ative a interface de dispositivo de contêiner (CDI) no operador de GPU com cdi.enabled=true e cdi.default=true, porque o modo legado não é compatível. O CDI é necessário 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 sobre essas configurações, consulte as opções comuns de personalização de gráficos e cenários comuns de implantação na documentação da NVIDIA.

Verifique se o operador de GPU NVIDIA foi instalado.

Para verificar se os operandos do operador da GPU estão sendo executados corretamente, execute o comando comando a seguir.

kubectl get pods -n gpu-operator

A saída será assim:

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 GPU está configurada corretamente no "Alocável" , 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 será assim:

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 está sendo executada corretamente, use 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 comando:

kubectl logs cuda-vectoradd

O resultado será assim:

[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

Gerenciar a pilha de GPU com o operador de GPU NVIDIA no Google Kubernetes Engine (GKE)

Visão geral

Por que usar o operador de GPU NVIDIA?

Limitações

Antes de começar

Criar e configurar o pool de nós de GPU

Instalar o Operador de GPU NVIDIA

A seguir