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

As unidades de processamento gráfico (GPU) geralmente são usadas para cargas de trabalho de computação intensiva, tais como gráficos e cargas de trabalho de visualização. O AKS dá suporte a pools de nós Linux habilitados para GPU para executar cargas de trabalho do Kubernetes com uso intensivo de computação.

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

VMs habilitadas para GPU com suporte

Para exibir as VMs habilitadas para GPU disponíveis, consulte os tamanhos de VM com otimização de GPU no Azure. Se um tamanho de VM de GPU não estiver em nossa lista de tamanhos de VM com suporte, o AKS não instalará os componentes de software de GPU necessários nem fornecerá suporte. O AKS permite o uso de tamanhos de VM de GPU sem suporte após ignorar a instalação automática do driver de GPU.

Verifique os tamanhos de VM disponíveis e compatíveis usando o az vm list-skus comando.

az vm list-skus --location <your-location> --output table

Para pools de nós do AKS, é recomendável um tamanho mínimo de Standard_NC6s_v3. A série NVv4 (baseada em GPUs AMD) não tem suporte no AKS.

Limitações

• Se você estiver usando um pool de nós habilitado para GPU do Linux no Azure, os patches de segurança automáticos não serão aplicados. Veja a versão atual da API do AKS para conhecer o comportamento padrão do canal de atualização do sistema operacional do nó.
• Flatcar Container Linux para AKS não é compatível com GPU NVIDIA no AKS.
• Não há suporte para o Azure Linux com proteção de SO para AKS com GPU NVIDIA no AKS.

• Não há suporte para a atualização de um pool de nós existente para adicionar o tamanho da VM de GPU no AKS.

Antes de começar

• Este artigo considera que você tenha um cluster do AKS. Se você não tiver um cluster, crie um usando a CLI do Azure, 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. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.
• Se você tiver a extensão da CLI do aks-preview Azure instalada, atualize a versão para 18.0.0b2 ou posterior.

Obter as credenciais para o cluster

Obtenha as credenciais do cluster do AKS usando o comando az aks get-credentials. O seguinte comando de exemplo 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 do driver de GPU e muito mais.

Instalação do plug-in do dispositivo NVIDIA

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

Instalar manualmente o plug-in do dispositivo NVIDIA

Você pode implantar um DaemonSet para o plug-in do 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.

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

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

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

   kubectl create namespace gpu-resources
   

2. Crie um arquivo nomeado nvidia-device-plugin-ds.yaml e cole o seguinte manifesto YAML fornecido como parte do plug-in do 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.18.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 é criado com sucesso usando o comando kubectl apply.

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

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

Ignorar a instalação do driver de GPU

Se você quiser controlar a instalação dos drivers NVIDIA ou usar o Operador de GPU NVIDIA, ignore a instalação padrão do driver de GPU. A Microsoft não dá suporte nem gerencia a manutenção e a compatibilidade dos drivers NVIDIA como parte da implantação da imagem do cluster.

1. Crie um pool de nós usando o comando az aks nodepool add e defina o campo --gpu-driver para none, a fim de 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 de 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 existentes não são alterados. Você pode dimensionar o pool de nós para zero e fazer backup para fazer a alteração entrar 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.

Confirmar se as GPUs são agendáveis

Após criar seu cluster, confirme que as GPUs são agendáveis no Kubernetes.

1. Listar os nós em seu cluster usando o comando kubectl get nodes.

   kubectl get nodes
   

   Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

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

   kubectl describe node aks-gpunp-28993262-0
   

   Na seção Capacidade, a GPU deve ser listada como nvidia.com/gpu: 1. Seu resultado deve ser semelhante ao seguinte exemplo de saída condensado:

   Name:               aks-gpunp-28993262-0
   Roles:              agent
   Labels:             accelerator=nvidia
   
   [...]
   
   Capacity:
   [...]
    nvidia.com/gpu:                 1
   [...]
   

Executar uma carga de trabalho com suporte a GPU

Para ver a GPU em ação, você pode agendar uma tarefa que usa GPU com a solicitação de recursos apropriada. Neste exemplo, vamos executar um trabalho do Tensorflow contra o conjunto de dados do MNIST.

1. Crie um arquivo nomeado 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 você receber um erro de incompatibilidade de versão durante uma chamada de drivers, como “A versão do driver CUDA é insuficiente para a versão de runtime CUDA”, confira o gráfico de compatibilidade da matriz de 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 comando kubectl apply, que analisa o arquivo de manifesto e cria os objetos definidos do Kubernetes.

   kubectl apply -f samples-tf-mnist-demo.yaml
   

Exibir o status da carga de trabalho habilitada para GPU

1. Monitore o andamento do trabalho usando o comando kubectl get jobs com o sinalizador --watch. Poderá levar alguns minutos para baixar pela primeira vez 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 sucesso, conforme mostrado no exemplo de saída 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 processo kubectl --watch com Ctrl-C.

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

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

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

   kubectl logs samples-tf-mnist-demo-smnr6
   

   O exemplo de saída condensado dos logs de pod a seguir 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
   

Atualizando um pool de nós

Se você quiser atualizar ou atualizar os pools de nós, poderá observar que não há parâmetro --gpu-driver para nenhuma das operações. Você pode encontrar um erro como unrecognized arguments: --gpu-driver none se tentasse passar o parâmetro. Não é necessário chamar o parâmetro, pois o valor não é afetado por tais operações.

Quando você cria seu pool de nós pela primeira vez, qualquer parâmetro declarado para --gpu-driver não será afetado pelas operações de atualização/melhoria. Se você não quiser que nenhum driver seja instalado e selecionou --gpu-driver None ao criar seu pool de nós, os drivers não serão instalados em atualizações ou atualizações subsequentes.

Limpar os recursos

Remova os objetos do Kubernetes associados que você criou neste artigo usando o comando kubectl delete job.

kubectl delete jobs samples-tf-mnist-demo

Próximas etapas

• Para executar trabalhos do Apache Spark, confira Executar trabalhos do Apache Spark no AKS.
• Para obter mais informações sobre os recursos do agendador do Kubernetes, confira Melhores práticas de recursos avançados do agendador no AKS.
• Para mais informações sobre o Serviço de Kubernetes do Azure e Azure Machine Learning, consulte:
  • Configure um cluster do Kubernetes para treinamento ou implantação de modelo de ML.
  • Implantar um modelo com um endpoint online.
  • Serviço de alto desempenho com o servidor de inferência Triton.
  • Laboratórios para Kubernetes e Kubeflow.