Início Rápido: Criar um cluster de AKS (Serviço de Kubernetes do Azure) baseado em Linux da GPU usando CLI do Azure

AKS (Serviço de Kubernetes do Azure) é um serviço gerenciado do Kubernetes que você pode usar para implantar e gerenciar rapidamente clusters. Neste guia de início rápido, você aprende a:

  • Implante um cluster do AKS usando CLI do Azure.
  • Adicione um pool de nós de GPU baseado em Linux com nós de GPU gerenciados habilitados.
  • Verifique se o AKS instalou e configurou a pilha de software da GPU necessária para o agendamento.

Nós de GPU totalmente gerenciados são um recurso em versão prévia. Quando você habilita nós de GPU gerenciados, o AKS instala e gerencia o driver de GPU NVIDIA, o plug-in do dispositivo Kubernetes NVIDIA, o exportador de métricas do DCGM (Data Center GPU Manager) e os componentes de monitoramento de integridade da GPU para o pool de nós de GPU. Nós de GPU gerenciados também integram métricas de GPU em tempo real para ingestão pelo Azure Managed Prometheus e pelo serviço gerenciado para Prometheus do Azure Monitor. Para obter mais informações, consulte Criar um pool de nós de GPU totalmente gerenciado em AKS (Serviço de Kubernetes do Azure) (versão prévia) e observabilidade de GPU em AKS (Serviço de Kubernetes do Azure).

Note

Este artigo inclui etapas para implantar apenas um cluster para fins de avaliação. Antes de implantar um cluster pronto para produção, familiarize-se com a arquitetura de referência de linha de base para considerar como ele se alinha aos seus requisitos de negócios.

Importante

As funcionalidades em versão preliminar do AKS estão disponíveis de forma optativa e por autoatendimento. As versões prévias são fornecidas “no estado em que se encontram” e “conforme disponíveis” e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

Antes de começar

Este guia de início rápido pressupõe uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, confira Principais conceitos do Kubernetes para o AKS (Serviço de Kubernetes do Azure).

  • Se você ainda não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

Instalar a extensão da CLI aks-preview

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

az extension add --name aks-preview

Atualize a extensão para garantir que você tenha a versão mais recente usando o comando az extension update .

az extension update --name aks-preview

Registrar o recurso de visualização

Registre o ManagedGPUExperiencePreview sinalizador de funcionalidade na sua assinatura usando o comando az feature register.

az feature register --namespace Microsoft.ContainerService --name ManagedGPUExperiencePreview

Demora alguns minutos para o status mostrar Registrado. Verifique o status do registro usando o comando az feature show.

az feature show --namespace Microsoft.ContainerService --name ManagedGPUExperiencePreview --query properties.state

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

az provider register --namespace Microsoft.ContainerService

Definir variáveis de ambiente

Defina as variáveis de ambiente a seguir para uso ao longo deste início rápido.

export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
export RESOURCE_GROUP="myAKSResourceGroup$RANDOM_STRING"
export CLUSTER_NAME="myAKSCluster$RANDOM_STRING"
export GPU_NP="gpunp"
export GPU_VM_SIZE="Standard_NC4as_T4_v3"
export LOCATION="westus"

A RANDOM_STRING variável armazena uma cadeia de caracteres aleatória de 10 dígitos. Os valores das variáveis RESOURCE_GROUP e CLUSTER_NAME são concatenados com o valor RANDOM_STRING para criar nomes exclusivos. A GPU_NP variável armazena o nome do pool de nós de GPU gerenciado. A variável GPU_VM_SIZE armazena o tamanho da VM com suporte a GPU do pool de nós. A LOCATION variável tem o valor westus. Você pode usar esses valores de variável ou criar seus próprios. Use o echo comando para exibir valores variáveis como echo $RANDOM_STRING.

Criar um grupo de recursos

