Menyebarkan layanan inferensi LLM mandiri - Container Service for Kubernetes

Topik ini menggunakan model Qwen3-32B sebagai contoh untuk menunjukkan cara menyebarkan layanan inferensi model bahasa besar (LLM) mandiri di kluster Container Service for Kubernetes (ACK) menggunakan vLLM dan SGLang.

Latar Belakang

Qwen3-32B
Qwen3-32B merupakan evolusi terbaru dari seri Qwen, dengan arsitektur padat 32,8 miliar 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 di kelasnya 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 dan penyajian, serta 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 akselerasi 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 mainstream 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.
- Efisiensi eksekusi: 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 paralelisme TP, PP, DP, dan EP, 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.

Prasyarat

Kluster Container Service for Kubernetes (ACK) yang menjalankan Kubernetes 1.22 atau lebih baru telah dibuat, dengan node yang dipercepat GPU ditambahkan. Untuk informasi lebih lanjut, lihat Buat kluster ACK yang dikelola dan Tambahkan node GPU ke kluster.

Proses yang dijelaskan dalam topik ini memerlukan lebih dari 64 GB memori GPU. Tipe instans ecs.gn8is-2x.8xlarge direkomendasikan. Untuk detailnya, lihat Instansi komputasi yang dioptimalkan dengan percepatan GPU family gn8is.

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 kiri, klik Clusters.
Di halaman Clusters, temukan kluster yang Anda inginkan dan klik namanya. Di panel navigasi kiri, pilih Volumes > Persistent Volumes.
Di halaman Volumes, klik Create di pojok kanan atas.

Di kotak dialog Create Volume, 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 navigasi kiri, pilih Volumes > Persistent Volume Claims.
Di halaman PersistentVolumeClaims, klik Create di pojok kanan atas.

Di halaman Create PersistentVolumeClaim, konfigurasikan parameter.

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

Gunakan template YAML berikut untuk menyebarkan layanan inferensi LLM mandiri di ACK menggunakan mesin inferensi vLLM dan SGLang.

Sebarkan layanan inferensi mandiri dengan vLLM

Buat file bernama vllm.yaml.

Perluas untuk melihat template YAML

apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    # untuk prometheus scrape
    alibabacloud.com/inference-workload: vllm-inference
    alibabacloud.com/inference_backend: vllm
  name: vllm-inference
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      alibabacloud.com/inference-workload: vllm-inference
      alibabacloud.com/inference_backend: vllm
  template:
    metadata:
      labels:
        alibabacloud.com/inference-workload: vllm-inference
        alibabacloud.com/inference_backend: vllm
    spec:
      volumes:
      - name: model
        persistentVolumeClaim:
          claimName: llm-model
      - name: dshm
        emptyDir:
          medium: Memory
          sizeLimit: 15Gi
      containers:
      - command:
        - sh
        - -c
        - vllm serve /models/Qwen3-32B --port 8000 --trust-remote-code --max-model-len 2048 --gpu-memory-utilization 0.85 --tensor-parallel-size 2
#        image: vllm/vllm-openai:v0.10.0
        image: kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:v0.10.0
        name: vllm
        ports:
        - containerPort: 8000
          name: http
        readinessProbe:
          initialDelaySeconds: 30
          periodSeconds: 10
          tcpSocket:
            port: 8000
        resources:
          limits:
            nvidia.com/gpu: "2"
            memory: "16Gi"
            cpu: "4"
          requests:
            nvidia.com/gpu: "2"
            memory: "16Gi"
            cpu: "4"
        volumeMounts:
        - mountPath: /models/Qwen3-32B
          name: model
        - mountPath: /dev/shm
          name: dshm
---
apiVersion: v1
kind: Service
metadata:
  name: inference-service
spec:
  type: ClusterIP
  ports:
    - port: 8000
      protocol: TCP
      targetPort: 8000
  selector:
    alibabacloud.com/inference-workload: vllm-inference

Sebarkan layanan inferensi LLM mandiri menggunakan kerangka kerja vLLM.
```
kubectl create -f vllm.yaml
```

Sebarkan layanan inferensi mandiri dengan SGLang

Buat file bernama sglang.yaml.

Perluas untuk melihat template YAML

apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    # untuk prometheus scrape
    alibabacloud.com/inference-workload: sgl-inference
    alibabacloud.com/inference_backend: sglang
  name: sgl-inference
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      alibabacloud.com/inference-workload: sgl-inference
      alibabacloud.com/inference_backend: sglang
  template:
    metadata:
      labels:
        alibabacloud.com/inference-workload: sgl-inference
        alibabacloud.com/inference_backend: sglang
    spec:
      volumes:
        - name: model
          persistentVolumeClaim:
            claimName: llm-model
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 15Gi
      containers:
        - command:
            - sh
            - -c
            - "python3 -m sglang.launch_server --model-path /models/Qwen3-32B --tp 2 --trust-remote-code  --context-length 2048 --host 0.0.0.0 --port 8000 --enable-metrics"
          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
          name: sglang
          ports:
            - containerPort: 8000
              name: http
          readinessProbe:
            initialDelaySeconds: 30
            periodSeconds: 10
            tcpSocket:
              port: 8000
          resources:
            limits:
              nvidia.com/gpu: "2"
              memory: "16Gi"
              cpu: "4"
            requests:
              nvidia.com/gpu: "2"
              memory: "16Gi"
              cpu: "4"
          volumeMounts:
            - mountPath: /models/Qwen3-32B
              name: model
            - mountPath: /dev/shm
              name: dshm
