Szybki start: tworzenie klastra Azure Kubernetes Service (AKS) opartego na procesorze GPU z systemem Linux przy użyciu Azure CLI

Azure Kubernetes Service (AKS) to zarządzana usługa Kubernetes, której można użyć do szybkiego wdrażania klastrów i zarządzania nimi. Z tego przewodnika Szybki start dowiesz się, jak wykonywać następujące zadania:

  • Wdróż klaster usługi AKS przy użyciu Azure CLI.
  • Dodaj pulę węzłów procesora GPU opartą na systemie Linux z włączonymi zarządzanymi węzłami procesora GPU.
  • Sprawdź, czy AKS zainstalował i skonfigurował stos oprogramowania GPU na potrzeby planowania.

W pełni zarządzane węzły procesora GPU są funkcją w wersji zapoznawczej. Po włączeniu zarządzanych węzłów GPU usługa AKS instaluje sterownik GPU NVIDIA i zarządza nim, a także instaluje wtyczkę urządzeń NVIDIA dla platformy Kubernetes, eksporter metryk narzędzia Data Center GPU Manager (DCGM) oraz składniki monitorowania kondycji GPU dla puli węzłów GPU. Zarządzane węzły GPU integrują również metryki GPU w czasie rzeczywistym na potrzeby pozyskiwania danych w usłudze Azure Managed Prometheus oraz w usłudze Azure Monitor managed service for Prometheus. Aby uzyskać więcej informacji, zobacz Tworzenie w pełni zarządzanej puli węzłów procesora GPU w Azure Kubernetes Service (AKS) (wersja zapoznawcza) i obserwowanie procesora GPU w Azure Kubernetes Service (AKS).

Note

Ten artykuł zawiera kroki wdrażania klastra tylko do celów ewaluacyjnych. Przed wdrożeniem klastra gotowego do produkcji zapoznaj się z architekturą referencyjną punktu odniesienia , aby zastanowić się, jak jest ona zgodna z wymaganiami biznesowymi.

Important

Funkcje usługi AKS w wersji zapoznawczej są dostępne na zasadzie samoobsługi i wymagają zapisania się. Wersje zapoznawcze są udostępniane w wersji "as is" i "jako dostępne" i są wykluczone z umów dotyczących poziomu usług i ograniczonej gwarancji. Wersje zapoznawcze usługi AKS są częściowo objęte pomocą techniczną dla klientów, świadczoną w miarę możliwości. W związku z tym te funkcje nie są przeznaczone do użytku produkcyjnego. Aby uzyskać więcej informacji, zobacz następujące artykuły pomocy technicznej:

Zanim rozpoczniesz

Ten szybki start zakłada, że masz podstawową wiedzę na temat pojęć związanych z platformą Kubernetes. Aby uzyskać więcej informacji, zobacz Podstawowe pojęcia Kubernetes dla Azure Kubernetes Service (AKS).

  • Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

Zainstaluj rozszerzenie CLI aks-preview

Zainstaluj rozszerzenie CLI aks-preview za pomocą polecenia az extension add.

az extension add --name aks-preview

Zaktualizuj rozszerzenie, aby upewnić się, że masz najnowszą wersję za pomocą polecenia az extension update .

az extension update --name aks-preview

Rejestrowanie funkcji w wersji zapoznawczej

Zarejestruj flagę funkcji ManagedGPUExperiencePreview w ramach subskrypcji przy użyciu polecenia az feature register.

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

Wyświetlenie stanu Zarejestrowane trwa kilka minut. Sprawdź stan rejestracji za pomocą polecenia az feature show.

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

Gdy stan ma wartość Zarejestrowano, odśwież rejestrację Microsoft.ContainerService dostawcy zasobów przy użyciu polecenia az provider register .

az provider register --namespace Microsoft.ContainerService

Definiowanie zmiennych środowiskowych

Zdefiniuj następujące zmienne środowiskowe do użycia w tym przewodniku Szybki start.

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"