Um grupo de recursos Azure é um grupo lógico para implantar e gerenciar recursos Azure. Ao criar um grupo de recursos, especifique um local. Esse local é onde os metadados do grupo de recursos são armazenados e onde seus recursos são executados em Azure se você não especificar outra região durante a criação de recursos.

Use o comando az group create para criar um grupo de recursos.

az group create --name $RESOURCE_GROUP --location $LOCATION

O exemplo a seguir mostra o resultado.

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup<randomStringValue>",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup<randomStringValue>",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Criar um cluster do AKS

Use o comando az aks create para criar um cluster do AKS. O exemplo a seguir cria um cluster com um nó de sistema e habilita uma identidade gerenciada atribuída pelo sistema.

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --node-count 1 \
  --generate-ssh-keys

Quando você cria um novo cluster, o AKS cria automaticamente um segundo grupo de recursos para armazenar os recursos do AKS. Para obter mais informações, confira Por que dois grupos de recursos são criados com o AKS?

O cluster neste exemplo especifica uma contagem de nós de um para economizar tempo e recursos. Em um ambiente de produção, use uma contagem de nós de três ou mais nós. O az aks create comando usa como padrão três nós se você não especificar uma contagem de nós.

Adicionar um pool de nós de GPU gerenciado

Adicione um pool de nós de GPU gerenciado baseado em Linux ao cluster usando o comando az aks nodepool add . O parâmetro --enable-managed-gpu=true configura o AKS para instalar e gerenciar o driver de GPU da NVIDIA, o plug-in de dispositivo do Kubernetes da NVIDIA, o exportador de métricas DCGM e os componentes de monitoramento da integridade da GPU no pool de nós.

O exemplo a seguir adiciona um pool de nós de GPU gerenciado usando o sistema operacional Ubuntu Linux padrão.

az aks nodepool add \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $GPU_NP \
  --node-count 1 \
  --node-vm-size $GPU_VM_SIZE \
  --node-taints sku=gpu:NoSchedule \
  --enable-managed-gpu=true

O --node-taints sku=gpu:NoSchedule parâmetro mantém cargas de trabalho não GPU fora do pool de nós de GPU, a menos que as cargas de trabalho incluam uma tolerância correspondente.

Depois de criar o pool de nós, use o comando az aks nodepool show para confirmar se o perfil de GPU gerenciado está habilitado.

az aks nodepool show \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $GPU_NP \
  --query "{Name:name, Mode:mode, VmSize:vmSize, Taints:nodeTaints, GpuProfile:gpuProfile}"

Sua saída deve incluir os valores a seguir.

{
  "GpuProfile": {
    "driver": "Install",
    "driverType": "",
    "nvidia": {
      "managementMode": "Managed",
      "migStrategy": null
    }
  },
  "Mode": "User",
  "Name": "gpunp",
  "Taints": [
    "sku=gpu:NoSchedule"
  ],
  "VmSize": "Standard_NC4as_T4_v3"
}

Conectar-se ao cluster

Para gerenciar um cluster do Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl. Se você usar o Azure Cloud Shell, o kubectl já estará instalado. Para instalar o kubectl localmente, use o comando az aks install-cli.

  1. Configure kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials . Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.

    az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME

  2. Verifique a conexão com o cluster usando o comando obter kubectl . Esse comando retorna uma lista dos nós de cluster e mostra o pool de nós para cada nó.

    kubectl get nodes -L kubernetes.azure.com/agentpool,kubernetes.azure.com/mode

    NAME                                STATUS   ROLES    AGE     VERSION   AGENTPOOL   MODE
aks-nodepool1-123456789-vmss000000  Ready    <none>   20m     v1.34.4   nodepool1   system
aks-gpunp-123456789-vmss000000      Ready    <none>   5m36s   v1.34.4   gpunp       user

  3. Verifique se o Kubernetes pode agendar cargas de trabalho de GPU no pool de nós de GPU gerenciado.

    kubectl get nodes -l kubernetes.azure.com/agentpool=$GPU_NP -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.allocatable.nvidia\.com/gpu}{"\n"}{end}'

    A saída mostra a quantidade de GPUs alocáveis para cada nó no pool de nós de GPU gerenciado.

    aks-gpunp-123456789-vmss000000  1

