Guida introduttiva: Creare un cluster di Servizio Azure Kubernetes (AKS) basato su GPU linux usando interfaccia della riga di comando di Azure

Servizio Azure Kubernetes (AKS) è un servizio Kubernetes gestito che è possibile usare per distribuire e gestire rapidamente i cluster. In questa guida introduttiva si apprenderà come:

  • Distribuire un cluster AKS usando interfaccia della riga di comando di Azure.
  • Aggiungere un pool di nodi GPU basato su Linux con nodi GPU gestiti abilitati.
  • Verificare che AKS abbia installato e configurato lo stack software GPU per la pianificazione.

I nodi GPU completamente gestiti sono una funzionalità di anteprima. Quando si abilitano i nodi GPU gestiti, AKS installa e gestisce il driver GPU NVIDIA, il plug-in per dispositivi Kubernetes NVIDIA, l'esportatore di metriche di Data Center GPU Manager (DCGM) e i componenti di monitoraggio dello stato di integrità della GPU per il pool di nodi GPU. I nodi GPU gestiti integrano anche metriche GPU in tempo reale per l’acquisizione da parte di Azure Managed Prometheus e del servizio gestito per Prometheus di Monitoraggio di Azure. Per altre informazioni, vedere Creare un pool di nodi GPU completamente gestito in Servizio Azure Kubernetes (AKS) (anteprima) e l'osservabilità della GPU in Servizio Azure Kubernetes (AKS).

Note

Questo articolo include i passaggi per distribuire un cluster solo a scopo di valutazione. Prima di distribuire un cluster pronto per la produzione, acquisire familiarità con l'architettura di riferimento di base per valutare il modo in cui si allinea ai requisiti aziendali.

Importante

Le funzionalità in anteprima di AKS sono disponibili in modalità self-service, su base volontaria. Le anteprime vengono fornite "così come sono" e "come disponibili" e sono escluse dai contratti di servizio e dalla garanzia limitata. Le anteprime di AKS sono coperte solo parzialmente dall'assistenza clienti nei limiti del possibile. Di conseguenza, queste funzionalità non sono destinate all'uso in produzione. Per altre informazioni, vedere gli articoli di supporto seguenti:

Prima di iniziare

Questa guida introduttiva presuppone una comprensione di base dei concetti relativi a Kubernetes. Per altre informazioni, vedere Concetti di base relativi a Kubernetes per il servizio Azure Kubernetes.

Installare l'estensione CLI aks-preview

Installare l'estensione aks-preview CLI tramite il comando az extension add.

az extension add --name aks-preview

Aggiornare l'estensione per assicurarsi di avere la versione più recente usando il comando az extension update .

az extension update --name aks-preview

Registrare la funzionalità di anteprima

Registra il ManagedGPUExperiencePreview flag della funzionalità nella tua sottoscrizione usando il comando az feature register.

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

Sono necessari alcuni minuti per visualizzare lo stato Registered. Verificare lo stato della registrazione usando il comando az feature show.

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

Quando lo stato è Registrato, aggiornare la registrazione del Microsoft.ContainerService provider di risorse usando il comando az provider register .

az provider register --namespace Microsoft.ContainerService

Definire le variabili di ambiente

Definire le seguenti variabili di ambiente per l'utilizzo in questa introduzione rapida.

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"

La RANDOM_STRING variabile archivia una stringa casuale a 10 cifre. I valori delle RESOURCE_GROUP variabili e CLUSTER_NAME vengono concatenati con il RANDOM_STRING valore per creare nomi univoci. La GPU_NP variabile archivia il nome per il pool di nodi GPU gestito. La variabile GPU_VM_SIZE memorizza la dimensione della VM abilitata per GPU per il pool di nodi. La LOCATION variabile ha il valore westus. È possibile usare questi valori di variabile o crearne di personalizzati. Usare il echo comando per visualizzare i valori delle variabili, ad esempio echo $RANDOM_STRING.

Creare un gruppo di risorse

Un gruppo di risorse Azure è un gruppo logico per la distribuzione e la gestione delle risorse Azure. Quando si crea un gruppo di risorse, specificare una posizione. Questa posizione è la posizione in cui vengono archiviati i metadati del gruppo di risorse e dove vengono eseguite le risorse in Azure se non si specifica un'altra area durante la creazione della risorsa.

Usare il comando az group create per creare un gruppo di risorse.

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

Nell'esempio seguente viene illustrato il risultato.

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

Crea un cluster AKS

Usare il comando az aks create per creare un cluster del servizio Azure Kubernetes. L'esempio seguente crea un cluster con un nodo di sistema e abilita un'identità gestita assegnata dal sistema.

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

Quando si crea un nuovo cluster, il servizio Azure Kubernetes crea automaticamente un secondo gruppo di risorse per archiviare le risorse del servizio Azure Kubernetes. Per ulteriori informazioni, vedere Perché vengono creati due gruppi di risorse con AKS?

Il cluster in questo esempio specifica un numero di nodi di uno per risparmiare tempo e risorse. In un ambiente di produzione usare un numero di nodi di tre o più nodi. Il az aks create comando usa per impostazione predefinita tre nodi se non si specifica un numero di nodi.

Aggiungere un pool di nodi GPU gestito

Aggiungere un pool di nodi GPU gestito basato su Linux al cluster usando il comando az aks nodepool add . Il parametro --enable-managed-gpu=true configura AKS per installare e gestire il driver GPU NVIDIA, il plug-in del dispositivo Kubernetes NVIDIA, l'esportatore di metriche DCGM e i componenti di monitoraggio dello stato delle GPU nel pool di nodi.

L'esempio seguente aggiunge un pool di nodi GPU gestito usando il sistema operativo Ubuntu Linux predefinito.

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

