Menyebarkan Layanan Inferensi Terdistribusi Multi-Node - Container Service for Kubernetes

Topik ini menggunakan model Qwen3-32B sebagai contoh untuk menunjukkan cara menyebarkan layanan inferensi model terdistribusi multi-node dalam kluster Container Service for Kubernetes (ACK) menggunakan kerangka kerja vLLM dan SGLang.

Latar Belakang

Qwen3-32B
Qwen3-32B merupakan evolusi terbaru dari seri Qwen, menampilkan arsitektur padat 32,8B-parameter yang dioptimalkan untuk efisiensi penalaran dan kelancaran percakapan.
Fitur Utama:
- Kinerja Dual-Mode: Unggul dalam tugas kompleks seperti penalaran logis, matematika, dan pembuatan kode, sambil tetap sangat efisien untuk pembuatan teks umum.
- Kemampuan Canggih: Menunjukkan kinerja luar biasa dalam mengikuti instruksi, dialog multi-giliran, penulisan kreatif, dan penggunaan alat terbaik untuk tugas agen AI.
- Jendela Konteks Besar: Secara asli menangani hingga 32.000 token konteks, yang dapat diperluas hingga 131.000 token menggunakan teknologi YaRN.
- Dukungan Multibahasa: Memahami dan menerjemahkan lebih dari 100 bahasa, menjadikannya ideal untuk aplikasi global.
Untuk informasi lebih lanjut, lihat blog, GitHub, dan dokumentasi.
vLLM
vLLM adalah pustaka yang cepat dan ringan, dirancang untuk mengoptimalkan inferensi LLM serta penyajiannya, dengan secara signifikan meningkatkan throughput dan mengurangi latensi.
Optimasi Inti:
- PagedAttention: Algoritma perhatian inovatif yang secara efisien mengelola cache Key-Value (KV) untuk meminimalkan pemborosan memori dan meningkatkan throughput.
- Inferensi Canggih: Meningkatkan kecepatan dan pemanfaatan dengan pengelompokan berkelanjutan, dekoding spekulatif, dan percepatan grafik CUDA/HIP.
- Rentang Paralelisme Luas: Mendukung Tensor Parallelism (TP), Pipeline Parallelism (PP), Data Parallelism (DP), dan Expert Parallelism (EP) untuk penskalaan di beberapa GPU.
- Dukungan Kuantisasi: Kompatibel dengan format kuantisasi populer seperti GPTQ, AWQ, INT4/8, dan FP8 untuk mengurangi jejak memori model.
Kompatibilitas Luas:
- Perangkat Keras dan Model: Berjalan pada GPU NVIDIA, AMD, dan Intel serta mendukung model utama dari Hugging Face dan ModelScope (seperti Qwen, Llama, Deepseek, dan E5-Mistral).
- API Standar: Menyediakan API yang kompatibel dengan OpenAI, sehingga mudah diintegrasikan ke dalam aplikasi yang ada.
Untuk informasi lebih lanjut, lihat vLLM GitHub.
SGLang
SGLang adalah mesin inferensi yang menggabungkan backend berkinerja tinggi dan frontend fleksibel, dirancang khusus untuk beban kerja LLM serta multimodal.
Backend Berkinerja Tinggi:
- Caching Canggih: Fitur RadixAttention (cache awalan efisien) dan PagedAttention untuk memaksimalkan throughput selama tugas inferensi kompleks.
- Eksekusi Efisien: Menggunakan pengelompokan berkelanjutan, dekoding spekulatif, pemisahan PD, dan pengelompokan multi-LoRA untuk melayani banyak pengguna dan model fine-tuned secara efisien.
- Paralelisme Penuh dan Kuantisasi: Mendukung TP, PP, DP, dan EP paralelisme, bersama dengan berbagai metode kuantisasi (FP8, INT4, AWQ, GPTQ).
Frontend yang fleksibel:
- Antarmuka Pemrograman Kuat: Memungkinkan pengembang dengan mudah membangun aplikasi kompleks dengan fitur seperti generasi berantai, alur kontrol, dan pemrosesan paralel.
- Multimodal dan Interaksi Eksternal: Secara asli mendukung input multimodal (seperti teks dan gambar) dan memungkinkan interaksi dengan alat eksternal, menjadikannya ideal untuk alur kerja agen tingkat lanjut.
- Dukungan Model Luas: Mendukung model generatif (Qwen, DeepSeek, Llama), model penyematan (E5-Mistral), dan model hadiah (Skywork).
Untuk informasi lebih lanjut, lihat SGLang GitHub.

