Mulai cepat: Membuat kluster Azure Kubernetes Service (AKS) berbasis GPU Linux menggunakan Azure CLI

Azure Kubernetes Service (AKS) adalah layanan Kubernetes terkelola yang dapat Anda gunakan untuk menyebarkan dan mengelola kluster dengan cepat. Dalam panduan memulai cepat ini, Anda mempelajari cara:

  • Sebarkan kluster AKS dengan menggunakan Azure CLI.
  • Tambahkan kumpulan simpul GPU berbasis Linux dengan simpul GPU terkelola diaktifkan.
  • Pastikan bahwa AKS telah menginstal dan mengonfigurasi stack perangkat lunak GPU untuk penjadwalan.

Node GPU yang dikelola sepenuhnya merupakan fitur pratinjau. Saat Anda mengaktifkan simpul GPU terkelola, AKS menginstal dan mengelola driver GPU NVIDIA, plugin perangkat NVIDIA Kubernetes, pengekspor metrik Data Center GPU Manager (DCGM), dan komponen pemantauan kesehatan GPU untuk kumpulan simpul GPU. Node GPU terkelola juga mengintegrasikan metrik GPU real time untuk penyerapan di Azure Managed Prometheus dan layanan terkelola Azure Monitor untuk Prometheus. Untuk informasi selengkapnya, lihat Membuat kumpulan simpul GPU yang dikelola sepenuhnya pada Azure Kubernetes Service (AKS) (pratinjau) dan pengamatan GPU di Azure Kubernetes Service (AKS).

Note

Artikel ini mencakup langkah-langkah untuk menyebarkan kluster hanya untuk tujuan evaluasi. Sebelum Anda menyebarkan kluster siap produksi, biasakan diri Anda dengan arsitektur referensi dasar untuk mempertimbangkan bagaimana kluster tersebut selaras dengan kebutuhan bisnis Anda.

Important

Fitur pratinjau AKS tersedia atas dasar layanan mandiri dan pendaftaran sukarela. Pratinjau disediakan "apa adanya" dan "sebagaimana tersedia," dan pratinjau tersebut dikecualikan dari perjanjian tingkat layanan (SLA) serta garansi terbatas. Fitur pratinjau AKS sebagian didukung oleh dukungan pelanggan sebatas upaya terbaik. Dengan demikian, fitur-fitur ini tidak dimaksudkan untuk penggunaan produksi. Untuk informasi lebih lanjut, lihat artikel dukungan berikut ini:

Sebelum Anda mulai

Panduan memulai cepat ini mengasumsikan bahwa Anda memiliki pemahaman dasar tentang konsep Kubernetes. Untuk informasi lebih, lihat konsep inti Kubernetes untuk Azure Kubernetes Service (AKS).

  • Jika Anda tidak memiliki akun Azure, buat akun gratis sebelum memulai.
  • Anda memerlukan Azure CLI versi 2.85.0 atau yang lebih baru. Jalankan az --version untuk mencari tahu versinya. Jika Anda perlu menginstal atau meningkatkan Azure CLI, lihat Menginstal Azure CLI.
  • Pastikan bahwa identitas yang Anda gunakan untuk membuat kluster Anda memiliki izin minimum yang sesuai. Untuk informasi selengkapnya tentang akses dan identitas untuk AKS, lihat Opsi akses dan identitas untuk Azure Kubernetes Service (AKS).
  • Jika Anda memiliki beberapa langganan Azure, pilih ID langganan yang sesuai untuk penagihan dengan menggunakan perintah az account set. Untuk informasi selengkapnya, lihat Cara mengelola langganan Azure - Azure CLI.
  • Tergantung pada langganan Azure Anda, Anda mungkin perlu mengajukan permintaan peningkatan kuota vCPU untuk keluarga VM yang mendukung GPU yang Anda gunakan dalam panduan mulai cepat ini. Untuk informasi selengkapnya, lihat Meningkatkan kuota vCPU VM-family.
  • Ukuran VM dengan dukungan GPU berisi perangkat keras khusus yang tunduk pada harga yang lebih tinggi dan ketersediaan regional. Untuk informasi selengkapnya, lihat Ukuran komputer virtual yang dioptimalkan GPU.

aks-preview Menginstal ekstensi CLI

aks-preview Instal ekstensi CLI dengan menggunakan perintah az extension add.

az extension add --name aks-preview

Perbarui ekstensi untuk memastikan Anda memiliki versi terbaru dengan menggunakan perintah az extension update .

az extension update --name aks-preview

Mendaftarkan fitur pratinjau

ManagedGPUExperiencePreview Daftarkan bendera fitur di langganan Anda dengan menggunakan perintah az feature register.

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

