Quickstart: Criar um cluster Azure Kubernetes Service (AKS) baseado em GPU Linux usando CLI do Azure

Azure Kubernetes Service (AKS) é um serviço Kubernetes gerido que pode usar para implementar e gerir clusters rapidamente. Neste início rápido, vais aprender como:

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

Os nós totalmente geridos da GPU são uma funcionalidade de pré-visualização. Quando ativa nós de GPU geridos, o AKS instala e gere o controlador da GPU da NVIDIA, o plug-in de dispositivo do Kubernetes da NVIDIA, o exportador de métricas do Data Center GPU Manager (DCGM) e os componentes de monitorização do estado de funcionamento da GPU para o conjunto de nós de GPU. Os nós de GPU geridos também integram métricas de GPU em tempo real para ingestão no Azure Managed Prometheus e no serviço gerido do Azure Monitor para Prometheus. Para mais informações, veja Criar um pool de nós GPU totalmente gerido no Azure Kubernetes Service (AKS) (pré-visualização) e a observabilidade da GPU no Azure Kubernetes Service (AKS).

Note

Este artigo inclui passos para implementar um cluster apenas para fins de avaliação. Antes de implementar um cluster pronto para produção, familiarize-se com a arquitetura de referência base para considerar como esta se alinha com os requisitos do seu negócio.

Importante

As funcionalidades de pré-visualização do AKS estão disponíveis num regime de autosserviço e de adesão voluntária. 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 versões de pré-visualização do AKS são apenas parcialmente abrangidas pelo suporte ao cliente, na medida do possível. Assim sendo, estas funcionalidades não se destinam ao uso em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

Antes de começares

Este guia de iniciação rápida pressupõe uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, consulte Conceitos principais do Kubernetes para o Serviço Kubernetes do Azure (AKS).

Instalar a aks-preview extensão CLI

Instala a extensão da aks-preview CLI utilizando o comando az extension add.

az extension add --name aks-preview

Atualize a extensão para garantir que tem a versão mais recente usando o comando de atualização da extensão az .

az extension update --name aks-preview

Registe-se na funcionalidade de pré-visualização

Registe o sinalizador de funcionalidade ManagedGPUExperiencePreview na sua subscrição com o comando az feature register.

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

Leva alguns minutos para que o status mostre 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 estado mostrar Registado, atualize o registo do fornecedor de recursos Microsoft.ContainerService utilizando o comando az provider register.

az provider register --namespace Microsoft.ContainerService

Definir variáveis de ambiente

Defina as seguintes variáveis de ambiente para uso durante este 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 sequência 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 únicos. A GPU_NP variável armazena o nome do pool de nós da GPU gerida. A GPU_VM_SIZE variável armazena o tamanho da VM com GPU para o pool de nós. A LOCATION variável tem o valor westus. Pode usar estes valores variáveis ou criar os seus próprios. Use o echo comando para exibir valores de variáveis como echo $RANDOM_STRING.

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico para implementar e gerir recursos do Azure. Quando criares um grupo de recursos, especifica uma localização. Esta localização é onde os metadados do grupo de recursos são armazenados e onde os seus recursos correm no Azure caso não especifique outra região durante a criação dos recursos.

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

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

O exemplo seguinte 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

Utilize o comando az aks create para criar um cluster AKS. O exemplo seguinte cria um cluster com um nó de sistema e ativa uma identidade gerida 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, consulte Por que dois grupos de recursos são criados com o AKS?

O cluster neste exemplo especifica um número de nós de um para poupar tempo e recursos. Num ambiente de produção, utilize um número de nós igual ou superior a três. O az aks create comando por defeito tem três nós se não especificares a contagem de nós.

Adicionar um pool de nós de GPU gerido

Adicione um pool de nós de GPU geridos baseado no Linux ao seu cluster utilizando o comando az aks nodepool add. O parâmetro --enable-managed-gpu=true configura o AKS para instalar e gerir o controlador da GPU NVIDIA, o plug-in de dispositivo do Kubernetes da NVIDIA, o exportador de métricas do DCGM e os componentes de monitorização do estado da GPU no pool de nós.

O exemplo seguinte adiciona um pool de nós GPU gerido utilizando o sistema operativo Ubuntu Linux por defeito.

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 da GPU, a menos que as cargas de trabalho incluam uma tolerância correspondente.