Penyebaran terdistribusi
Seiring dengan bertambahnya ukuran LLM, parameter mereka sering kali melebihi memori GPU tunggal. Untuk menjalankan model besar ini, berbagai strategi paralelisasi digunakan untuk membagi tugas inferensi menjadi beberapa subtugas. Subtugas ini dialokasikan di seluruh GPU. Hasilnya kemudian digabungkan untuk menyelesaikan tugas inferensi LLM dengan cepat. Strategi paralelisasi umum:
Data Parallelism (DP)
Setiap GPU menyimpan salinan lengkap model tetapi memproses batch data yang berbeda. Ini adalah strategi paling sederhana dan paling umum.
Tensor Parallelism (TP)
Membagi matriks bobot model (tensor) di beberapa GPU. Setiap GPU hanya menyimpan sebagian dari bobot model dan menghitung pada bagian tersebut.
Pipeline Parallelism (PP)
Mengalokasikan lapisan model yang berbeda ke GPU yang berbeda, menciptakan pipa. Output satu lapisan pada GPU dilewatkan sebagai input ke lapisan berikutnya pada GPU lain.
Expert Parallelism (EP)
Model dengan arsitektur Mixture-of-Experts (MoE) berisi banyak sub-model "ahli". Hanya sebagian dari ahli ini yang diaktifkan untuk memproses setiap permintaan. Oleh karena itu, sub-model ahli ini dapat disimpan di GPU yang berbeda. Ketika beban kerja inferensi memerlukan ahli tertentu, data diarahkan ke GPU yang relevan.

Prasyarat

Anda memiliki kluster ACK yang dikelola yang menjalankan Kubernetes 1.28 atau lebih baru dengan dua atau lebih node yang dipercepat GPU. Setiap node yang dipercepat GPU harus memiliki setidaknya 32 GB memori. Untuk instruksi, lihat Buat Kluster ACK yang Dikelola dan Tambahkan Node yang Dipercepat GPU ke Kluster.
Tipe instans ecs.gn8is.4xlarge direkomendasikan. Untuk detail, lihat Instansi Komputasi yang Dioptimalkan dengan Percepatan GPU Family gn8is.
Komponen LeaderWorkerSet versi V0.6.0 atau lebih baru telah diinstal. Anda dapat menginstalnya melalui Konsol ACK:
1. Masuk ke Konsol ACK.
2. Di panel navigasi di sebelah kiri, klik Clusters, lalu klik nama kluster yang Anda buat.
3. Di panel navigasi di sebelah kiri, klik Applications > Helm. Di halaman Helm, klik Deploy.
4. Pada langkah Basic Information, masukkan Application Name dan Namespace. Temukan lws di bagian Chart, lalu klik Next. Dalam contoh ini, nama aplikasi (lws) dan namespace (lws-system) digunakan.
5. Pada langkah Parameters, pilih versi terbaru dari Chart Version, lalu klik OK untuk menginstal lws.

Penyebaran model

Langkah 1: Persiapkan file model Qwen3-32B

Jalankan perintah berikut untuk mengunduh model Qwen3-32B dari ModelScope.
Jika plugin git-lfs belum diinstal, jalankan yum install git-lfs atau apt-get install git-lfs untuk menginstalnya. Untuk metode instalasi lainnya, lihat Menginstal Git Large File Storage.
```
git lfs install
GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/Qwen/Qwen3-32B.git
cd Qwen3-32B/
git lfs pull
```
Masuk ke Konsol OSS dan catat nama bucket Anda. Jika Anda belum membuatnya, lihat Buat Bucket. Buat direktori di Object Storage Service (OSS) dan unggah model ke dalamnya.
Untuk informasi lebih lanjut tentang cara menginstal dan menggunakan ossutil, lihat Instal ossutil.
```
ossutil mkdir oss://<your-bucket-name>/Qwen3-32B
ossutil cp -r ./Qwen3-32B oss://<your-bucket-name>/Qwen3-32B
```

Buat volume persisten (PV) bernama llm-model dan klaim volume persisten (PVC) untuk kluster Anda. Untuk instruksi terperinci, lihat Buat PV dan PVC.

Contoh menggunakan konsol

Buat PV

Masuk ke Konsol ACK. Di panel navigasi di sebelah kiri, klik Clusters.
Di halaman Clusters, temukan kluster yang Anda inginkan dan klik namanya. Di panel di sebelah kiri, pilih Volumes > Persistent Volumes.
Di halaman PersistentVolumes, klik Create di pojok kanan atas.

Di kotak dialog Create PersistentVolume, konfigurasikan parameter.

Tabel berikut menjelaskan konfigurasi dasar PV contoh:

