Rövid útmutató: GPU-val rendelkező, Linux-alapú Azure Kubernetes Service-(AKS-)fürt létrehozása az Azure CLI használatával

Azure Kubernetes Service (AKS) egy felügyelt Kubernetes-szolgáltatás, amellyel gyorsan üzembe helyezheti és kezelheti a fürtöket. Ezen rövid útmutató segítségével megtanulhatja a következőket:

  • AKS-klaszter telepítése az Azure CLI használatával.
  • Adjon hozzá egy Linux-alapú GPU-csomópontkészletet, amelyen engedélyezve van a felügyelt GPU-csomópontok használata.
  • Ellenőrizze, hogy az AKS telepítette-e és konfigurálta-e a GPU-szoftververmet az ütemezéshez.

A teljes mértékben felügyelt GPU-csomópontok előzetes verziójú funkciók. A felügyelt GPU-csomópontok engedélyezésekor az AKS telepíti és kezeli az NVIDIA GPU-illesztőt, az NVIDIA Kubernetes eszköz beépülő modult, a Data Center GPU Manager (DCGM) metrikák exportőrét és a GPU-csomópontkészlet GPU-állapotfigyelő összetevőit. A felügyelt GPU-csomópontok valós idejű GPU-metrikákat is integrálnak az Azure Managed Prometheusba és a Prometheushoz készült Azure Monitor felügyelt szolgáltatásba történő betöltéshez. További információ: Teljes mértékben felügyelt GPU-csomópontkészlet létrehozása a Azure Kubernetes Service (AKS) (előzetes verzió) és a GPU megfigyelhetősége Azure Kubernetes Service (AKS).

Note

Ez a cikk a fürtök csak kiértékelési célokra történő üzembe helyezésének lépéseit tartalmazza. Éles üzemre kész fürt üzembe helyezése előtt ismerkedjen meg az alapkonfigurációs referenciaarchitektúrával , és gondolja át, hogyan összhangban van az üzleti követelményekkel.

Important

Az AKS előzetes verziójú funkciói önkiszolgáló, opt-in alapon érhetők el. Az előzetes verziókat "ahogy van" és "rendelkezésre állóként" biztosítjuk, és a szolgáltatási szerződésekből és a korlátozott jótállásból kizárjuk őket. Az AKS előzetes verzióihoz részleges támogatást nyújt az ügyfélszolgálat a tőle telhető legjobb módon. Ezért ezek a funkciók nem éles használatra vannak szánva. További információkért tekintse meg az alábbi támogatási cikkeket:

Mielőtt hozzákezdene

A rövid útmutató feltételezi, hogy rendelkezik a Kubernetes használatára vonatkozó alapvető ismeretekkel. További információkért tekintse meg az Azure Kubernetes Service (AKS) Kubernetes alapfogalmait.

  • Ha nem rendelkezik Azure-fiókkal, a kezdés előtt hozzon létre egy ingyenes fiókot .
  • Szüksége van Azure CLI 2.85.0-s vagy újabb verziójára. A verzió megkereséséhez futtassa a következőt: az --version. Ha telepítenie vagy frissítenie kell az Azure CLI-t, tekintse meg az Azure CLI telepítését.
  • Győződjön meg arról, hogy a fürt létrehozásához használt identitás rendelkezik a megfelelő minimális engedélyekkel. Az AKS-hez való hozzáféréssel és identitással kapcsolatos további információkért lásd az Azure Kubernetes Service (AKS) hozzáférési és identitásbeállításait.
  • Ha több Azure előfizetéssel rendelkezik, az az account set paranccsal válassza ki a számlázáshoz megfelelő előfizetés-azonosítót. További információ: Azure előfizetések kezelése – Azure CLI.
  • Az Azure előfizetésétől függően előfordulhat, hogy vCPU-kvótanövelést kell kérnie az ebben a rövid útmutatóban használt GPU-kompatibilis virtuálisgép-családhoz. További információ: VM-családi vCPU-kvóták növelése.
  • A GPU-kompatibilis virtuális gépek méretei speciális hardvereket tartalmaznak, magasabb díjszabás és regionális rendelkezésre állás függvényében. További információ: GPU-optimalizált virtuálisgép-méretek.

A CLI bővítmény aks-preview telepítése

Telepítse a aks-preview CLI-bővítményt az az extension add paranccsal.

az extension add --name aks-preview

Frissítse a bővítményt, hogy biztosan a legújabb verzióval rendelkezzen az az extension update paranccsal.

az extension update --name aks-preview

Az előzetes verziójú funkció regisztrálása

Regisztrálja a ManagedGPUExperiencePreview funkciójelzőt az előfizetésben az az feature register paranccsal.

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

Néhány percig tart, amíg az állapot megjelenik a Regisztrált állapotban. Ellenőrizze a regisztráció állapotát a az feature show parancs használatával.

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

