Snabbstart: Skapa ett GPU Linux-baserat Azure Kubernetes Service (AKS) kluster med Azure CLI

Azure Kubernetes Service (AKS) är en hanterad Kubernetes-tjänst som du kan använda för att snabbt distribuera och hantera kluster. I den här snabbstarten lär du dig att:

  • Distribuera ett AKS-kluster med hjälp av Azure CLI.
  • Lägg till en Linux-baserad GPU-nodpool med hanterade GPU-noder aktiverade.
  • Kontrollera att AKS har installerat och konfigurerat GPU-programvarustacken för schemaläggning.

Fullständigt hanterade GPU-noder är en förhandsversionsfunktion. När du aktiverar hanterade GPU-noder installerar och hanterar AKS NVIDIA GPU-drivrutinen, NVIDIA Kubernetes-enhetsinsticksprogrammet, DCGM-måttexportören (Data Center GPU Manager) och GPU-hälsoövervakningskomponenter för GPU-nodpoolen. Hanterade GPU-noder integrerar även GPU-mått i realtid för inmatning i Azure Managed Prometheus och Azure Monitor hanterad tjänst för Prometheus. Mer information finns i Skapa en fullständigt hanterad GPU-nodpool på Azure Kubernetes Service (AKS) (förhandsversion) och GPU-observerbarhet i Azure Kubernetes Service (AKS).

Note

Den här artikeln innehåller steg för att distribuera ett kluster endast i utvärderingssyfte. Innan du distribuerar ett produktionsklart kluster bör du bekanta dig med referensarkitekturen för baslinjen för att överväga hur den överensstämmer med dina affärskrav.

Important

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och frivillig registrering. Förhandsversioner tillhandahålls "i befintligt skick" och "i mån av tillgång," och de är undantagna från servicenivåavtal och begränsad garanti. AKS-förhandsversioner stöds delvis av kundsupport efter bästa förmåga. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

Innan du börjar

Den här snabbstarten förutsätter grundläggande kunskaper om Kubernetes-begrepp. Mer information finns i Kubernetes grundläggande begrepp för Azure Kubernetes Service (AKS).

Installera CLI-tillägget aks-preview

aks-preview Installera CLI-tillägget med hjälp av kommandot az extension add.

az extension add --name aks-preview

Uppdatera tillägget så att du har den senaste versionen med hjälp av kommandot az extension update .

az extension update --name aks-preview

Registrera förhandsgranskningsfunktionen

Registrera funktionsflaggan ManagedGPUExperiencePreview i din prenumeration med kommandot az feature register .

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

Det tar några minuter för statusen att visa Registrerad. Kontrollera registreringsstatusen med kommandot az feature show .

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

När statusen visas Registrerad uppdaterar du registreringen av Microsoft.ContainerService resursprovidern med hjälp av kommandot az provider register .

az provider register --namespace Microsoft.ContainerService

Definiera miljövariabler

Definiera följande miljövariabler för användning under den här snabbstarten.

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"

Variabeln RANDOM_STRING lagrar en slumpmässig 10-siffrig sträng. Värdena RESOURCE_GROUP och CLUSTER_NAME variabeln sammanfogas med värdet RANDOM_STRING för att skapa unika namn. Variabeln GPU_NP lagrar namnet på den hanterade GPU-nodpoolen. Variabeln GPU_VM_SIZE lagrar den GPU-aktiverade VM-storleken för nodpoolen. Variabeln LOCATION har värdet westus. Du kan använda dessa variabelvärden eller skapa egna. echo Använd kommandot för att visa variabelvärden som echo $RANDOM_STRING.

Skapa en resursgrupp

En Azure resursgrupp är en logisk grupp för att distribuera och hantera Azure resurser. När du skapar en resursgrupp anger du en plats. Den här platsen är platsen där resursgruppens metadata lagras och där dina resurser körs i Azure om du inte anger någon annan region när du skapar resurser.

Använd kommandot az group create för att skapa en resursgrupp.

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

I följande exempel visas resultatet.

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

Skapa ett AKS-kluster

Använd kommandot az aks create för att skapa ett AKS-kluster. I följande exempel skapas ett kluster med en systemnod och en systemtilldelad hanterad identitet aktiveras.

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

När du skapar ett nytt kluster skapar AKS automatiskt en andra resursgrupp för att lagra AKS-resurserna. Mer information finns i Varför skapas två resursgrupper med AKS?

Klustret i det här exemplet anger ett nodantal på ett för att spara tid och resurser. I en produktionsmiljö använder du ett nodantal på tre eller flera noder. Kommandot az aks create är som standard tre noder om du inte anger ett nodantal.

Lägga till en hanterad GPU-nodpool

Lägg till en Linux-baserad hanterad GPU-nodpool i klustret med hjälp av kommandot az aks nodepool add . Parametern --enable-managed-gpu=true konfigurerar AKS för att installera och hantera NVIDIA GPU-drivrutinen, NVIDIA Kubernetes-enhetspluginet, exporteraren för DCGM-mått och komponenter för GPU-hälsoövervakning på nodpoolen.

I följande exempel läggs en hanterad GPU-nodpool till med hjälp av standardoperativsystemet Ubuntu Linux.

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

