Schnellstart: Erstellen eines GPU Linux-basierten Azure Kubernetes Service (AKS)-Clusters mithilfe von Azure CLI

Azure Kubernetes Service (AKS) ist ein verwalteter Kubernetes-Dienst, mit dem Sie Cluster schnell bereitstellen und verwalten können. In dieser Schnellstartanleitung erfahren Sie, wie Sie:

  • Stellen Sie einen AKS-Cluster mithilfe von Azure CLI bereit.
  • Fügen Sie einen Linux-basierten GPU-Knotenpool mit aktivierten verwalteten GPU-Knoten hinzu.
  • Stellen Sie sicher, dass AKS den GPU-Softwarestapel für die Planung installiert und konfiguriert hat.

Vollverwaltete GPU-Knoten sind eine Vorschaufunktion. Wenn Sie verwaltete GPU-Knoten aktivieren, installiert und verwaltet AKS den NVIDIA GPU-Treiber, NVIDIA Kubernetes-Geräte-Plug-In, Data Center GPU Manager (DCGM)-Metrikexporteur und GPU-Integritätsüberwachungskomponenten für den GPU-Knotenpool. Verwaltete GPU-Knoten integrieren auch GPU-Echtzeitmetriken zur Erfassung in Azure Managed Prometheus und den verwalteten Dienst für Prometheus in Azure Monitor. Weitere Informationen finden Sie unter Erstellen eines vollständig verwalteten GPU-Knotenpools auf Azure Kubernetes Service (AKS) (Vorschau) und GPU-Observierbarkeit in Azure Kubernetes Service (AKS).

Note

Dieser Artikel enthält Schritte zum Bereitstellen eines Clusters nur zu Auswertungszwecken. Bevor Sie einen produktionsbereiten Cluster bereitstellen, machen Sie sich mit der basisbasierten Referenzarchitektur vertraut, um zu berücksichtigen, wie sie ihren Geschäftlichen Anforderungen entspricht.

Important

AKS-Preview-Funktionen stehen auf Selbstbedienungs- und Opt-in-Basis zur Verfügung. Vorschauversionen werden „im Istzustand“ und „wie verfügbar“ bereitgestellt und sind von den Service Level Agreements und der eingeschränkten Garantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Bevor Sie anfangen

Für diese Schnellstartanleitung werden Grundkenntnisse in Bezug auf die Kubernetes-Konzepte vorausgesetzt. Weitere Informationen finden Sie unter Kubernetes-Kernkonzepte für Azure Kubernetes Service (AKS).

  • Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

Installieren Sie die aks-preview-Erweiterung für die Befehlszeilenschnittstelle

Installieren Sie die aks-preview CLI-Erweiterung mithilfe des Befehls "az extension add" .

az extension add --name aks-preview

Aktualisieren Sie die Erweiterung, um sicherzustellen, dass Sie über die neueste Version verfügen, indem Sie den Befehl "az extension update" verwenden.

az extension update --name aks-preview

Registrieren des Vorschaufeatures

Registrieren Sie das ManagedGPUExperiencePreview Feature-Flag in Ihrem Abonnement mithilfe des Befehls "az feature register" .

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

Es dauert einige Minuten, bis der Status Registered (Registriert) angezeigt wird. Überprüfen Sie den Registrierungsstatus mithilfe des Befehls az feature show.

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

Wenn der Status "Registriert" angezeigt wird, aktualisieren Sie die Registrierung des Microsoft.ContainerService Ressourcenanbieters mithilfe des Befehls " az provider register" .

az provider register --namespace Microsoft.ContainerService

Definieren von Umgebungsvariablen

Definieren Sie die folgenden Umgebungsvariablen für die verwendung in dieser Schnellstartanleitung.

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"

Die RANDOM_STRING Variable speichert eine zufällige 10-stellige Zeichenfolge. Die RESOURCE_GROUP Werte und CLUSTER_NAME Variablen werden mit dem RANDOM_STRING Wert verkettet, um eindeutige Namen zu erstellen. Die GPU_NP Variable speichert den Namen für den verwalteten GPU-Knotenpool. Die GPU_VM_SIZE Variable speichert die GRÖßE der GPU-aktivierten VM für den Knotenpool. Die LOCATION Variable weist den Wert "westus" auf. Sie können diese Variablenwerte verwenden oder eigene erstellen. Verwenden Sie den echo Befehl, um Variablenwerte wie echo $RANDOM_STRING anzuzeigen.

Erstellen einer Ressourcengruppe

