Usar GPUs AMD para cargas de trabalho de computação intensiva no Serviço Kubernetes do Azure (AKS)

Os tamanhos de máquina virtual (VM) de GPU AMD no Azure podem fornecer flexibilidade em desempenho e custo, oferecendo alta capacidade de computação e, ao mesmo tempo, permitindo que você escolha a configuração certa para seus requisitos de carga de trabalho. O AKS suporta pools de nós Linux habilitados para GPU AMD para executar cargas de trabalho Kubernetes com uso intensivo de computação.

Este artigo ajuda você a provisionar nós com GPUs AMD escalonáveis em clusters AKS novos e existentes.

Limitações

Atualmente, o AKS suporta o tamanho de VM do Standard_ND96isr_MI300X_v5 Azure com GPU AMD da série MI300.
A atualização de um pool de nós existente para adicionar um tamanho de VM GPU AMD não é suportada no AKS.
A atualização de um pool de nós habilitado para GPU não AMD com um tamanho de VM de GPU AMD não é suportada.
AzureLinux Windows, AzureLinuxOSGuarde flatcar não são compatíveis com GPU AMD.

Antes de começar

Este artigo pressupõe que você tenha um cluster AKS existente. Se você não tiver um cluster, crie um usando a CLI do Azure, o Azure PowerShell ou o portal do Azure.
Você precisa da CLI do Azure versão 2.72.2 ou posterior instalada para definir o --gpu-driver campo. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, consulte Install Azure CLI.
Se você tiver a extensão da CLI do aks-preview Azure instalada, atualize a versão para 18.0.0b2 ou posterior.

Observação

As VMs habilitadas para GPU contêm hardware especializado sujeito a preços mais altos e disponibilidade de região. Para obter mais informações, consulte a ferramenta de preços e a disponibilidade da região.

Obtenha as credenciais para o seu cluster

Obtenha as credenciais para o seu cluster AKS usando o az aks get-credentials comando. O comando de exemplo a seguir obtém as credenciais para o cluster myAKSCluster no grupo de myResourceGroup recursos:

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Opções para usar GPUs AMD

O uso de GPUs AMD envolve a instalação de vários componentes de software de GPU AMD, como o plug-in de dispositivo AMD para Kubernetes, drivers de GPU e muito mais.

Observação

Atualmente, o AKS não gerencia nem automatiza a instalação de drivers de GPU ou o plug-in de dispositivo AMD GPU em pools de nós habilitados para GPU AMD.

Registre o recurso AKSInfinibandSupport

Se o tamanho da sua VM GPU AMD estiver habilitado para RDMA com a convenção de nomenclatura r (por exemplo, Standard_ND96isr_MI300X_v5), terá de garantir que as máquinas no conjunto de nós fiquem na mesma rede física Infiniband. Para conseguir isso, registre o AKSInfinibandSupport sinalizador de recurso usando o az feature register comando:
```
az feature register --name AKSInfinibandSupport --namespace Microsoft.ContainerService
```

Verifique o status do registro usando o az feature show comando:

az feature show \
--namespace "Microsoft.ContainerService" \
--name AKSInfinibandSupport

Crie um pool de nós habilitado para GPU AMD usando o comando az aks nodepool add e ignore a instalação padrão do driver definindo o campo --gpu-driver para o valor none.
```
az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --node-vm-size Standard_ND96isr_MI300X_v5 \
    --gpu-driver none
```
Observação

Atualmente, o AKS impõe o uso do campo gpu-driver para ignorar a instalação automática do driver durante o tempo de criação do pool de nós da GPU AMD.

Deploie o operador de unidade de processamento gráfico AMD no AKS

O operador de GPU AMD automatiza o gerenciamento e a implantação de todos os componentes de software AMD necessários para provisionar a GPU, incluindo a instalação do driver, o plug-in do dispositivo AMD para Kubernetes, o tempo de execução do contêiner AMD e muito mais. Como o operador de GPU AMD lida com esses componentes, não é necessário instalar separadamente o plug-in de dispositivo AMD em seu cluster AKS. Isso também significa que a instalação automática do driver de GPU deve ser ignorada para usar o AMD GPU Operator no AKS.

