Rychlý start: Vytvoření clusteru Azure Kubernetes Service (AKS) gpu s Linuxem pomocí Azure CLI

Azure Kubernetes Service (AKS) je spravovaná služba Kubernetes, kterou můžete použít k rychlému nasazení a správě clusterů. V tomto rychlém startu se naučíte:

  • Nasaďte cluster AKS pomocí Azure CLI.
  • Přidejte fond uzlů GPU se systémem Linux se zapnutými spravovanými uzly GPU.
  • Ověřte, že AKS nainstaloval a nakonfiguroval softwarový zásobník GPU pro účely plánování.

Plně spravované GPU uzly jsou funkcí ve verzi Preview. Když povolíte spravované uzly GPU, AKS nainstaluje a spravuje ovladač NVIDIA GPU, modul zařízení NVIDIA pro Kubernetes, exportér metrik Data Center GPU Manager (DCGM) a komponenty pro monitorování stavu fondu uzlů GPU. Spravované uzly GPU také integrují metriky GPU v reálném čase pro ingesti do služeb Azure Managed Prometheus a spravované služby Azure Monitor pro Prometheus. Další informace najdete v tématu Vytvoření plně spravovaného fondu uzlů GPU na Azure Kubernetes Service (AKS) (Preview) a pozorovatelnosti GPU v Azure Kubernetes Service (AKS).

Note

Tento článek obsahuje postup nasazení clusteru pouze pro účely vyhodnocení. Než nasadíte cluster připravený pro produkční prostředí, seznamte se se základní referenční architekturou a zvažte, jak je v souladu s vašimi obchodními požadavky.

Důležité

Funkce AKS ve verzi Preview jsou k dispozici na bázi samoobsluhy a dobrovolného přihlášení. Ukázky jsou poskytovány "tak, jak jsou" a "dle dostupnosti" a jsou vyloučeny ze smluv o úrovni služeb a z omezené záruky. Předběžné verze AKS jsou částečně pokryty zákaznickou podporou podle možností. Proto tyto funkce nejsou určené pro produkční použití. Další informace najdete v následujících článcích podpory:

Než začnete

Tento rychlý start předpokládá základní znalosti konceptů Kubernetes. Další informace najdete v tématu Základní koncepty Kubernetes pro Službu Azure Kubernetes Service (AKS).

  • Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.

Nainstalovat rozšíření aks-preview příkazového řádku

Nainstalujte rozšíření aks-preview CLI pomocí příkazu az extension add.

az extension add --name aks-preview

Pomocí příkazu az extension update aktualizujte rozšíření, abyste měli nejnovější verzi.

az extension update --name aks-preview

Registrace funkce Preview

ManagedGPUExperiencePreview Pomocí příkazu az feature register zaregistrujte příznak funkce ve vašem předplatném.

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

Zobrazení stavu Zaregistrované trvá několik minut. Pomocí příkazu az feature show ověřte stav registrace.

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

Když se zobrazí stav Registrováno, aktualizujte registraci Microsoft.ContainerService poskytovatele prostředků pomocí příkazu az provider register .

az provider register --namespace Microsoft.ContainerService

Definování proměnných prostředí

Během tohoto rychlého startu definujte následující proměnné prostředí k použití.

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"

Proměnná RANDOM_STRING ukládá náhodný 10místný řetězec. Hodnoty proměnných RESOURCE_GROUP a CLUSTER_NAME jsou zřetězeny s hodnotou RANDOM_STRING pro vytvoření jedinečných názvů. Proměnná GPU_NP ukládá název spravovaného fondu uzlů GPU. Proměnná GPU_VM_SIZE ukládá velikost virtuálního počítače s podporou GPU pro fond uzlů. Proměnná LOCATION má hodnotu westus. Tyto hodnoty proměnných můžete použít nebo si vytvořit vlastní. echo Pomocí příkazu zobrazte hodnoty proměnných, jako je echo $RANDOM_STRING.

Vytvoření skupiny zdrojů

Skupina prostředků Azure je logická skupina pro nasazování a správu Azure prostředků. Při vytváření skupiny prostředků zadejte umístění. Toto umístění je místo, kde jsou uložena metadata skupiny prostředků a kde se vaše prostředky spouští v Azure pokud během vytváření prostředků nezadáte jinou oblast.

Pomocí příkazu az group create vytvořte skupinu prostředků.

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

Následující příklad ukazuje výsledek.

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

Vytvoření clusteru AKS

Pomocí příkazu az aks create vytvořte cluster AKS. Následující příklad vytvoří cluster s jedním systémovým uzlem a povolí spravovanou identitu přiřazenou systémem.

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

Když vytvoříte nový cluster, AKS automaticky vytvoří druhou skupinu prostředků pro uložení prostředků AKS. Další informace najdete v tématu Proč se v AKS vytvářejí dvě skupiny prostředků?

Cluster v tomto příkladu určuje počet uzlů jako jeden, aby se ušetřil čas a prostředky. V produkčním prostředí použijte počet uzlů se třemi nebo více uzly. Pokud az aks create nezadáte počet uzlů, příkaz se standardně nastaví na tři uzly.

Přidání spravovaného fondu uzlů GPU

Přidejte do clusteru fond uzlů GPU spravovaný linuxem pomocí příkazu az aks nodepool add . Parametr --enable-managed-gpu=true nakonfiguruje AKS pro instalaci a správu ovladače NVIDIA GPU, modulu plug-in zařízení NVIDIA Kubernetes, exportéru metrik DCGM a komponent monitorování stavu GPU ve fondu uzlů.

Následující příklad přidá spravovaný fond uzlů GPU pomocí výchozího operačního systému 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