Il --node-taints sku=gpu:NoSchedule parametro mantiene i carichi di lavoro non GPU dal pool di nodi GPU, a meno che i carichi di lavoro non includano una tollerazione corrispondente.

Dopo aver creato il pool di nodi, usare il comando az aks nodepool show per verificare che il profilo GPU gestito sia abilitato.

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

L'output deve includere i valori seguenti.

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

Connettersi al cluster

Per gestire un cluster Kubernetes, usare il client da riga di comando kubernetes kubectl. Se si usa Azure Cloud Shell, kubectl è già installato. Per installare kubectl in locale, usare il comando az aks install-cli.

  1. Configurare kubectl per connettersi al cluster Kubernetes usando il comando az aks get-credentials . Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

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

  2. Verificare la connessione al cluster usando il comando kubectl get . Questo comando restituisce un elenco dei nodi del cluster e mostra il pool di nodi per ogni nodo.

    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. Verificare che Kubernetes possa pianificare carichi di lavoro GPU nel pool di nodi GPU gestito.

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

    L'output mostra il numero di GPU allocabili per ogni nodo nel pool di nodi GPU gestito.

    aks-gpunp-123456789-vmss000000  1

Abilitare la raccolta delle metriche GPU

I pool di nodi GPU gestiti includono l'utilità di esportazione delle metriche DCGM. Per acquisire le metriche della GPU in Azure Managed Prometheus, abilita innanzitutto il servizio gestito per Prometheus di Monitoraggio di Azure nel tuo cluster AKS. Crea quindi un oggetto ConfigMap che abiliti il profilo di scraping dcgmexporter nell'agente di Monitoraggio di Azure.

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

Dopo aver applicato questo ConfigMap, tutti i pool di nodi GPU NVIDIA esistenti e nuovi nel cluster vengono raschiati automaticamente. Per visualizzare le metriche GPU in Grafana con gestione Azure, vedere Osservabilità della GPU in Servizio Azure Kubernetes (AKS).

Distribuire l'applicazione

Distribuire un carico di lavoro GPU per verificare che il pool di nodi GPU gestito possa eseguire applicazioni reali. Questo esempio esegue Ollama, che serve un piccolo modello linguistico open source (Llama 3.2 1B) tramite un'API compatibile con OpenAI. Ollama è basato su llama.cpp, che supporta la GPU NVIDIA T4 nel Standard_NC4as_T4_v3 pool di nodi usato da questa guida introduttiva.

Il manifesto seguente crea un Deployment oggetto e un oggetto Service. Il Deployment richiede una GPU (nvidia.com/gpu: 1), include una tolleranza per il taint sku=gpu:NoSchedule e usa un selettore di nodo per indirizzare il pool di nodi GPU gestito. All'avvio del contenitore, il contenitore avvia il server Ollama e scarica il modello llama3.2:1b in modo che il pod sia pronto a gestire le richieste.

Distribuire l'applicazione usando il comando seguente.

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

Questo manifest si applica al pool di nodi gpunp. Se è stato usato un valore diverso per la GPU_NP variabile, aggiornare il valore del kubernetes.azure.com/agentpool selettore del nodo in modo che corrisponda prima di applicare il manifesto.

Verificare che la distribuzione sia pronta usando il comando kubectl rollout status . Il download iniziale del modello può richiedere alcuni minuti.

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

Verificare che il pod sia in esecuzione nel pool di nodi GPU gestito usando il comando kubectl get .

kubectl get pods -l app=ollama -o wide

L'output dovrebbe mostrare il pod in esecuzione su un nodo nel pool di nodi 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>

Testare l'applicazione

Inoltrare una porta locale a Service usando il comando kubectl port-forward . Mantenere questo comando in esecuzione e aprire un secondo terminale per i passaggi rimanenti.

kubectl port-forward svc/ollama 11434:11434

Nel secondo terminale inviare un prompt al modello usando l'endpoint di completamento della chat compatibile con 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?"}]
  }'

Il modello restituisce una risposta JSON che contiene una risposta generata, confermando che il carico di lavoro esegue l'inferenza tramite il pool gestito di nodi GPU.

Verificare che il modello sia caricato nella GPU usando il ollama ps comando . La colonna PROCESSOR mostra 100% GPU quando il modello viene eseguito sulla 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

È anche possibile visualizzare la GPU direttamente dall'interno del pod usando il nvidia-smi comando .

kubectl exec deploy/ollama -- nvidia-smi

Al termine del test, arrestare il kubectl port-forward processo selezionando CTRL+C nel relativo terminale. L'applicazione viene rimossa quando si elimina il cluster nel passaggio successivo.

Eliminare il cluster

Se non si prevede di eseguire l'esercitazione AKS, rimuovere le risorse non necessarie per evitare addebiti per la fatturazione di Azure. È possibile rimuovere il gruppo di risorse, il servizio contenitore e tutte le risorse correlate usando il comando az group delete .

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

Hai creato il cluster AKS con un'identità gestita assegnata dal sistema, che è l'opzione di identità predefinita usata in questa guida introduttiva. Questa identità è gestita dalla piattaforma, pertanto non è necessario rimuoverla manualmente.

Passaggi successivi

In questa guida introduttiva è stato distribuito un cluster Kubernetes e quindi è stato aggiunto un pool di nodi GPU gestito basato su Linux. Per altre informazioni sui nodi GPU gestiti e sulle metriche GPU, vedere gli articoli seguenti:

Per ulteriori informazioni su AKS e per eseguire un esempio completo di code-to-deployment, proseguire con l'esercitazione sul cluster Kubernetes.

Esercitazione su AKS (Azure Kubernetes Service)

  • Last updated on