Dibutuhkan beberapa menit agar status menampilkan Terdaftar. Verifikasi status pendaftaran dengan menggunakan perintah az feature show .

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

Saat status menunjukkan Terdaftar, segarkan pendaftaran penyedia sumber daya Microsoft.ContainerService dengan menggunakan perintah az provider register.

az provider register --namespace Microsoft.ContainerService

Menentukan variabel lingkungan

Tentukan variabel lingkungan berikut untuk digunakan di seluruh panduan kilat ini.

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"

Variabel RANDOM_STRING menyimpan string 10 digit acak. Nilai variabel RESOURCE_GROUP dan CLUSTER_NAME dikombinasikan dengan nilai RANDOM_STRING untuk membuat nama unik. Variabel GPU_NP menyimpan nama untuk kumpulan simpul GPU terkelola. Variabel GPU_VM_SIZE menyimpan ukuran VM yang diaktifkan GPU untuk kumpulan simpul. Variabel LOCATION memiliki nilai westus. Anda dapat menggunakan nilai variabel ini atau membuat nilai Anda sendiri. echo Gunakan perintah untuk melihat nilai variabel seperti echo $RANDOM_STRING.

Buat grup sumber daya

Grup sumber daya Azure adalah grup logis untuk menyebarkan dan mengelola sumber daya Azure. Saat Anda membuat grup sumber daya, tentukan lokasi. Lokasi ini adalah tempat metadata grup sumber daya disimpan dan tempat sumber daya Anda berjalan di Azure jika Anda tidak menentukan wilayah lain selama pembuatan sumber daya.

Gunakan perintah az group create untuk membuat grup sumber daya.

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

Contoh berikut menunjukkan hasilnya.

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

Membuat kluster AKS

Gunakan perintah az aks create untuk membuat kluster AKS. Contoh berikut membuat kluster dengan satu simpul sistem dan mengaktifkan identitas terkelola yang ditetapkan sistem.

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

Saat Anda membuat kluster baru, AKS secara otomatis membuat grup sumber daya kedua untuk menyimpan sumber daya AKS. Untuk informasi selengkapnya, lihat Mengapa dua grup sumber daya dibuat dengan AKS?

Kluster dalam contoh ini menentukan jumlah simpul satu untuk menghemat waktu dan sumber daya. Di lingkungan produksi, gunakan jumlah simpul tiga node atau lebih. Perintah az aks create akan menggunakan tiga node secara default jika Anda tidak menentukan jumlah node.

Menambahkan kumpulan simpul GPU terkelola

Tambahkan kumpulan simpul GPU terkelola berbasis Linux ke kluster Anda dengan menggunakan perintah az aks nodepool add . Parameter --enable-managed-gpu=true ini mengonfigurasi AKS untuk menginstal dan mengelola driver GPU NVIDIA, plugin perangkat Kubernetes NVIDIA, pengekspor metrik DCGM, dan komponen pemantauan kesehatan GPU di kumpulan simpul.

Contoh berikut menambahkan kumpulan simpul GPU terkelola dengan menggunakan sistem operasi Linux Ubuntu default.

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

Parameter --node-taints sku=gpu:NoSchedule mencegah beban kerja non-GPU tetap berada di luar kumpulan node GPU kecuali beban kerja tersebut menyertakan toleration yang sesuai.

Setelah Anda membuat kumpulan simpul, gunakan perintah az aks nodepool show untuk mengonfirmasi bahwa profil GPU terkelola diaktifkan.

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

Output Anda harus menyertakan nilai berikut.

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

Menyambungkan ke kluster

Untuk mengelola kluster Kube, gunakan klien baris perintah Kube, kubectl. Jika Anda menggunakan Azure Cloud Shell, kubectl sudah terpasang. Untuk menginstal kubectl secara lokal, gunakan perintah az aks install-cli .

  1. Konfigurasikan kubectl untuk terhubung ke kluster Kubernetes dengan menggunakan perintah az aks get-credentials . Perintah ini mengunduh kredensial dan mengonfigurasi CLI Kubernetes untuk menggunakannya.

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

  2. Verifikasi koneksi ke kluster Anda dengan menggunakan perintah kubectl get . Perintah ini mengembalikan daftar simpul kluster dan menunjukkan kumpulan simpul untuk setiap simpul.

    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. Verifikasi bahwa Kubernetes dapat menjadwalkan beban kerja GPU pada kumpulan simpul GPU terkelola.

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

    Output menunjukkan jumlah GPU yang dapat dialokasikan untuk setiap simpul di kumpulan simpul GPU terkelola.

    aks-gpunp-123456789-vmss000000  1

Mengaktifkan pengumpulan metrik GPU

