**Ajudar a melhorar esta página** Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página. # Gerenciar dispositivos de GPU NVIDIA no Amazon EKS As GPUs da NVIDIA são amplamente utilizadas para treinamento de machine learning, inferência e workloads de computação de alta performance. O Amazon EKS oferece suporte a dois mecanismos para gerenciar dispositivos de GPU NVIDIA em seus clusters do EKS: o *driver NVIDIA DRA para GPUs* e o *plug-in de dispositivo NVIDIA para Kubernetes*. É recomendado usar o driver de DRA da NVIDIA para novas implantações em clusters que executam a versão 1.34 ou versões posteriores do Kubernetes com grupos de nós gerenciados pelo EKS ou grupos de nós autogerenciados. O driver NVIDIA DRA permite a alocação flexível e o compartilhamento de GPU entre contêineres. Não há suporte para o driver de DRA da NVIDIA com o Karpenter ou para o Modo Automático do EKS. Use o [plug-in de dispositivo da NVIDIA](#nvidia-device-plugin) com o Karpenter e o Modo Automático do EKS. Além disso, o plug-in de dispositivo da NVIDIA permanece compatível com grupos de nós gerenciados pelo EKS e com nós autogerenciados. ## Driver NVIDIA DRA x plug-in de dispositivo NVIDIA | Recurso | Driver de DRA da NVIDIA | Plug-in de dispositivo NVIDIA | | --- | --- | --- | | Versão mínima do Kubernetes | 1.34 | Todas as versões do Kubernetes compatíveis com o EKS | | Computação do EKS | Grupos de nós gerenciados e nós autogerenciados | Modo Automático do EKS, Karpenter, grupos de nós gerenciados e nós autogerenciados | | AMIs otimizadas para o EKS | AL2023 (NVIDIA) | AL2023 (NVIDIA) e Bottlerocket | | Anúncio de dispositivo | Atributos detalhados por meio de objetos `ResourceSlice`, incluindo modelo da GPU, memória, versão do driver e topologia | Contagem de inteiros de recursos estendidos `nvidia.com/gpu` | | Compartilhamento de GPU | Vários contêineres no mesmo Pod podem compartilhar uma GPU por meio de referências compartilhadas `ResourceClaim` | Sem compatibilidade. Cada GPU é alocada exclusivamente a um contêiner. | | ComputeDomains | Gerencia o Multi-Node NVLink (MNNVL) por meio de recursos `ComputeDomain` para uma comunicação segura entre GPUs em vários nós | Não compatível | | Seleção baseada em atributos | Filtre GPUs por modelo, memória ou outros atributos usando expressões CEL | Não compatível | | Alocação de EFA com reconhecimento de topologia | Reconhecimento de topologia nativo de DRA | Reconhecimento de topologia automático (apenas AMIs AL2023 otimizadas para o EKS) | ## Instale o driver NVIDIA DRA O driver NVIDIA DRA para GPUs gerencia dois tipos de recursos: GPUs e ComputeDomains. Ele executa dois plug-ins DRA kubelet: `gpu-kubelet-plugin` e `compute-domain-kubelet-plugin`. Cada uma delas pode ser habilitada ou desabilitada separadamente durante a instalação. Este guia aborda a alocação de GPUs. Para saber como usar o ComputeDomains, consulte [Uso do P6e-GB200 UltraServers com o Amazon EKS](ml-eks-nvidia-ultraserver.md). ### Pré-requisitos + Um cluster do Amazon EKS que executa a versão 1.34 ou versões posteriores do Kubernetes com grupos de nós gerenciados pelo EKS ou com grupos de nós autogerenciados. + Nós com tipos de instância de GPU NVIDIA (como instâncias `P` ou `G`). + Nós com componentes de nível de host instalados para GPUs NVIDIA. Ao utilizar as AMIs NVIDIA AL2023 ou Bottlerocket otimizadas para EKS, o driver NVIDIA no nível do host, o driver CUDA em modo de usuário e o kit de ferramentas para contêineres já vêm pré-instalados. + O Helm instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md) para obter mais informações. + `kubectl` configurado para se comunicar com o seu cluster; consulte [Instalar ou atualizar o `kubectl`](install-kubectl.md#kubectl-install-update) para obter mais informações. ### Procedimento **Importante** Ao utilizar o driver NVIDIA DRA para o gerenciamento de dispositivos de GPU, a implantação dele não pode ser realizada junto com o plug-in de dispositivo NVIDIA no mesmo nó. Consulte o [KEP-5004](https://github.com/kubernetes/enhancements/issues/5004) do Kubernetes para obter atualizações. **Importante** Atualmente, o uso do driver NVIDIA DRA com o Bottlerocket não é compatível. 1. Adicione o repositório do chart do Helm do driver NVIDIA DRA. ``` helm repo add nvidia https://helm.ngc.nvidia.com/nvidia ``` 1. Atualize seu repositório Helm local. ``` helm repo update ``` 1. Baixe a versão mais recente do driver NVIDIA DRA. ``` helm search repo nvidia/nvidia-dra ``` 1. Instale o driver NVIDIA DRA. ``` helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \ --create-namespace \ --namespace nvidia-dra-driver-gpu \ --set resources.computeDomains.enabled=false \ --set 'gpuResourcesEnabledOverride=true' ``` Para opções de configuração avançadas, consulte o [chart do Helm do driver NVIDIA DRA](https://github.com/kubernetes-sigs/nvidia-dra-driver-gpu/blob/main/deployments/helm/nvidia-dra-driver-gpu/values.yaml). 1. Verifique se os pods do driver DRA estão em execução. ``` kubectl get pods -n nvidia-dra-driver-gpu ``` 1. Verifique se os objetos `DeviceClass` foram criados. ``` kubectl get deviceclass ``` ``` NAME AGE gpu.nvidia.com 60s ``` 1. Verifique se os objetos `ResourceSlice` foram publicados para seus nós de GPU. ``` kubectl get resourceslice ``` Para solicitar GPUs NVIDIA usando o driver DRA, crie um `ResourceClaimTemplate` que faça referência a `gpu.nvidia.com` `DeviceClass` e inclua-o na especificação do seu Pod. O exemplo apresentado a seguir solicita uma única GPU. Consulte [Alocação de dispositivos EFA com GPU e dispositivos do Neuron com reconhecimento de topologia](device-management-efa.md#efa-dra-topology-aware) para obter as etapas necessárias para a alocação de GPUs da NVIDIA com interfaces EFA alinhadas à topologia. ``` apiVersion: resource.k8s.io/v1 kind: ResourceClaimTemplate metadata: name: single-gpu spec: spec: devices: requests: - name: gpu exactly: deviceClassName: gpu.nvidia.com count: 1 --- apiVersion: v1 kind: Pod metadata: name: gpu-workload spec: containers: - name: app ... resources: claims: - name: gpu resourceClaims: - name: gpu resourceClaimTemplateName: single-gpu tolerations: - key: "nvidia.com/gpu" operator: "Exists" effect: "NoSchedule" ``` ## Instalar o plug-in de dispositivo NVIDIA para Kubernetes O plug-in de dispositivo NVIDIA para Kubernetes disponibiliza as GPUs NVIDIA como recursos estendidos `nvidia.com/gpu`. Você solicita GPUs nas solicitações e limites de recursos de contêineres. ### Pré-requisitos + Um cluster do Amazon EKS. + Nós com tipos de instância de GPU NVIDIA que utilizam a AMI NVIDIA AL2023 otimizada para EKS. As AMIs Bottlerocket otimizadas para o EKS incluem o plug-in de dispositivo da NVIDIA, não sendo necessário nenhuma instalação separada. + O Helm instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md) para obter mais informações. + `kubectl` configurado para se comunicar com o seu cluster; consulte [Instalar ou atualizar o `kubectl`](install-kubectl.md#kubectl-install-update) para obter mais informações. ### Procedimento 1. Adicione o repositório do chart do Helm do plug-in de dispositivo NVIDIA. ``` helm repo add nvdp https://nvidia.github.io/k8s-device-plugin ``` 1. Atualize seu repositório Helm local. ``` helm repo update ``` 1. Instale o plug-in de dispositivo NVIDIA para Kubernetes. ``` helm install nvdp nvdp/nvidia-device-plugin \ --namespace nvidia \ --create-namespace \ --set gfd.enabled=true ``` **Como desabilitar o MOFED em nós com dispositivos EFA** A partir da versão v0.19.0 do `k8s-device-plugin`, o sinalizador `--mofed-enabled` assume o valor `true` como padrão. Isso faz com que o plug-in de dispositivo da NVIDIA monte todos os dispositivos `/dev/infiniband/uverbs*` em contêineres que solicitam GPUs (`nvidia.com/gpu`). Isso gera um conflito com o plug-in de dispositivos EFA da AWS, que é o responsável por gerenciar a montagem dos dispositivos `uverbs`. As workloads que solicitam menos do que a totalidade dos dispositivos EFA em um nó são impactadas porque o plug-in de dispositivo da NVIDIA reivindica todos os dispositivos `uverbs` por padrão. Se os nós tiverem dispositivos EFA, desabilite explicitamente o MOFED ao instalar o plug-in de dispositivo da NVIDIA: ``` helm upgrade --install nvdp nvdp/nvidia-device-plugin \ --namespace nvidia \ --create-namespace \ --set gfd.enabled=true \ --set mofedEnabled=false ``` Se você gerencia o plug-in de dispositivo da NVIDIA por meio do [NVIDIA GPU Operator](https://github.com/NVIDIA/gpu-operator), desabilite o MOFED usando o campo `devicePlugin.env`: ``` helm upgrade --install gpu-operator nvidia/gpu-operator \ --namespace gpu-operator \ --set 'devicePlugin.env[0].name=MOFED_ENABLED' \ --set 'devicePlugin.env[0].value=false' ``` Para obter mais informações, acesse a página [NVIDIA k8s-device-plugin issue \#1692](https://github.com/NVIDIA/k8s-device-plugin/issues/1692). **nota** Você também pode instalar e gerenciar o plug-in de dispositivo NVIDIA para Kubernetes usando o [NVIDIA GPU Operator](https://github.com/NVIDIA/gpu-operator), que automatiza o gerenciamento de todos os componentes de software da NVIDIA necessários para provisionar GPUs. 1. Verifique se o DaemonSet do plug-in do dispositivo NVIDIA está em execução. ``` kubectl get ds -n nvidia nvdp-nvidia-device-plugin ``` ``` NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE nvdp-nvidia-device-plugin 2 2 2 2 2 60s ``` 1. Verifique se os seus nós possuem GPUs alocáveis. ``` kubectl get nodes "-o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia\.com/gpu" ``` Veja abaixo um exemplo de saída. ``` NAME GPU ip-192-168-11-225.us-west-2.compute.internal 1 ip-192-168-24-96.us-west-2.compute.internal 1 ``` ### Solicitar GPUs NVIDIA em um Pod Para solicitar GPUs da NVIDIA usando o plug-in de dispositivo, especifique o recurso `nvidia.com/gpu` em suas solicitações e limites de recursos do contêiner. ``` apiVersion: v1 kind: Pod metadata: name: nvidia-smi spec: restartPolicy: OnFailure containers: - name: gpu-demo image: public.ecr.aws/amazonlinux/amazonlinux:2023-minimal command: ["/bin/sh", "-c"] args: ["nvidia-smi && tail -f /dev/null"] resources: limits: nvidia.com/gpu: 1 requests: nvidia.com/gpu: 1 tolerations: - key: "nvidia.com/gpu" operator: "Equal" value: "true" effect: "NoSchedule" ``` Para executar este teste, aplique o manifesto e visualize os logs: ``` kubectl apply -f nvidia-smi.yaml kubectl logs nvidia-smi ``` Veja abaixo um exemplo de saída. ``` +-----------------------------------------------------------------------------------------+ | NVIDIA-SMI XXX.XXX.XX Driver Version: XXX.XXX.XX CUDA Version: XX.X | |-----------------------------------------+------------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA L4 On | 00000000:31:00.0 Off | 0 | | N/A 27C P8 11W / 72W | 0MiB / 23034MiB | 0% Default | | | | N/A | +-----------------------------------------+------------------------+----------------------+ +-----------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=========================================================================================| | No running processes found | +-----------------------------------------------------------------------------------------+ ```