Parameter	Deskripsi
PV Type	Dalam contoh ini, pilih OSS.
Volume Name	Dalam contoh ini, masukkan llm-model.
Access Certificate	Konfigurasikan ID AccessKey dan rahasia AccessKey yang digunakan untuk mengakses bucket OSS.
Bucket ID	Pilih bucket OSS yang Anda buat di langkah sebelumnya.
OSS Path	Masukkan path tempat model berada, seperti `/Qwen3-32B`.

Buat PVC

Di halaman Clusters, temukan kluster yang Anda inginkan dan klik namanya. Di panel di sebelah kiri, pilih Volumes > Persistent Volume Claims.
Di halaman PersistentVolumeClaims, klik Create di pojok kanan atas.

Di halaman Create PersistentVolumeClaim, masukkan parameter yang diperlukan.

Tabel berikut menjelaskan konfigurasi dasar PVC contoh.

Item Konfigurasi	Deskripsi
PVC Type	Dalam contoh ini, pilih OSS.
Name	Dalam contoh ini, masukkan llm-model.
Allocation Mode	Dalam contoh ini, pilih Existing Volumes.
Existing Volumes	Klik hyperlink Select PV dan pilih PV yang Anda buat.

Contoh menggunakan kubectl

Gunakan template YAML berikut untuk membuat file bernama llm-model.yaml, berisi konfigurasi untuk Secret, PV statis, dan PVC statis.

apiVersion: v1
kind: Secret
metadata:
  name: oss-secret
stringData:
  akId: <your-oss-ak> # ID AccessKey yang digunakan untuk mengakses bucket OSS.
  akSecret: <your-oss-sk> # Rahasia AccessKey yang digunakan untuk mengakses bucket OSS.
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: llm-model
  labels:
    alicloud-pvname: llm-model
spec:
  capacity:
    storage: 30Gi 
  accessModes:
    - ReadOnlyMany
  persistentVolumeReclaimPolicy: Retain
  csi:
    driver: ossplugin.csi.alibabacloud.com
    volumeHandle: llm-model
    nodePublishSecretRef:
      name: oss-secret
      namespace: default
    volumeAttributes:
      bucket: <your-bucket-name> # Nama bucket.
      url: <your-bucket-endpoint> # Endpoint, seperti oss-cn-hangzhou-internal.aliyuncs.com.
      otherOpts: "-o umask=022 -o max_stat_cache_size=0 -o allow_other"
      path: <your-model-path> # Dalam contoh ini, path adalah /Qwen3-32B/.
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: llm-model
spec:
  accessModes:
    - ReadOnlyMany
  resources:
    requests:
      storage: 30Gi
  selector:
    matchLabels:
      alicloud-pvname: llm-model

Buat Secret, PV statis, dan PVC statis.
```
kubectl create -f llm-model.yaml
```

Langkah 2: Sebarkan layanan inferensi terdistribusi

Topik ini menggunakan beban kerja LeaderWorkerSet untuk menyebarkan layanan inferensi pada dua node yang dipercepat GPU dengan ukuran TP 2.

Sebarkan dengan vLLM

Buat file bernama vllm_multi.yaml.

Perluas untuk Melihat Template YAML

apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: vllm-multi-nodes
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
          # for prometheus to scrape
          alibabacloud.com/inference-workload: vllm-multi-nodes
          alibabacloud.com/inference_backend: vllm
      spec:
        volumes:
          - name: model
            persistentVolumeClaim:
              claimName: llm-model
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 15Gi
        containers:
          - name: vllm-leader
            image: kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:v0.10.0
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE); python3 -m vllm.entrypoints.openai.api_server --port 8000 --model /models/Qwen3-32B --tensor-parallel-size 2"
            resources:
              limits:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
              requests:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
            ports:
              - containerPort: 8000
                name: http
            readinessProbe:
              initialDelaySeconds: 30
              periodSeconds: 10
              tcpSocket:
                port: 8000
            volumeMounts:
              - mountPath: /models/Qwen3-32B
                name: model
              - mountPath: /dev/shm
                name: dshm
    workerTemplate:
      spec:
        volumes:
          - name: model
            persistentVolumeClaim:
              claimName: llm-model
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 15Gi
        containers:
          - name: vllm-worker
            image: kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:v0.10.0
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
            resources:
              limits:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
              requests:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
            ports:
              - containerPort: 8000
            volumeMounts:
              - mountPath: /models/Qwen3-32B
                name: model
              - mountPath: /dev/shm
                name: dshm
---
apiVersion: v1
kind: Service
metadata:
  name: multi-nodes-service
spec:
  type: ClusterIP
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 8000
  selector:
    alibabacloud.com/inference-workload: vllm-multi-nodes
    role: leader

Jalankan perintah berikut untuk menyebarkan layanan inferensi LLM multi-node menggunakan kerangka kerja vLLM:
```
kubectl create -f vllm_multi.yaml
```

Sebarkan dengan SGLang