Ha az állapot a Regisztrálva állapotot mutatja, frissítse az erőforrás-szolgáltató regisztrációját az Microsoft.ContainerServiceaz provider register paranccsal.

az provider register --namespace Microsoft.ContainerService

Környezeti változók definiálása

A rövid útmutató során a következő környezeti változók definiálhatók.

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"

A RANDOM_STRING változó egy véletlenszerű 10 jegyű sztringet tárol. RESOURCE_GROUP és CLUSTER_NAME változóértékek az RANDOM_STRING értékkel összefűzve egyedi nevek létrehozásához. A GPU_NP változó tárolja a felügyelt GPU-csomópontkészlet nevét. A GPU_VM_SIZE változó tárolja a csomópontkészlet GPU-kompatibilis virtuálisgép-méretét. A LOCATION változó értéke westus. Ezeket a változóértékeket használhatja, vagy létrehozhat saját értékeket. Az echo parancs használatával megtekintheti a változóértékeket, mint a echo $RANDOM_STRING.

Erőforráscsoport létrehozása

Az Azure erőforráscsoport logikai csoport Azure erőforrások üzembe helyezéséhez és kezeléséhez. Erőforráscsoport létrehozásakor adjon meg egy helyet. Ez a hely tárolja az erőforráscsoport metaadatait, és ahol az erőforrások Azure futnak, ha nem ad meg másik régiót az erőforrás létrehozása során.

Az az group create paranccsal hozzon létre egy erőforráscsoportot.

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

Az alábbi példa az eredményt mutatja.

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

AKS-klaszter létrehozása

Használja az az aks create parancsot egy AKS-fürt létrehozásához. Az alábbi példa egy egy rendszercsomóponttal rendelkező fürtöt hoz létre, és engedélyezi a rendszer által hozzárendelt felügyelt identitást.

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

Új fürt létrehozásakor az AKS automatikusan létrehoz egy második erőforráscsoportot az AKS-erőforrások tárolásához. További információ: Miért jön létre két erőforráscsoport az AKS-sel?

A példában szereplő fürt egy csomópont számát adja meg, amely időt és erőforrásokat takarít meg. Éles környezetben használjon három vagy több csomópontot tartalmazó csomópontszámot. A az aks create parancs alapértelmezés szerint három csomópontra vonatkozik, ha nem ad meg csomópontszámot.

Felügyelt GPU-csomópontkészlet hozzáadása

Adjon hozzá egy Linux-alapú, felügyelt GPU-csomópontkészletet a fürthöz az az aks nodepool add parancs használatával. A --enable-managed-gpu=true paraméter konfigurálja az AKS-t az NVIDIA GPU-illesztő, az NVIDIA Kubernetes eszköz beépülő modul, a DCGM-metrikák exportőre és a GPU állapotfigyelési összetevőinek telepítéséhez és kezeléséhez a csomópontkészleten.

Az alábbi példa egy felügyelt GPU-csomópontkészletet ad hozzá az alapértelmezett Ubuntu Linux operációs rendszer használatával.

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

A --node-taints sku=gpu:NoSchedule paraméter nem GPU-alapú számítási feladatokat távol tart a GPU-csomópontkészlettől, kivéve, ha a számítási feladatok egyező tűrést tartalmaznak.

A csomópontkészlet létrehozása után az az aks nodepool show paranccsal győződjön meg arról, hogy a felügyelt GPU-profil engedélyezve van.

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

A kimenetnek tartalmaznia kell a következő értékeket.

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

Csatlakozzon a klaszterhez

A Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori klienst, a kubectl-t. Ha az Azure Cloud Shellt használja, kubectl már telepítve van. A kubectl helyi telepítésére használja az az aks install-cli parancsot.

  1. Konfigurálja a(z) kubectl elemet úgy, hogy az az aks get-credentials paranccsal csatlakozni tudjon a Kubernetes-klaszteréhez. Ez a parancs letölti a hitelesítő adatokat, és konfigurálja a Kubernetes parancssori felületét a használatukhoz.

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

  2. Ellenőrizze a fürthöz való kapcsolatot a kubectl get paranccsal. Ez a parancs visszaadja a fürtcsomópontok listáját, és megjeleníti az egyes csomópontok csomópontkészletét.

    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. Ellenőrizze, hogy a Kubernetes képes-e GPU-számítási feladatokat ütemezni a felügyelt GPU-csomópontkészleten.

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

    A kimenet a felügyelt GPU-csomópontkészlet minden csomópontjának kiosztható GPU-számát jeleníti meg.

    aks-gpunp-123456789-vmss000000  1

GPU-metrikák gyűjteményének engedélyezése