Habilitar a coleção de métricas de GPU

Os pools de nós de GPU gerenciados incluem o exportador de métricas do DCGM. Para coletar as métricas de GPU no Prometheus Gerenciado do Azure, primeiro habilite o serviço gerenciado para Prometheus do Azure Monitor no seu cluster do AKS. Em seguida, crie um ConfigMap que habilite o perfil de raspagem dcgmexporter no agente do Azure Monitor.

cat <<EOF | kubectl create -f -
kind: ConfigMap
apiVersion: v1
data:
  schema-version:
    v1
  config-version:
    ver1
  default-scrape-settings-enabled: |-
    dcgmexporter = true
metadata:
  name: ama-metrics-settings-configmap
  namespace: kube-system
EOF

Depois de aplicar esse ConfigMap, todos os pools de nós de GPU NVIDIA existentes e novos no cluster serão raspados automaticamente. Para exibir as métricas de GPU em Espaço Gerenciado do Azure para Grafana, consulte a observabilidade da GPU em AKS (Serviço de Kubernetes do Azure).

Implantar o aplicativo

Implante uma carga de trabalho de GPU para confirmar se o pool de nós de GPU gerenciado pode executar aplicativos reais. Este exemplo executa o Ollama, que atende a um pequeno modelo de linguagem grande de software livre (Llama 3.2 1B) por meio de uma API compatível com OpenAI. O Ollama é desenvolvido com base em llama.cpp, que oferece suporte à GPU NVIDIA T4 no pool de nós Standard_NC4as_T4_v3 que este guia de início rápido utiliza.

O manifesto a seguir cria um Deployment e um Service. O Deployment solicita uma GPU (nvidia.com/gpu: 1), inclui uma tolerância para a mancha sku=gpu:NoSchedule e usa um seletor de nó para direcionar o pool de nós de GPU gerenciado. Quando o contêiner é iniciado, ele inicia o servidor Ollama e baixa o modelo llama3.2:1b para que o pod fique pronto para atender às solicitações.

Implante o aplicativo usando o comando a seguir.

cat <<'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
  labels:
    app: ollama
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      # Schedule onto the managed GPU node pool created in this quickstart.
      nodeSelector:
        kubernetes.azure.com/agentpool: gpunp
      # Tolerate the GPU node pool taint (sku=gpu:NoSchedule).
      tolerations:
        - key: "sku"
          operator: "Equal"
          value: "gpu"
          effect: "NoSchedule"
      containers:
        - name: ollama
          image: ollama/ollama:0.30.10
          ports:
            - name: http
              containerPort: 11434
          env:
            # Listen on all interfaces so the Service and kubelet probes can reach it.
            - name: OLLAMA_HOST
              value: "0.0.0.0:11434"
            # Model to pull and serve on startup. Fits comfortably on a 16-GB T4.
            - name: MODEL
              value: "llama3.2:1b"
          # Start the server, wait until it's ready, and then pull the model so the
          # pod is self-contained (no manual "ollama pull" step required).
          command: ["/bin/sh", "-c"]
          args:
            - |
              ollama serve &
              pid=$!
              echo "Waiting for the Ollama server to be ready..."
              until ollama list >/dev/null 2>&1; do sleep 2; done
              echo "Server ready. Pulling model: $MODEL"
              ollama pull "$MODEL" || echo "WARN: pull failed; run 'kubectl exec deploy/ollama -- ollama pull $MODEL' manually"
              echo "Model $MODEL is ready to serve."
              wait $pid
          resources:
            requests:
              cpu: "1"
              memory: 4Gi
            limits:
              cpu: "4"
              memory: 16Gi
              nvidia.com/gpu: 1
          startupProbe:
            httpGet:
              path: /api/tags
              port: http
            periodSeconds: 5
            failureThreshold: 60
          readinessProbe:
            httpGet:
              path: /api/tags
              port: http
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /
              port: http
            periodSeconds: 20
          volumeMounts:
            - name: ollama-data
              mountPath: /root/.ollama
      volumes:
        - name: ollama-data
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: ollama
  labels:
    app: ollama