Buat file bernama sglang_multi.yaml.

Perluas untuk Melihat Template YAML

apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: sglang-multi-nodes
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
          # for prometheus to scrape
          alibabacloud.com/inference-workload: sglang-multi-nodes
          alibabacloud.com/inference_backend: sglang
      spec:
        containers:
          - name: sglang-leader
            image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/anolis-docker-images/docker-temp:0.3.4.post2-sglang0.4.10.post2-pytorch2.7.1.8-cuda12.8.1-py312-alinux3.2104
            command:
              - sh
              - -c
              - "python3 -m sglang.launch_server --model-path /models/Qwen3-32B --tp 2 --dist-init-addr $(LWS_LEADER_ADDRESS):20000 \
              --nnodes $(LWS_GROUP_SIZE) --node-rank $(LWS_WORKER_INDEX) --trust-remote-code --host 0.0.0.0 --port 8000 --enable-metrics"
            resources:
              limits:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
              requests:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
            ports:
              - containerPort: 8000
                name: http
            readinessProbe:
              tcpSocket:
                port: 8000
              initialDelaySeconds: 30
              periodSeconds: 10
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models/Qwen3-32B
                name: model
        volumes:
            - name: model
              persistentVolumeClaim:
                claimName: llm-model
            - name: dshm
              emptyDir:
                medium: Memory
                sizeLimit: 15Gi
    workerTemplate:
      spec:
        containers:
          - name: sglang-worker
            image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/anolis-docker-images/docker-temp:0.3.4.post2-sglang0.4.10.post2-pytorch2.7.1.8-cuda12.8.1-py312-alinux3.2104
            command:
              - sh
              - -c
              - "python3 -m sglang.launch_server --model-path /models/Qwen3-32B --tp 2 --dist-init-addr $(LWS_LEADER_ADDRESS):20000 \
              --nnodes $(LWS_GROUP_SIZE) --node-rank $(LWS_WORKER_INDEX) --trust-remote-code"
            resources:
              limits:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
              requests:
                nvidia.com/gpu: "1"
                memory: "24Gi"
                cpu: "8"
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models/Qwen3-32B
                name: model
        volumes:
            - name: model
              persistentVolumeClaim:
                claimName: llm-model
            - name: dshm
              emptyDir:
                medium: Memory
                sizeLimit: 15Gi
---
apiVersion: v1
kind: Service
metadata:
  name: multi-nodes-service
spec:
  selector:
    alibabacloud.com/inference-workload: sglang-multi-nodes
    role: leader
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Jalankan perintah berikut untuk menyebarkan layanan inferensi LLM multi-node menggunakan kerangka kerja SGLang:
```
kubectl create -f sglang_multi.yaml
```

Langkah 3: Validasi layanan inferensi

Jalankan perintah berikut untuk menetapkan penerusan port antara layanan inferensi dan lingkungan lokal Anda.
Penting
Penerusan port yang ditetapkan oleh kubectl port-forward kurang memiliki keandalan, keamanan, dan skalabilitas tingkat produksi. Ini cocok untuk tujuan pengembangan dan debugging saja dan tidak boleh digunakan dalam lingkungan produksi. Untuk solusi jaringan siap produksi di kluster Kubernetes, lihat Manajemen Ingress.
```
kubectl port-forward svc/multi-nodes-service 8000:8000
```
Keluaran yang Diharapkan:
```
Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
```

Jalankan perintah berikut untuk mengirim permintaan inferensi sampel ke layanan:

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json"  -d '{"model": "/models/Qwen3-32B", "messages": [{"role": "user", "content": "Test it"}], "max_tokens": 30, "temperature": 0.7, "top_p": 0.9, "seed": 10}'

Keluaran yang Diharapkan:

{"id":"chatcmpl-ee6b347a8bd049f9a502669db0817938","object":"chat.completion","created":1753685847,"model":"/models/Qwen3-32B","choices":[{"index":0,"message":{"role":"assistant","reasoning_content":null,"content":"<think>\nOkay, the user sent "Test it". I need to confirm their request first. They might be testing my functionality or want to see my reaction.","tool_calls":[]},"logprobs":null,"finish_reason":"length","stop_reason":null}],"usage":{"prompt_tokens":10,"total_tokens":40,"completion_tokens":30,"prompt_tokens_details":null},"prompt_logprobs":null,"kv_transfer_params":null}

Keluaran ini mengonfirmasi bahwa layanan model terdistribusi berfungsi dengan baik dan dapat menghasilkan respons.

Latar Belakang

Qwen3-32B

vLLM

SGLang

Penyebaran terdistribusi

Data Parallelism (DP)

Tensor Parallelism (TP)

Pipeline Parallelism (PP)

Expert Parallelism (EP)