Eine Azure Ressourcengruppe ist eine logische Gruppe zum Bereitstellen und Verwalten von Azure Ressourcen. Wenn Sie eine Ressourcengruppe erstellen, geben Sie einen Speicherort an. An diesem Speicherort werden die Metadaten der Ressourcengruppe gespeichert und in Azure ausgeführt, wenn Sie während der Ressourcenerstellung keine andere Region angeben.

Verwenden Sie den Befehl "az group create " zum Erstellen einer Ressourcengruppe.

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

Das folgende Beispiel zeigt das Ergebnis.

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

Erstellen eines AKS-Clusters

Erstellen Sie mithilfe des Befehls az aks create einen AKS-Cluster. Im folgenden Beispiel wird ein Cluster mit einem Systemknoten erstellt und eine vom System zugewiesene verwaltete Identität aktiviert.

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

Beim Erstellen eines neuen Clusters erstellt AKS automatisch eine zweite Ressourcengruppe, um die AKS-Ressourcen zu speichern. Weitere Informationen finden Sie unter Warum werden zwei Ressourcengruppen mit AKS erstellt?.

Der Cluster in diesem Beispiel gibt eine Knotenanzahl von einem an, um Zeit und Ressourcen zu sparen. Verwenden Sie in einer Produktionsumgebung eine Knotenanzahl von drei oder mehr Knoten. Der az aks create Befehl ist standardmäßig auf drei Knoten festgelegt, wenn Sie keine Knotenanzahl angeben.

Hinzufügen eines verwalteten GPU-Knotenpools

Fügen Sie Ihrem Cluster einen linuxbasierten verwalteten GPU-Knotenpool hinzu, indem Sie den Befehl " az aks nodepool hinzufügen" verwenden . Der --enable-managed-gpu=true Parameter konfiguriert AKS zum Installieren und Verwalten des NVIDIA GPU-Treibers, des NVIDIA Kubernetes-Geräte-Plug-Ins, des DCGM-Metrikexporteurs und der KOMPONENTEN für die GPU-Integritätsüberwachung im Knotenpool.

Im folgenden Beispiel wird ein verwalteter GPU-Knotenpool mithilfe des standardmäßigen Ubuntu Linux-Betriebssystems hinzugefügt.

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

Der --node-taints sku=gpu:NoSchedule Parameter behält Nicht-GPU-Workloads außerhalb des GPU-Knotenpools bei, es sei denn, die Workloads enthalten eine entsprechende Tolerierung.

Nachdem Sie den Knotenpool erstellt haben, verwenden Sie den Befehl " az aks nodepool show ", um zu bestätigen, dass das verwaltete GPU-Profil aktiviert ist.

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

Die Ausgabe sollte die folgenden Werte enthalten.

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

Herstellen einer Verbindung mit dem Cluster

Um einen Kubernetes-Cluster zu verwalten, verwenden Sie den Kubernetes-Befehlszeilenclient kubectl. Wenn Sie Azure Cloud Shell verwenden, ist kubectl bereits installiert. Um kubectl lokal zu installieren, verwenden Sie den Befehl az aks install-cli.

  1. Konfigurieren Sie kubectl, um mithilfe des Befehls az aks get-credentials eine Verbindung mit Ihrem Kubernetes-Cluster herzustellen. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

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

  2. Überprüfen Sie die Verbindung mit Ihrem Cluster mithilfe des Befehls "kubectl get ". Dieser Befehl gibt eine Liste der Clusterknoten zurück und zeigt den Knotenpool für jeden Knoten an.

    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. Stellen Sie sicher, dass Kubernetes GPU-Workloads im verwalteten GPU-Knotenpool planen können.

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

    Die Ausgabe zeigt die Anzahl der zuweisbaren GPUs für jeden Knoten im verwalteten GPU-Knotenpool an.

    aks-gpunp-123456789-vmss000000  1

Aktivieren der GPU-Metriksammlung

Verwaltete GPU-Knotenpools enthalten den Exporter für DCGM-Metriken. Um die GPU-Metriken in Azure Managed Prometheus zu erfassen, aktivieren Sie zuerst den verwalteten Azure Monitor-Dienst für Prometheus auf Ihrem AKS-Cluster. Erstellen Sie dann eine ConfigMap, die das dcgmexporter Scraping-Profil im Azure Monitor-Agent ermöglicht.

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

Nachdem Sie diese ConfigMap angewendet haben, werden alle vorhandenen und neuen NVIDIA GPU-Knotenpools auf dem Cluster automatisch verschrottet. Informationen zum Anzeigen von GPU-Metriken in Azure Managed Grafana finden Sie unter GPU-Observability in Azure Kubernetes Service (AKS).