Depois de criar o conjunto de nós, use o comando az aks nodepool show para confirmar que o perfil de GPU gerido está ativado.

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}"

A sua saída deve incluir os seguintes valores.

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

Ligar ao cluster

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

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

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

  2. Verifica a ligação ao teu cluster usando o comando kubectl get . Este comando devolve uma lista dos nós do 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 consegue programar cargas de trabalho de GPU no conjunto de nós GPU gerido.

    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 o número de GPUs alocáveis para cada nó no conjunto gerido de nós de GPU.

    aks-gpunp-123456789-vmss000000  1

Ativar a recolha de métricas da GPU

Pools de nós de GPU geridos incluem o exportador de métricas DCGM. Para integrar as métricas da GPU no Azure Managed Prometheus, ative primeiro o serviço gerido Azure Monitor para Prometheus no seu cluster AKS. Depois, crie um ConfigMap que ative o perfil de scraping 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 este ConfigMap, todos os grupos de nós com GPU NVIDIA, existentes e novos, no cluster são automaticamente recolhidos. Para visualizar métricas GPU em Azure Managed Grafana, veja a observabilidade GPU em Azure Kubernetes Service (AKS).

Implementar a aplicação

Implemente uma carga de trabalho da GPU para confirmar que o pool de nós da GPU gerida pode executar aplicações reais. Este exemplo corre o Ollama, que serve um pequeno modelo de linguagem open source (Llama 3.2 1B) através de uma API compatível com OpenAI. O Ollama baseia-se em llama.cpp, que suporta a GPU NVIDIA T4 no conjunto de nós Standard_NC4as_T4_v3 utilizado por este guia de início rápido.

O seguinte manifesto cria um Deployment e um Service. O Deployment solicita uma GPU (nvidia.com/gpu: 1), inclui uma tolerância para o taint sku=gpu:NoSchedule e usa um seletor de nós para direcionar para o pool de nós GPU gerido. Quando o contentor inicia, lança o servidor Ollama e puxa o llama3.2:1b modelo para que o pod esteja pronto para receber pedidos.

Implemente a aplicação usando o seguinte comando.

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 destina-se ao conjunto de nós gpunp. Se usou um valor diferente para a GPU_NP variável, atualize o kubernetes.azure.com/agentpool valor do seletor de nós para corresponder antes de aplicar o manifesto.

Confirme que a implementação está pronta usando o comando de estado de implementação do kubectl . O download inicial do modelo pode demorar alguns minutos.

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

Verifique que o pod está em execução no conjunto de nós de GPU gerido utilizando o comando kubectl get.

kubectl get pods -l app=ollama -o wide

O resultado deve mostrar o pod em execução num nó no conjunto 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 a aplicação

Encaminhe uma porta local para o Service usando o comando kubectl port-forward . Mantenha este comando ativo e abra um segundo terminal para os passos restantes.

kubectl port-forward svc/ollama 11434:11434

No segundo terminal, envie um prompt ao modelo usando o endpoint de conclusão de chat 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 devolve uma resposta JSON que contém uma resposta gerada, o que confirma que a carga de trabalho está a processar inferência a partir do conjunto de nós de GPU geridos.

Confirma que o modelo está carregado na GPU usando o ollama ps comando. A PROCESSOR coluna mostra 100% GPU quando o modelo corre 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

Também podes ver a GPU diretamente do interior do pod usando o nvidia-smi comando.

kubectl exec deploy/ollama -- nvidia-smi

Quando terminar o teste, pare o kubectl port-forward processo selecionando Ctrl+C no seu terminal. A aplicação é removida quando apagas o cluster no passo seguinte.

Eliminar o cluster

Se não planeias fazer o tutorial do AKS, limpa recursos desnecessários para evitar cobranças no Azure. Pode remover o grupo de recursos, o serviço de contentores e todos os recursos relacionados usando o comando delete do grupo az .

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

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

Passos seguintes

Neste quickstart, implementaste um cluster Kubernetes e depois adicionaste um pool de nós de GPU gerido baseado em Linux. Para mais informações sobre nós de GPU geridos 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 Kubernetes.

Tutorial do AKS

  • Última atualização a