Quickstart: Een op GPU gebaseerd Azure Kubernetes Service (AKS)-cluster maken met behulp van Azure CLI

Azure Kubernetes Service (AKS) is een beheerde Kubernetes-service die u kunt gebruiken om snel clusters te implementeren en te beheren. In deze snelstart leert u de volgende zaken:

  • Implementeer een AKS-cluster met behulp van Azure CLI.
  • Voeg een gpu-knooppuntgroep op basis van Linux toe waarvoor beheerde GPU-knooppunten zijn ingeschakeld.
  • Controleer of AKS de GPU-softwarestack voor planning heeft geïnstalleerd en geconfigureerd.

Volledig beheerde GPU-knooppunten zijn een preview-functie. Wanneer u beheerde GPU-knooppunten inschakelt, installeert en beheert AKS het NVIDIA GPU-stuurprogramma, de NVIDIA Kubernetes-apparaatinvoegtoepassing, de metrische gegevensexporteur van Data Center GPU Manager (DCGM) en gpu-statuscontroleonderdelen voor de GPU-knooppuntgroep. Beheerde GPU-knooppunten bevatten ook realtime GPU-metrieken voor opname door Azure Managed Prometheus en Azure Monitor managed service for Prometheus. Zie Een volledig beheerde GPU-knooppuntgroep maken op Azure Kubernetes Service (AKS) (preview) en GPU-waarneembaarheid in Azure Kubernetes Service (AKS) voor meer informatie.

Note

Dit artikel bevat stappen voor het implementeren van een cluster alleen voor evaluatiedoeleinden. Voordat u een cluster implementeert dat gereed is voor productie, moet u vertrouwd raken met de referentiearchitectuur van de basislijn om na te gaan hoe dit overeenkomt met uw bedrijfsvereisten.

Important

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

Voordat u begint

In deze snelstart wordt ervan uitgegaan dat u een basisbegrip hebt van Kubernetes-concepten. Zie Kubernetes-kernconcepten voor Azure Kubernetes Service (AKS) voor meer informatie.

  • Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

aks-preview De CLI-extensie installeren

Installeer de aks-preview CLI-extensie met behulp van de opdracht az extension add .

az extension add --name aks-preview

Werk de extensie bij om ervoor te zorgen dat u de nieuwste versie hebt met behulp van de opdracht az extension update .

az extension update --name aks-preview

De preview-functie registreren

Registreer de ManagedGPUExperiencePreview functievlag in uw abonnement met behulp van de opdracht az feature register .

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

Het duurt enkele minuten voordat de status Geregistreerd wordt weergegeven. Controleer de registratiestatus met behulp van de opdracht az feature show .

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

Wanneer de status Geregistreerd wordt weergegeven, vernieuwt u de registratie van de Microsoft.ContainerService resourceprovider met behulp van de opdracht az provider register .

az provider register --namespace Microsoft.ContainerService

Omgevingsvariabelen definiëren

Definieer de volgende omgevingsvariabelen voor gebruik in deze quickstart.

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"

De RANDOM_STRING variabele slaat een willekeurige tekenreeks van 10 cijfers op. De RESOURCE_GROUP en CLUSTER_NAME variabele waarden worden samengevoegd met de RANDOM_STRING waarde om unieke namen te maken. De GPU_NP variabele slaat de naam op voor de beheerde GPU-knooppuntgroep. De GPU_VM_SIZE variabele slaat de VM-grootte met GPU op voor de knooppuntgroep. De LOCATION variabele heeft de waarde westus. U kunt deze variabelewaarden gebruiken of uw eigen waarden maken. Gebruik de echo opdracht om variabele waarden weer te geven, zoals echo $RANDOM_STRING.

Een brongroep maken

Een Azure resourcegroep is een logische groep voor het implementeren en beheren van Azure resources. Wanneer u een resourcegroep maakt, geeft u een locatie op. Op deze locatie worden de metagegevens van de resourcegroep opgeslagen en waar uw resources worden uitgevoerd in Azure als u geen andere regio opgeeft tijdens het maken van resources.