spec:
  type: ClusterIP
  selector:
    app: ollama
  ports:
    - name: http
      port: 11434
      targetPort: http
EOF

Note

Este manifesto tem como alvo o conjunto de nós gpunp. Se você usou um valor diferente para a variável GPU_NP, atualize o valor do seletor de nó kubernetes.azure.com/agentpool para que corresponda antes de aplicar o manifesto.

Confirme se a implantação está pronta executando o comando kubectl rollout status. O download do modelo inicial pode levar alguns minutos.

kubectl rollout status deployment/ollama --timeout=600s

Verifique se o pod está em execução no pool de nós de GPU gerenciado usando o comando kubectl get .

kubectl get pods -l app=ollama -o wide

Sua saída deve mostrar o pod em execução em um nó no pool de nós gpunp.

NAME                      READY   STATUS    RESTARTS   AGE   IP            NODE                            NOMINATED NODE   READINESS GATES
ollama-5b8f6c9d4f-2xq7p   1/1     Running   0          5m    10.244.1.10   aks-gpunp-12345678-vmss000000   <none>           <none>

Testar o aplicativo

Encaminhe uma porta local para o Service usando o comando kubectl port-forward . Mantenha esse comando em execução e abra um segundo terminal para as etapas restantes.

kubectl port-forward svc/ollama 11434:11434

No segundo terminal, envie um prompt para o modelo ao usar o endpoint de chat completions compatível com OpenAI.

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:1b",
    "messages": [{"role": "user", "content": "In one sentence, what is Azure Kubernetes Service?"}]
  }'

O modelo retorna uma resposta JSON que contém uma resposta gerada, o que confirma que a carga de trabalho está processando inferência no pool de nós de GPU gerenciado.

Confirme se o modelo é carregado na GPU usando o ollama ps comando. A coluna PROCESSOR mostra 100% GPU quando o modelo é executado no T4.

kubectl exec deploy/ollama -- ollama ps

NAME          ID              SIZE      PROCESSOR    CONTEXT   UNTIL
llama3.2:1b   baf6a787fdff    1.5 GB    100% GPU     4096      4 minutes from now

Você também pode exibir a GPU diretamente de dentro do pod usando o nvidia-smi comando.

kubectl exec deploy/ollama -- nvidia-smi

Ao concluir o teste, interrompa o kubectl port-forward processo selecionando Ctrl+C em seu terminal. O aplicativo é removido quando você exclui o cluster na próxima etapa.

Excluir o cluster

Se você não planeja fazer o tutorial do AKS, limpe recursos desnecessários para evitar encargos de cobrança do Azure. Você pode remover o grupo de recursos, o serviço de contêiner e todos os recursos relacionados usando o comando az group delete .

az group delete --name $RESOURCE_GROUP --no-wait --yes

Você criou o cluster do AKS com uma identidade gerenciada atribuída pelo sistema, que é a opção de identidade padrão usada neste início rápido. A plataforma gerencia essa identidade para que você não precise removê-la manualmente.

Próximas Etapas 

Neste início rápido, você implantou um cluster kubernetes e adicionou um pool de nós de GPU gerenciado baseado em Linux. Para obter mais informações sobre nós de GPU gerenciados e métricas de GPU, consulte os seguintes artigos:

Para saber mais sobre o AKS e fazer um exemplo completo de código para implantação, continue para o tutorial do cluster do Kubernetes.

Tutorial do AKS

  • Last updated on