Stellen Sie die Anwendung bereit

Stellen Sie eine GPU-Workload bereit, um sicherzustellen, dass der verwaltete GPU-Knotenpool echte Anwendungen ausführen kann. In diesem Beispiel wird Ollama ausgeführt, das über eine openAI-kompatible API ein kleines Open-Source-Großsprachenmodell (Llama 3.2 1B) verwendet. Ollama basiert auf llama.cpp, das die NVIDIA T4-GPU im Knotenpool Standard_NC4as_T4_v3 unterstützt, den diese Schnellstartanleitung verwendet.

Das folgende Manifest erstellt ein Deployment und ein Service. Deployment fordert eine GPU (nvidia.com/gpu: 1) an, enthält eine Tolerierung für den sku=gpu:NoSchedule-Taint und verwendet einen Knotenselektor, um den verwalteten GPU-Knotenpool gezielt auszuwählen. Beim Start des Containers startet er den Ollama-Server und lädt das Modell llama3.2:1b herunter, sodass der Pod bereit ist, Anfragen zu verarbeiten.

Stellen Sie die Anwendung mithilfe des folgenden Befehls bereit.

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

Dieses Manifest zielt auf den gpunp Knotenpool ab. Wenn Sie einen anderen Wert für die GPU_NP Variable verwendet haben, aktualisieren Sie den kubernetes.azure.com/agentpool Knotenmarkiererwert entsprechend, bevor Sie das Manifest anwenden.

Vergewissern Sie sich mithilfe des Befehls kubectl rollout status, dass die Bereitstellung bereit ist. Der anfängliche Modelldownload kann einige Minuten dauern.

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

Stellen Sie sicher, dass der Pod im verwalteten GPU-Knotenpool ausgeführt wird, indem Sie den Befehl "kubectl get" verwenden .

kubectl get pods -l app=ollama -o wide

Ihre Ausgabe sollte zeigen, dass der Pod auf einem Knoten im Knotenpool gpunp läuft.

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>

Testen der App

Leiten Sie einen lokalen Port mithilfe des Befehls Service an weiter. Führen Sie diesen Befehl aus, und öffnen Sie ein zweites Terminal für die verbleibenden Schritte.

kubectl port-forward svc/ollama 11434:11434

Senden Sie im zweiten Terminal mithilfe des OpenAI-kompatiblen Endpunkts für Chatabschlusse eine Eingabeaufforderung an das Modell.

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

Das Modell gibt eine JSON-Antwort zurück, die eine generierte Antwort enthält, was bestätigt, dass der Workload die Inferenz über den verwalteten GPU-Knotenpool bereitstellt.

Vergewissern Sie sich, dass das Modell mithilfe des ollama ps Befehls auf der GPU geladen wird. Die PROCESSOR-Spalte zeigt 100% GPU, wenn das Modell auf dem T4 ausgeführt wird.

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

Sie können die GPU auch direkt über den Pod anzeigen, indem Sie den nvidia-smi Befehl verwenden.

kubectl exec deploy/ollama -- nvidia-smi

Wenn Sie den Test abgeschlossen haben, beenden Sie den kubectl port-forward Prozess, indem Sie STRG+C im Terminal auswählen. Die Anwendung wird entfernt, wenn Sie den Cluster im nächsten Schritt löschen.

Löschen des Clusters

Wenn Sie nicht planen, das AKS-Lernprogramm durchzuführen, bereinigen Sie unnötige Ressourcen, um Azure-Abrechnungsgebühren zu vermeiden. Sie können die Ressourcengruppe, den Containerdienst und alle zugehörigen Ressourcen entfernen, indem Sie den Befehl "az group delete" verwenden .

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

Sie haben den AKS-Cluster mit einer vom System zugewiesenen verwalteten Identität erstellt, bei der es sich um die Standardidentitätsoption handelt, die in dieser Schnellstartanleitung verwendet wird. Die Plattform verwaltet diese Identität, sodass Sie sie nicht manuell entfernen müssen.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Kubernetes-Cluster bereitgestellt und dann einen linuxbasierten verwalteten GPU-Knotenpool hinzugefügt. Weitere Informationen zu verwalteten GPU-Knoten und GPU-Metriken finden Sie in den folgenden Artikeln:

Wenn Sie mehr über AKS erfahren und ein vollständiges Code-zu-Bereitstellungsbeispiel ausführen möchten, fahren Sie mit dem Kubernetes-Clusterlernprogramm fort.

AKS-Lernprogramm

  • Last updated on