Gebruik de opdracht az group create om een resourcegroep te maken.

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

In het volgende voorbeeld ziet u het resultaat.

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

Een AKS-cluster maken

Gebruik de opdracht az aks create om een AKS-cluster te maken. In het volgende voorbeeld wordt een cluster met één systeemknooppunt gemaakt en wordt een door het systeem toegewezen beheerde identiteit ingeschakeld.

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

Wanneer u een nieuw cluster maakt, maakt AKS automatisch een tweede resourcegroep om de AKS-resources op te slaan. Zie voor meer informatie Waarom worden er twee resourcegroepen gemaakt met AKS?

In het cluster in dit voorbeeld wordt een aantal van één knooppunt opgegeven om tijd en resources te besparen. Gebruik in een productieomgeving een aantal knooppunten van drie of meer knooppunten. De az aks create opdracht wordt standaard ingesteld op drie knooppunten als u geen aantal knooppunten opgeeft.

Een beheerde GPU-knooppuntgroep toevoegen

Voeg een op Linux gebaseerde beheerde GPU-knooppuntgroep toe aan uw cluster met behulp van de opdracht az aks nodepool add . De --enable-managed-gpu=true parameter configureert AKS voor het installeren en beheren van het NVIDIA GPU-stuurprogramma, nvidia Kubernetes-apparaatinvoegtoepassing, DCGM metrics exporter en GPU-statuscontroleonderdelen in de knooppuntgroep.

In het volgende voorbeeld wordt een beheerde GPU-knooppuntgroep toegevoegd met behulp van het standaardbesturingssysteem 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

Met --node-taints sku=gpu:NoSchedule de parameter blijven niet-GPU-workloads buiten de GPU-knooppuntgroep, tenzij de workloads een overeenkomende tolerantie bevatten.

Nadat u de knooppuntgroep hebt gemaakt, gebruikt u de opdracht az aks nodepool show om te bevestigen dat het beheerde GPU-profiel is ingeschakeld.

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

De uitvoer moet de volgende waarden bevatten.

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

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u de Kubernetes-opdrachtregelclient kubectl. Als u Azure Cloud Shell gebruikt, is kubectl al geïnstalleerd. Als u lokaal wilt installeren kubectl , gebruikt u de opdracht az aks install-cli .

  1. Configureer kubectl om verbinding te maken met uw Kubernetes-cluster met behulp van de opdracht az aks get-credentials . Met deze opdracht worden inloggegevens gedownload en wordt de Kubernetes-CLI geconfigureerd om deze te gebruiken.

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

  2. Controleer de verbinding met uw cluster met behulp van de opdracht kubectl get . Met deze opdracht wordt een lijst met de clusterknooppunten geretourneerd en wordt de knooppuntgroep voor elk knooppunt weergegeven.

    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. Controleer of Kubernetes GPU-workloads kan plannen in de beheerde GPU-knooppuntgroep.

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

    In de uitvoer ziet u het aantal toegewezen GPU's voor elk knooppunt in de beheerde GPU-knooppuntgroep.

    aks-gpunp-123456789-vmss000000  1

Verzameling van GPU-metrieken inschakelen

Beheerde GPU-knooppuntgroepen omvatten de dcGM-metrische gegevensexporteur. Als u de GPU-metrische gegevens wilt opnemen in Azure Beheerde Prometheus, schakelt u eerst Azure Monitor beheerde service voor Prometheus in uw AKS-cluster in. Maak vervolgens een ConfigMap waarmee het dcgmexporter scrapingprofiel in de Azure Monitor-agent wordt ingeschakeld.

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

Nadat u deze ConfigMap hebt toegepast, worden alle bestaande en nieuwe NVIDIA GPU-knooppuntgroepen in het cluster automatisch verwijderd. Zie GPU-waarneembaarheid in Azure Kubernetes Service (AKS) om metrische GPU-gegevens in Azure Managed Grafana weer te geven.

De toepassing implementeren