Parametern --node-taints sku=gpu:NoSchedule håller icke-GPU-arbetsbelastningar borta från GPU-nodpoolen om inte arbetsbelastningarna innehåller en matchande tolerans.

När du har skapat nodpoolen använder du kommandot az aks nodepool show för att bekräfta att den hanterade GPU-profilen är aktiverad.

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

Dina utdata bör innehålla följande värden.

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

Anslut till klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. Om du använder Azure Cloud Shell är kubectl redan installerat. Om du vill installera kubectl lokalt använder du kommandot az aks install-cli .

  1. Konfigurera kubectl för att ansluta till kubernetes-klustret med kommandot az aks get-credentials . Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

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

  2. Kontrollera anslutningen till klustret med hjälp av kommandot kubectl get . Det här kommandot returnerar en lista över klusternoderna och visar nodpoolen för varje nod.

    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. Kontrollera att Kubernetes kan schemalägga GPU-arbetsbelastningar i den hanterade GPU-nodpoolen.

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

    Utdata visar det allokerbara GPU-antalet för varje nod i den hanterade GPU-nodpoolen.

    aks-gpunp-123456789-vmss000000  1

Aktivera GPU-måttsamling

Hanterade GPU-nodpooler innehåller DCGM-måttexportören. Om du vill mata in GPU-måtten i Azure Managed Prometheus aktiverar du först Azure Monitor hanterad tjänst för Prometheus i ditt AKS-kluster. Skapa sedan en ConfigMap som aktiverar dcgmexporter skrapningsprofilen i Azure Monitor-agenten.

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

När du har tillämpat den här ConfigMap skrapas alla befintliga och nya NVIDIA GPU-nodpooler i klustret automatiskt. Information om hur du visar GPU-mått i Azure Managed Grafana finns i GPU-observerbarhet i Azure Kubernetes Service (AKS).

Distribuera programmet

Distribuera en GPU-arbetsbelastning för att bekräfta att den hanterade GPU-nodpoolen kan köra verkliga program. Det här exemplet kör Ollama, som hanterar en liten stor språkmodell med öppen källkod (Llama 3.2 1B) via ett OpenAI-kompatibelt API. Ollama bygger på llama.cpp, som stöder NVIDIA T4 GPU i nodpoolen som den här snabbstarten Standard_NC4as_T4_v3 använder.

Följande manifest skapar en Deployment och en Service. Deployment begär en GPU (nvidia.com/gpu: 1), innehåller en tolerans för nedsmutsningen sku=gpu:NoSchedule och använder en nodväljare för att välja den hanterade GPU-nodpoolen. När containern startar startar den Ollama-servern och hämtar llama3.2:1b modellen så att podden är redo att hantera begäranden.

Distribuera programmet med hjälp av följande kommando.

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

Det här manifestet riktar sig till nodpoolen gpunp . Om du använde ett annat värde för variabeln GPU_NP uppdaterar du värdet för nodväljaren så att det kubernetes.azure.com/agentpool matchar innan du tillämpar manifestet.

Bekräfta att distributionen är klar med hjälp av kommandot för kubectl-distributionsstatus . Den inledande modellnedladdningen kan ta några minuter.

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

Kontrollera att podden körs i den hanterade GPU-nodpoolen med hjälp av kommandot kubectl get .

kubectl get pods -l app=ollama -o wide

Dina utdata bör visa podden som körs på en nod i nodpoolen 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>

Testa programmet

Vidarebefordra en lokal port till Service med kommandot kubectl port-forward . Håll det här kommandot igång och öppna en andra terminal för de återstående stegen.

kubectl port-forward svc/ollama 11434:11434

I den andra terminalen skickar du en prompt till modellen med hjälp av den OpenAI-kompatibla slutpunkten för chattkompletteringar.

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?"}]
  }'

Modellen returnerar ett JSON-svar som innehåller ett genererat svar som bekräftar att arbetsbelastningen levererar inferens från den hanterade GPU-nodpoolen.

Bekräfta att modellen har lästs in på GPU:n med hjälp ollama ps av kommandot . Kolumnen PROCESSOR visar 100% GPU när modellen körs på 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

Du kan också visa GPU:n direkt inifrån podden genom att använda kommandot nvidia-smi.

kubectl exec deploy/ollama -- nvidia-smi

När du är klar med testningen kubectl port-forward stoppar du processen genom att välja Ctrl+C i terminalen. Programmet tas bort när du tar bort klustret i nästa steg.

Ta bort klustret

Om du inte planerar att göra AKS-självstudien rensar du onödiga resurser för att undvika Azure-faktureringsavgifter. Du kan ta bort resursgruppen, containertjänsten och alla relaterade resurser med kommandot az group delete .

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

Du skapade AKS-klustret med en systemtilldelad hanterad identitet, vilket är standardalternativet för identitet som används i den här snabbstarten. Plattformen hanterar den här identiteten så att du inte behöver ta bort den manuellt.

Nästa steg

I den här snabbstarten distribuerade du ett Kubernetes-kluster och lade sedan till en Linux-baserad hanterad GPU-nodpool. Mer information om hanterade GPU-noder och GPU-mått finns i följande artiklar:

Fortsätt till självstudiehandledningen för Kubernetes-klustret för att lära dig mer om AKS och göra ett komplett exempel från kod till distribution.

Självstudiekurs om AKS

  • Last updated on