A felügyelt GPU-csomópontkészletek közé tartoznak a DCGM-metrikák exportőrei. A GPU-metrikák Azure felügyelt Prometheusba való betöltéséhez először engedélyezze Azure Monitor felügyelt szolgáltatást a Prometheushoz az AKS-fürtön. Ezután hozzon létre egy ConfigMapet, amely engedélyezi a dcgmexporter adatgyűjtési profilt az Azure Monitor-ügynökben.

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

A ConfigMap alkalmazása után a rendszer automatikusan lekaparja a fürt összes meglévő és új NVIDIA GPU-csomópontkészletét. Az Azure Managed Grafanában a GPU-metrikák megtekintéséhez lásd a GPU monitorozása az Azure Kubernetes Service-ben (AKS).

Az alkalmazás üzembe helyezése

Helyezzen üzembe egy GPU-számítási feladatot annak ellenőrzéséhez, hogy a felügyelt GPU-csomópontkészlet képes-e valós alkalmazásokat futtatni. Ez a példa az Ollama-t futtatja, amely egy kis, nyílt forráskódú nagy nyelvi modellt (Llama 3.2 1B) szolgál ki egy OpenAI-kompatibilis API-n keresztül. Az Ollama a llama.cpp-re épül, amely támogatja az NVIDIA T4 GPU-t az ebben a gyorsútmutatóban használt Standard_NC4as_T4_v3 csomópontkészletben.

A következő jegyzék létrehoz egy Deployment és egy Service. A(z) Deployment egy GPU-t (nvidia.com/gpu: 1) kér, tartalmaz egy tolerálást a sku=gpu:NoSchedule tainthez, és csomópontválasztót használ a felügyelt GPU-csomópontkészlet célzásához. Amikor a tároló elindul, elindítja az Ollama-kiszolgálót, és letölti a llama3.2:1b modellt, hogy a pod készen álljon a kérések kiszolgálására.

Telepítse az alkalmazást az alábbi paranccsal.

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

Ez a jegyzék a gpunp csomópontkészletet célozza meg. Ha a változóhoz GPU_NP más értéket használt, frissítse a kubernetes.azure.com/agentpool csomópontválasztó értékét úgy, hogy megfeleljen a jegyzékfájl alkalmazása előtt.

Győződjön meg arról, hogy a telepítés készen áll-e a kubectl rollout status parancs használatával. A modell kezdeti letöltése eltarthat néhány percig.

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

Ellenőrizze, hogy a pod fut-e a felügyelt GPU-csomópontkészleten a kubectl get paranccsal.

kubectl get pods -l app=ollama -o wide

A kimenetnek azt kell mutatnia, hogy a pod a gpunp csomópontkészlet egyik csomópontján fut.

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>

Az alkalmazás tesztelése

Továbbítson egy helyi portot a Service felé a kubectl port-forward parancs használatával. Hagyja futni ezt a parancsot, és a további lépésekhez nyisson meg egy második terminált.

kubectl port-forward svc/ollama 11434:11434

A második terminálban küldjön egy üzenetet a modellnek az OpenAI-kompatibilis csevegővégpont használatával.

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

A modell egy JSON-választ ad vissza, amely egy generált választ tartalmaz, amely megerősíti, hogy a számítási feladat a felügyelt GPU-csomópontkészletből származó következtetést szolgál ki.

Győződjön meg arról, hogy a modell betöltődik a GPU-ba a ollama ps parancs használatával. Az PROCESSOR oszlop azt mutatja, 100% GPU hogy a modell mikor fut a T4-en.

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

A parancs használatával közvetlenül a podon belülről is megtekintheti a nvidia-smi GPU-t.

kubectl exec deploy/ollama -- nvidia-smi

A tesztelés befejezésekor állítsa le a folyamatot a kubectl port-forwardctrl+C billentyűkombinációval a terminálban. Az alkalmazás akkor lesz eltávolítva, ha a következő lépésben törli a fürtöt.

A klaszter törlése

Ha nem tervezi elvégezni az AKS-oktatóanyagot, törölje a felesleges erőforrásokat az Azure számlázási költségeinek elkerülése érdekében. Az erőforráscsoportot, a tárolószolgáltatást és az összes kapcsolódó erőforrást az az group delete paranccsal távolíthatja el.

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

Az AKS-fürtöt egy rendszer által hozzárendelt felügyelt identitással hozta létre, amely az ebben a gyorsútmutatóban használt alapértelmezett identitásbeállítás. A platform kezeli ezt az identitást, így önnek nem kell manuálisan eltávolítania.

Következő lépések

Ebben a gyorsútmutatóban telepített egy Kubernetes-fürtöt, majd hozzáadott egy Linux-alapú, felügyelt GPU-csomópontkészletet. A felügyelt GPU-csomópontokról és a GPU-metrikákról az alábbi cikkekben talál további információt:

Ha többet szeretne megtudni az AKS-ről, és elvégez egy teljes kód–üzembe helyezési példát, folytassa a Kubernetes-fürt oktatóanyagával.

AKS-oktatóanyag

  • Last updated on