Siga a documentação da AMD para instalar o operador da GPU.

Verifique o status das GPUs AMD no pool de nós usando o kubectl get nodes comando:

kubectl get nodes -o custom-columns=NAME:.metadata.name,GPUs:.status.capacity.'amd\.com/gpu'

Sua saída deve ser semelhante à saída de exemplo a seguir:

NAME                    STATUS   ROLES   AGE    VERSION
aks-gpunp-00000000      Ready    agent   2m4s   v1.31.7

Confirme que as GPUs AMD podem ser programadas

Depois de criar o pool de nós, confirme se as GPUs são escalonáveis no cluster AKS.

Liste os nós no cluster usando o kubectl get nodes comando.
```
kubectl get nodes
```
Confirme se as GPUs são escalonáveis usando o kubectl describe node comando.
```
kubectl describe node aks-gpunp-00000000
```
Na seção Capacidade, a GPU deve listar como amd.com/gpu: 1. Sua saída deve ser semelhante à seguinte saída de exemplo condensada:
```
Name:               aks-gpunp-00000000
Roles:              agent
Labels:             accelerator=amd

[...]

Capacity:
[...]
 amd.com/gpu:                 1
[...]
```

Executar uma carga de trabalho habilitada para GPU AMD

Para ver a GPU AMD em ação, pode-se agendar uma tarefa compatível com GPU com a solicitação de recurso apropriada. Neste exemplo, executaremos um trabalho Tensorflow no conjunto de dados MNIST.

Crie um arquivo chamado samples-tf-mnist-demo.yaml e cole o seguinte manifesto YAML, que inclui um limite de recursos de amd.com/gpu: 1:

apiVersion: batch/v1
kind: Job
metadata:
  labels:
    app: samples-tf-mnist-demo
  name: samples-tf-mnist-demo
spec:
  template:
    metadata:
      labels:
        app: samples-tf-mnist-demo
    spec:
      containers:
      - name: samples-tf-mnist-demo
        image: mcr.microsoft.com/azuredocs/samples-tf-mnist-demo:gpu
        args: ["--max_steps", "500"]
        imagePullPolicy: IfNotPresent
        resources:
          limits:
           amd.com/gpu: 1
      restartPolicy: OnFailure
      tolerations:
      - key: "sku"
        operator: "Equal"
        value: "gpu"
        effect: "NoSchedule"

Execute o trabalho usando o kubectl apply comando, que analisa o arquivo de manifesto e cria os objetos Kubernetes definidos.
```
kubectl apply -f samples-tf-mnist-demo.yaml
```

Exibir o status da carga de trabalho habilitada para GPU

Monitore o progresso do trabalho usando o kubectl get jobs comando com o --watch sinalizador. Pode levar alguns minutos para primeiro extrair a imagem e processar o conjunto de dados.
```
kubectl get jobs samples-tf-mnist-demo --watch
```
Quando a coluna COMPLETIONS mostra 1/1, o trabalho foi concluído com êxito, conforme mostrado na saída de exemplo a seguir:
```
NAME                    COMPLETIONS   DURATION   AGE

samples-tf-mnist-demo   0/1           3m29s      3m29s
samples-tf-mnist-demo   1/1   3m10s   3m36s
```
Saia do kubectl --watch processo com Ctrl-C.

Obtenha o nome do pod usando o kubectl get pods comando.

kubectl get pods --selector app=samples-tf-mnist-demo

Limpeza de recursos

Remova os objetos Kubernetes associados criados neste artigo usando o kubectl delete job comando.

kubectl delete jobs samples-tf-mnist-demo

Próximos passos

Explore as diferentes opções de armazenamento para a sua aplicação baseada em GPU no AKS.
Saiba mais sobre clusters Ray no AKS.
Utilize as suas GPUs NVIDIA para cargas de trabalho de computação intensiva no AKS.

Feedback

Esta página foi útil?

Last updated on 2025-06-21