Parametr --node-taints sku=gpu:NoSchedule zabrání tomu, aby se úlohy bez GPU spouštěly ve fondu uzlů GPU, pokud tyto úlohy neobsahují odpovídající toleranci.

Po vytvoření fondu uzlů pomocí příkazu az aks nodepool show potvrďte, že je povolený spravovaný profil GPU.

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

Výstup by měl obsahovat následující hodnoty.

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

Připojení ke clusteru

Pro správu Kubernetes clusteru použijte příkazový řádkový klient Kubernetes, kubectl. Pokud používáte Azure Cloud Shell, kubectl je už nainstalovaný. K místní instalaci kubectl použijte příkaz az aks install-cli .

  1. Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials . Tento příkaz stahuje přihlašovací údaje a konfiguruje Kubernetes CLI pro jejich použití.

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

  2. Pomocí příkazu kubectl get ověřte připojení ke clusteru. Tento příkaz vrátí seznam uzlů clusteru a zobrazí fond uzlů pro každý uzel.

    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. Ověřte, že Kubernetes může plánovat úlohy GPU ve spravovaném fondu uzlů GPU.

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

    Výstup zobrazuje počet akatebilních GPU pro každý uzel ve spravovaném fondu uzlů GPU.

    aks-gpunp-123456789-vmss000000  1

Povolení shromažďování metrik GPU

Fondy spravovaných uzlů GPU zahrnují exportér metrik DCGM. Chcete-li načíst metriky GPU do Azure Managed Prometheus, nejprve ve svém clusteru AKS povolte spravovanou službu Azure Monitor pro Prometheus. Pak vytvořte mapu ConfigMap, která v agentu Azure Monitor povolí profil dcgmexporter pro scraping.

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

Po použití této mapy ConfigMap se všechny existující a nové fondy uzlů NVIDIA GPU v clusteru automaticky sešrotují. Pokud chcete zobrazit metriky GPU v Azure Managed Grafana, podívejte se na pozorovatelnost GPU v Azure Kubernetes Service (AKS).

Nasazení aplikace

Nasaďte úlohu GPU, abyste potvrdili, že spravovaný fond uzlů GPU může spouštět skutečné aplikace. Tento příklad spouští Ollama, který obsluhuje malý opensourcový rozsáhlý jazykový model (Llama 3.2 1B) prostřednictvím rozhraní API kompatibilního s OpenAI. Ollama je postaven na llama.cpp, který podporuje GPU NVIDIA T4 ve Standard_NC4as_T4_v3 fondu uzlů, který tento rychlý start používá.

Následující manifest vytvoří objekt Deployment a objekt Service. Deployment požaduje jednu GPU (nvidia.com/gpu: 1), zahrnuje toleranci pro taint sku=gpu:NoSchedule a používá selektor uzlů, který cílí na spravovaný fond GPU uzlů. Když se kontejner spustí, spustí server Ollama a stáhne model llama3.2:1b, aby byl pod připravený vyřizovat požadavky.

Nasaďte aplikaci pomocí následujícího příkazu.

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

Tento manifest je určen pro skupinu uzlů gpunp. Pokud jste pro GPU_NP proměnnou použili jinou hodnotu, aktualizujte hodnotu selektoru kubernetes.azure.com/agentpool uzlu tak, aby odpovídala před použitím manifestu.

Pomocí příkazu kubectl rollout status ověřte, že je nasazení připraveno. Stažení počátečního modelu může trvat několik minut.

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

Pomocí příkazu kubectl get ověřte, že pod běží ve spravovaném fondu uzlů GPU.

kubectl get pods -l app=ollama -o wide

Výstup by měl zobrazit pod spuštěný na některém uzlu ve fondu uzlů 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>

Testování aplikace

Přesměrujte místní port na Service port pomocí příkazu kubectl port-forward . Ponechte tento příkaz spuštěný a otevřete druhý terminál pro zbývající kroky.

kubectl port-forward svc/ollama 11434:11434

V druhém terminálu odešlete do modelu výzvu pomocí koncového bodu dokončení chatu kompatibilního s 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?"}]
  }'

Model vrátí odpověď JSON obsahující vygenerovanou odpověď, která potvrzuje, že úloha obsluhuje odvozování ze spravovaného fondu uzlů GPU.

Pomocí příkazu ověřte, že je model načtený do GPU ollama ps . Sloupec PROCESSOR ukazuje 100% GPU , kdy model běží na 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

Gpu můžete také zobrazit přímo uvnitř podu nvidia-smi pomocí příkazu.

kubectl exec deploy/ollama -- nvidia-smi

Po dokončení testování proces zastavte kubectl port-forward tak, že v terminálu vyberete Ctrl+C . Aplikace se odebere při odstranění clusteru v dalším kroku.

Odstranění clusteru

Pokud nemáte v plánu kurz AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za fakturaci Azure. Pomocí příkazu az group delete můžete odebrat skupinu prostředků, službu kontejneru a všechny související prostředky.

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

Vytvořili jste cluster AKS se spravovanou identitou přiřazenou systémem, což je výchozí možnost identity použitá v tomto rychlém startu. Platforma spravuje tuto identitu, takže ji nemusíte ručně odstraňovat.

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes a pak jste přidali fond uzlů GPU spravovaný linuxem. Další informace o spravovaných uzlech GPU a metrikách GPU najdete v následujících článcích:

Chcete-li se dozvědět více o AKS a udělat úplný příklad od kódu po nasazení, pokračujte do kurzu clusteru Kubernetes.

Tutoriál AKS

  • Poslední aktualizace v