Partilhar via

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

As unidades de processamento gráfico (GPUs) são frequentemente usadas para cargas de trabalho de computação intensiva, como cargas de trabalho gráficas e de visualização. AKS suporta pools de nós Linux com suporte a GPU para executar cargas de trabalho Kubernetes com uso intensivo de computação.

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

VMs suportadas com capacidade para GPU

Para exibir VMs habilitadas para GPU com suporte, consulte Tamanhos de VM otimizados para GPU no Azure. Para os agrupamentos de nós do AKS, recomendamos um tamanho mínimo de Standard_NC6s_v3. A série NVv4 (baseada em GPUs AMD) não é suportada no AKS.

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.

Limitações

  • Se você estiver usando um pool de nós habilitado para GPU Linux do Azure, os patches de segurança automáticos não serão aplicados. Consulte a versão da API AKS que está a utilizar para conhecer o comportamento padrão do canal de atualização do SO do nó.

Observação

Para a versão da API do AKS 2023-06-01 ou posterior, o canal padrão para a atualização do sistema operativo do nó é NodeImage. Para versões anteriores, o canal padrão é Nenhum. Para saber mais, consulte Atualização automática.

  • A atualização de um pool de nós existente para adicionar o tamanho da VM da GPU não é suportada no AKS.

Observação

A imagem da GPU AKS (visualização) é desativada a partir de 10 de janeiro de 2025. O cabeçalho personalizado não está mais disponível, o que significa que você não pode criar novos pools de nós habilitados para GPU usando a imagem da GPU AKS. Recomendamos migrar ou usar a configuração padrão da GPU em vez da imagem da GPU, pois a imagem da GPU não é mais suportada. Para obter mais informações, consulte as notas de lançamento do AKS ou veja este anúncio de aposentadoria em nosso roteiro público do AKS.

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.

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 myAKSCluster no grupo de recursos myResourceGroup :

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

Opções para usar GPUs NVIDIA

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

Observação

Por padrão, a Microsoft mantém automaticamente a versão dos drivers NVIDIA como parte da implantação da imagem do nó, e o AKS suporta e gerencia isso. Embora os drivers NVIDIA sejam instalados por padrão em nós capazes de GPU, é necessário instalar o plugin do dispositivo.

Instalação do plug-in de dispositivo NVIDIA

A instalação do plug-in de dispositivo NVIDIA é necessária ao usar GPUs no AKS. Em alguns casos, a instalação é processada automaticamente, como ao usar o operador de GPU NVIDIA. Como alternativa, você pode instalar manualmente o plug-in de dispositivo NVIDIA.

Instale manualmente o plug-in do dispositivo NVIDIA

Você pode implementar um DaemonSet para o plugin de dispositivo da NVIDIA, que executa um pod em cada nó para fornecer os drivers necessários às GPUs. Essa é a abordagem recomendada ao usar pools de nós habilitados para GPU para o Azure Linux.

Para usar o SKU padrão do sistema operativo, crie o pool de nós sem especificar o SKU do sistema operativo. O conjunto de nós é configurado para utilizar o sistema operacional padrão com base na versão do Kubernetes do cluster.

  1. Adicione um pool de nós ao cluster usando o az aks nodepool add comando.

    az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

    Este comando adiciona um pool de nós chamado gpunp a myAKSCluster em myResourceGroup e usa parâmetros para definir as seguintes configurações de pool de nós:

    • --node-vm-size: Define o tamanho da VM para o nó no pool de nós como Standard_NC6s_v3.
    • --node-taints: Especifica uma mancha sku=gpu:NoSchedule no pool de nós.
    • --enable-cluster-autoscaler: Habilita o escalonador automático de cluster.
    • --min-count: Configura o autoscaler do cluster para garantir pelo menos um nó no grupo de nós.
    • --max-count: Configura o escalador automático do cluster para manter um máximo de três nós no grupo de nós.

    Observação

    Taints e tamanhos de VM só podem ser definidos para pools de nós durante a criação do pool de nós. Contudo, pode atualizar as configurações do autoscaler a qualquer momento.

  1. Crie um namespace usando o kubectl create namespace comando.

    kubectl create namespace gpu-resources

  2. Crie um arquivo chamado nvidia-device-plugin-ds.yaml e cole o seguinte manifesto YAML fornecido como parte do plug-in de dispositivo NVIDIA para o projeto Kubernetes:

    apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nvidia-device-plugin-daemonset
  namespace: gpu-resources
spec:
  selector:
    matchLabels:
      name: nvidia-device-plugin-ds
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        name: nvidia-device-plugin-ds
    spec:
      tolerations:
      - key: "sku"
        operator: "Equal"
        value: "gpu"
        effect: "NoSchedule"
      # Mark this pod as a critical add-on; when enabled, the critical add-on
      # scheduler reserves resources for critical add-on pods so that they can
      # be rescheduled after a failure.
      # See https://kubernetes.io/docs/tasks/administer-cluster/guaranteed-scheduling-critical-addon-pods/
      priorityClassName: "system-node-critical"
      containers:
      - image: nvcr.io/nvidia/k8s-device-plugin:v0.17.2
        name: nvidia-device-plugin-ctr
        env:
          - name: FAIL_ON_INIT_ERROR
            value: "false"
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop: ["ALL"]
        volumeMounts:
        - name: device-plugin
          mountPath: /var/lib/kubelet/device-plugins
      volumes:
      - name: device-plugin
        hostPath:
          path: /var/lib/kubelet/device-plugins

  3. Crie o DaemonSet e confirme se o plug-in do dispositivo NVIDIA foi criado com sucesso usando o kubectl apply comando.

    kubectl apply -f nvidia-device-plugin-ds.yaml

  4. Agora que você instalou com sucesso o plug-in de dispositivo NVIDIA, você pode verificar se suas GPUs são escalonáveis e executar uma carga de trabalho de GPU.