---
apiVersion: v1
kind: Service
metadata:
  name: inference-service
spec:
  type: ClusterIP
  ports:
    - port: 8000
      protocol: TCP
      targetPort: 8000
  selector:
    alibabacloud.com/inference-workload: sgl-inference

Sebarkan layanan inferensi LLM mandiri menggunakan kerangka kerja SGLang.
```
kubectl create -f sglang.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 di lingkungan produksi. Untuk solusi jaringan siap-produksi di kluster Kubernetes, lihat Pengelolaan Ingress.
```
kubectl port-forward svc/inference-service 8000:8000
```
Output yang diharapkan:
```
Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
```

Jalankan perintah berikut untuk mengirim permintaan sampel ke layanan inferensi model:

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

Output yang diharapkan:

{"id":"chatcmpl-d490443cd4094bdf86a1a49144f77444","object":"chat.completion","created":1753684011,"model":"/models/Qwen3-32B","choices":[{"index":0,"message":{"role":"assistant","reasoning_content":null,"content":"<think>\nOkay, the user sent \"Test\". 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}

Output tersebut menunjukkan bahwa model dapat menghasilkan respons berdasarkan input yang diberikan, yang dalam contoh ini adalah pesan uji.

Referensi

Konfigurasikan pemantauan Prometheus untuk layanan inferensi LLM
Dalam lingkungan produksi, memantau kesehatan dan kinerja layanan LLM sangat penting untuk menjaga stabilitas. Dengan mengintegrasikan dengan Layanan Terkelola untuk Prometheus, Anda dapat mengumpulkan metrik terperinci untuk:
- Mendeteksi kegagalan dan hambatan kinerja.
- Memecahkan masalah dengan data waktu nyata.
- Menganalisis tren kinerja jangka panjang untuk mengoptimalkan alokasi sumber daya.
Konfigurasikan penskalaan otomatis untuk layanan inferensi LLM
Beban kerja LLM sering berfluktuasi, menyebabkan kelebihan sumber daya atau kinerja buruk selama lonjakan lalu lintas. Penyekala Pod Horizontal (HPA) Kubernetes, yang terintegrasi dengan ack-alibaba-cloud-metrics-adapter, menangani masalah ini dengan:
- Secara otomatis menskalakan pod Anda berdasarkan pemanfaatan GPU, CPU, dan memori waktu nyata.
- Mengizinkan Anda mendefinisikan metrik khusus untuk pemicu skala yang lebih canggih.
- Memastikan ketersediaan tinggi selama permintaan puncak sambil mengurangi biaya selama periode idle.
Implementasikan perutean cerdas dan manajemen lalu lintas menggunakan Gateway dengan Ekstensi Inferensi
ACK Gateway dengan Ekstensi Inferensi adalah pengontrol ingress yang canggih, dibangun di atas API Gateway Kubernetes, yang menyederhanakan dan mengoptimalkan perutean untuk beban kerja AI/ML. Fitur utamanya meliputi:
- Penyeimbangan beban berbasis model: Menyediakan kebijakan penyeimbangan beban yang dioptimalkan untuk memastikan distribusi efisien permintaan inferensi.
- Perutean model cerdas: Mengarahkan lalu lintas berdasarkan nama model dalam payload permintaan. Ini ideal untuk mengelola beberapa model fine-tuned (misalnya, varian LoRA berbeda) di balik satu titik akhir atau untuk menerapkan pemisahan lalu lintas untuk rilis canary.
- Prioritas permintaan: Memberikan level prioritas ke model berbeda, memastikan bahwa permintaan ke model paling kritis diproses pertama, menjamin kualitas layanan.
Percepat pemuatan model dengan caching terdistribusi Fluid
File model besar (>10 GB) yang disimpan di layanan seperti OSS atau File Storage NAS dapat menyebabkan cold start pada pod karena waktu unduh yang lama. Fluid menyelesaikan masalah ini dengan menyediakan lapisan caching terdistribusi di seluruh node kluster Anda, sehingga secara signifikan mempercepat pemuatan model melalui dua cara utama:
- Throughput data dipercepat: Fluid mengumpulkan kapasitas penyimpanan dan lebar pita jaringan semua node dalam kluster. Ini menciptakan lapisan data kecepatan tinggi, paralel yang mengatasi hambatan menarik file besar dari satu sumber remote tunggal.
- Latensi I/O dikurangi: Dengan menyimpan file model langsung pada node komputasi tempat mereka dibutuhkan, Fluid memberikan aplikasi akses lokal, hampir instan ke data. Mekanisme baca yang dioptimalkan ini menghilangkan penundaan panjang yang terkait dengan I/O jaringan.