Partilhar via

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

  • Artigo

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. O AKS suporta pools de nós Linux habilitados para 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 compatíveis com GPU

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

Nota

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 sua versão atual da API AKS para obter o comportamento padrão do canal de atualização do SO do nó.

Nota

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

  • NVadsA10 v5-series não são um SKU recomendado para GPU VHD.
  • Não há suporte para a atualização de um pool de nós existente para adicionar GPU.

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.0.64 ou posterior instalada e configurada. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

Obter as credenciais para o 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, instalação de driver de GPU e muito mais.

Nota

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 oferece suporte e gerencia isso. Enquanto os drivers NVidia são instalados por padrão em nós compatíveis com GPU, você precisa instalar o plug-in 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 ou a imagem de GPU AKS (visualização). Como alternativa, você pode instalar manualmente o plug-in de dispositivo NVIDIA.

Instale manualmente o plug-in do dispositivo NVIDIA

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

Para usar a SKU do sistema operacional padrão, crie o pool de nós sem especificar uma SKU do sistema operacional. O pool de nós é configurado para 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 autoscaler de cluster.
    • --min-count: Configura o autoscaler do cluster para manter um mínimo de um nó no pool de nós.
    • --max-count: Configura o autoscaler de cluster para manter um máximo de três nós no pool de nós.

    Nota

    Taints e tamanhos de VM só podem ser definidos para pools de nós durante a criação do pool de nós, mas você 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: kube-system
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.15.0
        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 (visualização)

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 manutenção e a compatibilidade dos drivers NVidia como parte da implantação da imagem do nó.

Importante

Os recursos de visualização do AKS estão disponíveis em uma base de autosserviço e opt-in. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do AKS são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço. Como tal, estas funcionalidades não se destinam a utilização em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

  1. Registre ou atualize a extensão aks-preview usando o az extension add comando or az extension update .

    # Register the aks-preview extension
az extension add --name aks-preview

# Update the aks-preview extension
az extension update --name aks-preview

  2. Crie um pool de nós usando o az aks nodepool add comando com o sinalizador para ignorar a --skip-gpu-driver-install instalação automática do driver de GPU.

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

    Adicionar o sinalizador durante a --skip-gpu-driver-install criação do pool de nós ignora a instalação automática do driver de GPU. Os nós existentes não são alterados. Você pode dimensionar o pool de nós para zero e, em seguida, fazer backup para que a alteração entre em vigor.

Use o operador de GPU NVIDIA com AKS

O Operador de GPU NVIDIA automatiza o gerenciamento de todos os componentes de software NVIDIA necessários para provisionar a GPU, incluindo a instalação do driver, o plug-in de dispositivo NVIDIA para Kubernetes, o tempo de execução do contêiner NVIDIA e muito mais. Como o operador da GPU lida com esses componentes, não é necessário instalar manualmente o plug-in do dispositivo NVIDIA. Isso também significa que a instalação automática do driver de GPU no AKS não é mais necessária.

  1. Ignore a instalação automática do driver de GPU criando um pool de nós usando o az aks nodepool add comando com --skip-gpu-driver-install. Adicionar o sinalizador durante a --skip-gpu-driver-install criação do pool de nós ignora a instalação automática do driver de GPU. Os nós existentes não são alterados. Você pode dimensionar o pool de nós para zero e, em seguida, fazer backup para que a alteração entre em vigor.

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

  3. Agora que você instalou com êxito o operador de GPU, você pode verificar se suas GPUs são escalonáveis e executar uma carga de trabalho de GPU.

Aviso

Não recomendamos a instalação manual do conjunto de daemon de plug-in de dispositivo NVIDIA com clusters usando a imagem da GPU AKS.

Nota

Pode haver considerações adicionais a serem tomadas ao usar o operador de GPU NVIDIA e implantar em instâncias SPOT. Veja https://github.com/NVIDIA/gpu-operator/issues/577

Usar a imagem da GPU AKS (visualização)

Nota

A imagem da GPU AKS (visualização) será desativada em 10 de janeiro de 2025. O cabeçalho personalizado usado abaixo não estará mais disponível, o que significa que você não poderá criar novos pools de nós habilitados para GPU usando a imagem da GPU AKS. Recomendamos migrar ou usar a configuração de GPU padrão em vez da imagem de GPU dedicada, pois a imagem de GPU dedicada 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.