Implementeer een GPU-workload om te bevestigen dat de beheerde GPU-knooppuntgroep echte toepassingen kan uitvoeren. In dit voorbeeld wordt Ollama uitgevoerd, dat een klein opensource groot taalmodel (Llama 3.2 1B) bedient via een openAI-compatibele API. Ollama is gebouwd op llama.cpp, die de NVIDIA T4 GPU ondersteunt in de Standard_NC4as_T4_v3 knooppuntgroep die in deze quickstart wordt gebruikt.

In het volgende manifest wordt een Deployment en een Service gemaakt. De Deployment vragen één GPU aan (nvidia.com/gpu: 1), bevatten een toleratie voor de taint sku=gpu:NoSchedule en gebruiken een knooppuntselector om zich te richten op de beheerde GPU-knooppuntgroep. Wanneer de container wordt gestart, wordt de Ollama-server gestart en wordt het llama3.2:1b model opgehaald, zodat de pod klaar is om aanvragen te verwerken.

Implementeer de toepassing met behulp van de volgende opdracht.

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

Dit manifest is gericht op de gpunp knooppuntgroep. Als u een andere waarde voor de GPU_NP variabele hebt gebruikt, werkt u de waarde van de kubernetes.azure.com/agentpool knooppuntkiezer bij zodat deze overeenkomt voordat u het manifest toepast.

Controleer of de implementatie gereed is met behulp van de kubectl-implementatiestatusopdracht . Het downloaden van het eerste model kan enkele minuten duren.

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

Controleer of de pod wordt uitgevoerd in de beheerde GPU-knooppuntgroep met behulp van de opdracht kubectl get .

kubectl get pods -l app=ollama -o wide

In de uitvoer ziet u dat de pod draait op een knooppunt in de gpunp nodegroep.

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>

De toepassing testen

Stuur een lokale poort door naar de Service poort met behulp van de opdracht kubectl port-forward . Houd deze opdracht actief en open een tweede terminal voor de resterende stappen.

kubectl port-forward svc/ollama 11434:11434

Verzend in de tweede terminal een prompt naar het model met behulp van het OpenAI-compatibele eindpunt voor chatvoltooiingen.

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

Het model geeft een JSON-reactie terug die een gegenereerd antwoord bevat, waarmee wordt bevestigd dat de workload inferentie uitvoert via de beheerde GPU-nodegroep.

Controleer of het model is geladen op de GPU met behulp van de ollama ps opdracht. De PROCESSOR kolom toont 100% GPU wanneer het model op de T4 wordt uitgevoerd.

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

U kunt de GPU ook rechtstreeks vanuit de pod bekijken met behulp van de nvidia-smi opdracht.

kubectl exec deploy/ollama -- nvidia-smi

Wanneer u klaar bent met testen, stopt u het kubectl port-forward proces door Ctrl+C in de terminal te selecteren. De toepassing wordt verwijderd wanneer u het cluster in de volgende stap verwijdert.

Het cluster verwijderen

Als u niet van plan bent om de AKS-zelfstudie uit te voeren, moet u overbodige resources opschonen om Azure-factureringskosten te voorkomen. U kunt de resourcegroep, containerservice en alle gerelateerde resources verwijderen met behulp van de opdracht az group delete .

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

U hebt het AKS-cluster gemaakt met een door het systeem toegewezen beheerde identiteit. Dit is de standaardidentiteitsoptie die in deze quickstart wordt gebruikt. Het platform beheert deze identiteit, zodat u deze niet handmatig hoeft te verwijderen.

Volgende stappen 

In deze quickstart hebt u een Kubernetes-cluster geïmplementeerd en vervolgens een op Linux gebaseerde beheerde GPU-knooppuntgroep toegevoegd. Zie de volgende artikelen voor meer informatie over beheerde GPU-knooppunten en GPU-metrische gegevens:

Als u meer wilt weten over AKS en een volledig voorbeeld van code-naar-implementatie wilt uitvoeren, gaat u verder met de zelfstudie over het Kubernetes-cluster.

AKS-handleiding

  • Last updated on