Zmienna RANDOM_STRING przechowuje losowy 10-cyfrowy ciąg. Wartości zmiennych RESOURCE_GROUP i CLUSTER_NAME są łączone z wartością RANDOM_STRING w celu utworzenia unikalnych nazw. Zmienna GPU_NP przechowuje nazwę zarządzanej puli węzłów procesora GPU. Zmienna GPU_VM_SIZE przechowuje rozmiar maszyny wirtualnej z obsługą procesora GPU dla puli węzłów. Zmienna LOCATION ma wartość westus. Możesz użyć tych wartości zmiennych lub utworzyć własne. Użyj polecenia , echo aby wyświetlić wartości zmiennych, takie jak echo $RANDOM_STRING.

Tworzenie grupy zasobów

Grupa zasobów Azure to grupa logiczna do wdrażania zasobów Azure i zarządzania nimi. Podczas tworzenia grupy zasobów określ lokalizację. Ta lokalizacja polega na tym, że metadane grupy zasobów są przechowywane i gdzie zasoby są uruchamiane w Azure, jeśli nie określisz innego regionu podczas tworzenia zasobów.

Użyj polecenia az group create , aby utworzyć grupę zasobów.

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

Poniższy przykład przedstawia wynik.

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

Utwórz klaster AKS

Utwórz klaster AKS za pomocą polecenia az aks create. Poniższy przykład tworzy klaster z jednym węzłem systemowym i włącza tożsamość zarządzaną przypisaną przez system.

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

Podczas tworzenia nowego klastra usługa AKS automatycznie tworzy drugą grupę zasobów do przechowywania zasobów usługi AKS. Aby uzyskać więcej informacji, zobacz Dlaczego dwie grupy zasobów są tworzone za pomocą usługi AKS?

Klaster w tym przykładzie określa liczbę węzłów równą jednemu, aby zaoszczędzić czas i zasoby. W środowisku produkcyjnym należy użyć co najmniej trzech węzłów. Polecenie az aks create jest domyślnie ustawione na trzy węzły, jeśli nie określisz liczby węzłów.

Dodaj zarządzaną pulę węzłów GPU

Dodaj do klastra zarządzaną pulę węzłów GPU opartą na systemie Linux przy użyciu polecenia az aks nodepool add. Parametr --enable-managed-gpu=true konfiguruje AKS do instalowania sterownika GPU firmy NVIDIA, wtyczki urządzenia Kubernetes dla NVIDIA, eksportera metryk DCGM oraz składników monitorowania kondycji GPU i zarządzania nimi w puli węzłów.

Poniższy przykład dodaje zarządzaną pulę węzłów procesora GPU przy użyciu domyślnego systemu operacyjnego 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 nie dopuszcza obciążeń niewymagających GPU do puli węzłów GPU, chyba że obciążenia te zawierają odpowiednią tolerancję.

Po utworzeniu puli węzłów użyj polecenia az aks nodepool show , aby potwierdzić, że profil zarządzanego procesora GPU jest włączony.

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

Dane wyjściowe powinny zawierać następujące wartości.

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

Połącz się z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. Jeśli korzystasz z usługi Azure Cloud Shell, narzędzie kubectl jest już zainstalowane. Aby zainstalować kubectl lokalnie, użyj polecenia az aks install-cli .

  1. Skonfiguruj kubectl , aby nawiązać połączenie z klastrem Kubernetes przy użyciu polecenia az aks get-credentials . To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

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

  2. Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get . To polecenie zwraca listę węzłów klastra i pokazuje pulę węzłów dla każdego węzła.

    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. Sprawdź, czy platforma Kubernetes może zaplanować obciążenia procesora GPU w zarządzanej puli węzłów procesora 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}'

    Dane wyjściowe pokazują liczbę procesorów GPU możliwych do przydzielenia dla każdego węzła w zarządzanej puli węzłów GPU.

    aks-gpunp-123456789-vmss000000  1

Włączanie zbierania metryk procesora GPU

Zarządzane pule węzłów GPU zawierają eksporter metryk DCGM. Aby pozyskiwać metryki GPU w usłudze Azure Managed Prometheus, najpierw włącz usługę zarządzaną Azure Monitor dla narzędzia Prometheus w klastrze AKS. Następnie utwórz obiekt ConfigMap, aby włączyć profil dcgmexporter zbierania danych w agencie Azure Monitor.

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 zastosowaniu tej ConfigMap wszystkie istniejące i nowe pule węzłów procesora GPU firmy NVIDIA w klastrze są usuwane automatycznie. Aby wyświetlić metryki procesora GPU w Azure Managed Grafana, zobacz Obserwowanie procesora GPU w Azure Kubernetes Service (AKS).