O AKS fornece uma imagem AKS totalmente configurada contendo o plug-in de dispositivo NVIDIA para Kubernetes. A imagem da GPU AKS está atualmente disponível apenas no Ubuntu 18.04.

Importante

Os recursos de visualização do AKS estão disponíveis em uma base de autosserviço e opt-in. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do AKS são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço. Como tal, estas funcionalidades não se destinam a utilização em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

  1. Instale a aks-preview extensão da CLI do Azure usando o az extension add comando.

    az extension add --name aks-preview

  2. Atualize para a versão mais recente da extensão usando o az extension update comando.

    az extension update --name aks-preview

  3. Registre o GPUDedicatedVHDPreview sinalizador de recurso usando o az feature register comando.

    az feature register --namespace "Microsoft.ContainerService" --name "GPUDedicatedVHDPreview"

    Leva alguns minutos para que o status mostre Registrado.

  4. Verifique o status do registro usando o az feature show comando.

    az feature show --namespace "Microsoft.ContainerService" --name "GPUDedicatedVHDPreview"

  5. Quando o status refletir Registrado, atualize o registro do provedor de recursos Microsoft.ContainerService usando o az provider register comando.

    az provider register --namespace Microsoft.ContainerService

    Agora que você atualizou seu cluster para usar a imagem da GPU AKS, você pode adicionar um pool de nós para nós de GPU ao cluster.

  6. Adicione um pool de nós 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 \
    --aks-custom-headers UseGPUDedicatedVHD=true \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

    O comando de exemplo anterior 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.
    • --aks-custom-headers: Especifica uma imagem de GPU AKS especializada, UseGPUDedicatedVHD=true. Se o sku da GPU exigir VMs de 2ª geração, use --aks-custom-headers UseGPUDedicatedVHD=true,usegen2vm=true em vez disso.
    • --enable-cluster-autoscaler: Habilita o autoscaler de cluster.
    • --min-count: Configura o autoscaler do cluster para manter um mínimo de um nó no pool de nós.
    • --max-count: Configura o autoscaler de cluster para manter um máximo de três nós no pool de nós.

    Nota

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

  7. Agora que você criou com êxito um pool de nós usando a imagem da GPU, pode verificar se as GPUs são escalonáveis e executar uma carga de trabalho de GPU.

Confirme se as GPUs são escaloná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 habilitada para GPU

Para ver a GPU em ação, você pode agendar uma carga de trabalho habilitada para 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:

    Nota

    Se você 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", revise o gráfico de compatibilidade da matriz de driver 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

Use o Container Insights para monitorar o uso da GPU

O Container Insights com AKS monitora as seguintes métricas de uso de GPU:

Nome da métrica Dimensão métrica (tags) Description
containerGpuDutyCycle container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, gpuModel, gpuVendor Porcentagem de tempo durante o último período de amostra (60 segundos) durante o qual a GPU esteve ocupada/processando ativamente para um contêiner. O ciclo de trabalho é um número entre 1 e 100.
containerGpuLimits container.azm.ms/clusterId, container.azm.ms/clusterName, containerName Cada contêiner pode especificar limites como uma ou mais GPUs. Não é possível solicitar ou limitar uma fração de uma GPU.
containerGpuRequests container.azm.ms/clusterId, container.azm.ms/clusterName, containerName Cada contêiner pode solicitar uma ou mais GPUs. Não é possível solicitar ou limitar uma fração de uma GPU.
containerGpumemoryTotalBytes container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, gpuModel, gpuVendor Quantidade de memória GPU em bytes disponíveis para uso em um contêiner específico.
containerGpumemoryUsedBytes container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, gpuModel, gpuVendor Quantidade de memória GPU em bytes usada por um contêiner específico.
nodeGpuAllocatable container.azm.ms/clusterId, container.azm.ms/clusterName, gpuVendor Número de GPUs em um nó que podem ser usadas pelo Kubernetes.
nodeGpuCapacity container.azm.ms/clusterId, container.azm.ms/clusterName, gpuVendor Número total de GPUs em um nó.

Clean up resources (Limpar 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