Kumpulan simpul GPU terkelola mencakup pengekspor metrik DCGM. Untuk menyerap metrik GPU ke Azure Managed Prometheus, pertama-tama aktifkan layanan terkelola Azure Monitor untuk Prometheus pada kluster AKS Anda. Kemudian, buat ConfigMap yang mengaktifkan profil dcgmexporter scraping pada agen 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

Setelah Anda menerapkan ConfigMap ini, semua kumpulan simpul GPU NVIDIA yang ada dan baru pada kluster diekstraksi secara otomatis. Untuk melihat metrik GPU di Azure Managed Grafana, lihat Pengamatan GPU di Azure Kubernetes Service (AKS).

Menyebarkan aplikasi

Sebarkan beban kerja GPU untuk mengonfirmasi bahwa kumpulan simpul GPU terkelola dapat menjalankan aplikasi nyata. Contoh ini menjalankan Ollama, yang melayani model bahasa besar sumber terbuka kecil (Llama 3.2 1B) melalui API yang kompatibel dengan OpenAI. Ollama dibangun di atas llama.cpp, yang mendukung GPU NVIDIA T4 di pool node Standard_NC4as_T4_v3 yang digunakan oleh panduan mulai cepat ini.

Manifes berikut membuat Deployment dan Service. Deployment meminta satu GPU (nvidia.com/gpu: 1), menyertakan tolerasi untuk taint sku=gpu:NoSchedule, dan menggunakan pemilih node untuk menargetkan pool node GPU terkelola. Ketika kontainer dimulai, server Ollama dijalankan dan model llama3.2:1b diunduh agar pod siap menangani permintaan.

Sebarkan aplikasi dengan menggunakan perintah berikut.

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

Manifest ini ditujukan untuk pool gpunp node. Jika Anda menggunakan nilai yang berbeda untuk GPU_NP variabel, perbarui nilai pemilih kubernetes.azure.com/agentpool node agar cocok sebelum Anda menerapkan manifes.

Konfirmasikan bahwa penyebaran siap dengan menggunakan perintah status peluncuran kubectl . Pengunduhan model awal dapat memakan waktu beberapa menit.

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

Verifikasi bahwa pod berjalan pada kumpulan simpul GPU terkelola dengan menggunakan perintah kubectl get .

kubectl get pods -l app=ollama -o wide

Output Anda harus menunjukkan pod yang berjalan pada node di kumpulan gpunp simpul.

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>

Uji aplikasi

Teruskan port lokal ke Service dengan menggunakan perintah kubectl port-forward . Tetap jalankan perintah ini, dan buka terminal kedua untuk langkah-langkah yang tersisa.

kubectl port-forward svc/ollama 11434:11434

Di terminal kedua, kirim permintaan ke model dengan menggunakan titik akhir penyelesaian obrolan yang kompatibel dengan 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 mengembalikan respons JSON yang berisi jawaban yang dihasilkan, yang mengonfirmasi bahwa beban kerja melayani inferensi dari kumpulan simpul GPU terkelola.

Konfirmasikan bahwa model dimuat pada GPU dengan menggunakan ollama ps perintah . Kolom PROCESSOR menampilkan 100% GPU saat model berjalan pada GPU 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

Anda juga dapat melihat GPU langsung dari dalam pod dengan menggunakan nvidia-smi perintah .

kubectl exec deploy/ollama -- nvidia-smi

Saat Anda selesai menguji, hentikan kubectl port-forward proses dengan memilih Ctrl+C di terminalnya. Aplikasi dihapus saat Anda menghapus kluster di langkah berikutnya.

Hapus kluster tersebut

Jika Anda tidak berencana melakukan tutorial AKS, bersihkan sumber daya yang tidak perlu untuk menghindari biaya penagihan Azure. Anda dapat menghapus grup sumber daya, layanan kontainer, dan semua sumber daya terkait dengan menggunakan perintah az group delete .

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

Anda membuat kluster AKS dengan identitas terkelola yang ditetapkan oleh sistem, yang merupakan opsi identitas default yang digunakan dalam panduan mulai cepat ini. Platform mengelola identitas ini sehingga Anda tidak perlu menghapusnya secara manual.

Langkah berikutnya

Dalam panduan memulai cepat ini, Anda menerapkan kluster Kubernetes lalu menambahkan kumpulan node GPU terkelola berbasis Linux. Untuk informasi selengkapnya tentang node GPU terkelola dan metrik GPU, lihat artikel berikut ini:

Untuk mempelajari lebih lanjut tentang AKS dan melakukan contoh kode-ke-penyebaran lengkap, lanjutkan ke tutorial kluster Kubernetes.

Tutorial AKS

  • Last updated on