Wdrażanie aplikacji

Wdróż obciążenie procesora GPU, aby potwierdzić, że zarządzana pula węzłów procesora GPU może uruchamiać rzeczywiste aplikacje. W tym przykładzie działa system Ollama, który obsługuje mały model języka open source (Llama 3.2 1B) za pośrednictwem interfejsu API zgodnego z platformą OpenAI. Ollama opiera się na llama.cpp, który obsługuje kartę graficzną NVIDIA T4 w puli węzłów Standard_NC4as_T4_v3, używanej w tym przewodniku Szybki start.

Poniższy manifest tworzy element Deployment i element Service. Obiekt Deployment żąda jednego procesora graficznego (GPU) (nvidia.com/gpu: 1), zawiera tolerancję dla skażenia sku=gpu:NoSchedule i używa selektora węzłów, aby wskazać zarządzaną pulę węzłów GPU. Po uruchomieniu kontener uruchamia serwer Ollama i pobiera model llama3.2:1b, aby zasobnik był gotowy do obsługiwania żądań.

Wdróż aplikację przy użyciu następującego polecenia.

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

Ten manifest dotyczy puli węzłów gpunp. Jeśli dla zmiennej GPU_NP użyto innej wartości, zaktualizuj kubernetes.azure.com/agentpool wartość selektora węzłów, aby była zgodna przed zastosowaniem manifestu.

Upewnij się, że wdrożenie jest gotowe, za pomocą polecenia kubectl rollout status. Pobieranie początkowego modelu może potrwać kilka minut.

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

Sprawdź, czy pod jest uruchomiony w zarządzanej puli węzłów GPU za pomocą polecenia kubectl get.

kubectl get pods -l app=ollama -o wide

Wynik powinien pokazywać zasobnik uruchomiony na węźle w puli węzłów 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>

Testowanie aplikacji

Przekieruj lokalny port do Service za pomocą polecenia kubectl port-forward. Pozostaw to polecenie uruchomione i otwórz drugi terminal dla pozostałych kroków.

kubectl port-forward svc/ollama 11434:11434

W drugim terminalu wyślij monit do modelu przy użyciu punktu końcowego uzupełniania czatu zgodnego z interfejsem 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 zwraca odpowiedź JSON zawierającą wygenerowaną odpowiedź, która potwierdza, że obciążenie obsługuje wnioskowanie z zarządzanej puli węzłów procesora GPU.

Upewnij się, że model został załadowany na procesor GPU przy użyciu ollama ps polecenia . Kolumna PROCESSOR pokazuje 100% GPU , kiedy model działa 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 można również sprawdzić bezpośrednio z wnętrza poda za pomocą polecenia nvidia-smi.

kubectl exec deploy/ollama -- nvidia-smi

Po zakończeniu testowania kubectl port-forward zatrzymaj proces, wybierając klawisze Ctrl+C w terminalu. Aplikacja zostanie usunięta po usunięciu klastra w następnym kroku.

Usuwanie klastra

Jeśli nie planujesz wykonywania samouczka dotyczącego usługi AKS, wyczyść niepotrzebne zasoby, aby uniknąć opłat za rozliczenia platformy Azure. Grupę zasobów, usługę kontenera i wszystkie powiązane zasoby można usunąć za pomocą polecenia az group delete .

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

Klaster AKS utworzono przy użyciu tożsamości zarządzanej przypisanej przez system, która jest domyślną opcją tożsamości stosowaną w tym przewodniku Szybki start. Platforma zarządza tą tożsamością, aby nie trzeba było jej ręcznie usuwać.

Następne kroki

W tym przewodniku Szybki start wdrożysz klaster Kubernetes, a następnie dodasz zarządzaną pulę węzłów GPU opartych na systemie Linux. Aby uzyskać więcej informacji na temat zarządzanych węzłów procesora GPU i metryk procesora GPU, zobacz następujące artykuły:

Aby dowiedzieć się więcej na temat usługi AKS i wykonać kompletny przykład kodu do wdrożenia, przejdź do samouczka dotyczącego klastra Kubernetes.

Samouczek dotyczący usługi AKS

  • Last updated on