Ignorar a instalação do driver da GPU

Se você quiser controlar a instalação dos drivers NVIDIA ou usar o operador de GPU NVIDIA, você pode ignorar a instalação do driver de GPU padrão. A Microsoft não oferece suporte nem gerencia a compatibilidade e manutenção dos drivers NVIDIA como parte do processo de implantação da imagem do nó.

Observação

O campo gpu-driver API é uma alternativa sugerida para clientes que utilizavam anteriormente a tag de pool de nós --skip-gpu-driver-install.

  • A --skip-gpu-driver-install tag do pool de nós no AKS será desativada em 14 de agosto de 2025. Para manter o comportamento existente de ignorar a instalação automática do driver de GPU, atualize seus pools de nós para a versão mais recente da imagem do nó e defina o --gpu-driver campo como none. Após 14 de agosto de 2025, não poderá provisionar pools de nós AKS habilitados para GPU com a etiqueta de pool de nós --skip-gpu-driver-install para ignorar este comportamento padrão. Para obter mais informações, consulte skip-gpu-driver Desativar tags.

  1. Crie um pool de nós usando o comando az aks nodepool add e defina o campo --gpu-driver para none para ignorar a instalação padrão do driver de GPU.

    az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --gpu-driver none \
    --node-vm-size Standard_NC6s_v3 \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

    Definir o campo API --gpu-driver como none durante a criação do pool de nós ignora a instalação automática do driver de GPU. Os nós que já existem não são alterados. Você pode dimensionar o pool de nós para zero e, em seguida, aumentar novamente para que a alteração entre em vigor.

    Se você receber o erro unrecognized arguments: --gpu-driver none , atualize a versão da CLI do Azure. Para obter mais informações, consulte Antes de começar.

  2. Opcionalmente, você pode instalar o operador de GPU NVIDIA seguindo estas etapas.

Confirme se as GPUs são agendáveis

Depois de criar seu cluster, confirme se as GPUs são escalonáveis no Kubernetes.

  1. Liste os nós no cluster usando o kubectl get nodes comando.

    kubectl get nodes

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

    NAME                   STATUS   ROLES   AGE   VERSION
aks-gpunp-28993262-0   Ready    agent   13m   v1.20.7

  2. Confirme se as GPUs são escalonáveis usando o kubectl describe node comando.

    kubectl describe node aks-gpunp-28993262-0

    Na seção Capacidade, a GPU deve listar como nvidia.com/gpu: 1. Sua saída deve ser semelhante à seguinte saída de exemplo condensada:

    Name:               aks-gpunp-28993262-0
Roles:              agent
Labels:             accelerator=nvidia

[...]

Capacity:
[...]
 nvidia.com/gpu:                 1
[...]

Executar uma carga de trabalho que utiliza GPU

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

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

    Observação

    Se receber um erro de incompatibilidade de versão ao chamar drivers, como "A versão do driver CUDA é insuficiente para a versão de tempo de execução CUDA", reveja a tabela de compatibilidade dos drivers NVIDIA.

    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:
           nvidia.com/gpu: 1
      restartPolicy: OnFailure
      tolerations:
      - key: "sku"
        operator: "Equal"
        value: "gpu"
        effect: "NoSchedule"

  2. 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

  1. 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

  2. Saia do kubectl --watch processo com Ctrl-C.

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

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

  4. Visualize a saída da carga de trabalho habilitada para GPU usando o kubectl logs comando.

    kubectl logs samples-tf-mnist-demo-smnr6

    O seguinte exemplo condensado de saída dos logs pod confirma que o dispositivo GPU apropriado, Tesla K80, foi descoberto:

    2019-05-16 16:08:31.258328: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
2019-05-16 16:08:31.396846: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Found device 0 with properties:
name: Tesla K80 major: 3 minor: 7 memoryClockRate(GHz): 0.8235
pciBusID: 2fd7:00:00.0
totalMemory: 11.17GiB freeMemory: 11.10GiB
2019-05-16 16:08:31.396886: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: Tesla K80, pci bus id: 2fd7:00:00.0, compute capability: 3.7)
2019-05-16 16:08:36.076962: I tensorflow/stream_executor/dso_loader.cc:139] successfully opened CUDA library libcupti.so.8.0 locally
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Extracting /tmp/tensorflow/input_data/train-images-idx3-ubyte.gz
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Extracting /tmp/tensorflow/input_data/train-labels-idx1-ubyte.gz
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Extracting /tmp/tensorflow/input_data/t10k-images-idx3-ubyte.gz
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting /tmp/tensorflow/input_data/t10k-labels-idx1-ubyte.gz
Accuracy at step 0: 0.1081
Accuracy at step 10: 0.7457
Accuracy at step 20: 0.8233
Accuracy at step 30: 0.8644
Accuracy at step 40: 0.8848
Accuracy at step 50: 0.8889
Accuracy at step 60: 0.8898
Accuracy at step 70: 0.8979
Accuracy at step 80: 0.9087
Accuracy at step 90: 0.9099
Adding run metadata for 99
Accuracy at step 100: 0.9125
Accuracy at step 110: 0.9184
Accuracy at step 120: 0.922
Accuracy at step 130: 0.9161
Accuracy at step 140: 0.9219
Accuracy at step 150: 0.9151
Accuracy at step 160: 0.9199
Accuracy at step 170: 0.9305
Accuracy at step 180: 0.9251
Accuracy at step 190: 0.9258
Adding run metadata for 199
[...]
Adding run metadata for 499

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