Men-deploy layanan LLM dan menerapkan perutean pintar menggunakan gerbang inferensi AI di Knative - Container Service for Kubernetes

Komponen ACK Gateway with Inference Extension dibangun di atas Kubernetes Gateway API dan spesifikasi Inference Extension. Dikombinasikan dengan arsitektur serverless Knative, solusi ini menyederhanakan pengelolaan layanan inferensi AI generatif, mendukung perutean dan penyeimbangan beban Lapisan 7 yang efisien di berbagai beban kerja layanan inferensi, serta memungkinkan skalabilitas elastis sumber daya GPU berdasarkan konkurensi permintaan.

Cara kerja

Gateway with Inference Extension memperluas kemampuan Gateway API untuk skenario inferensi AI melalui Custom Resource Definitions (CRDs) berikut:

InferencePool: Mengelompokkan secara logis sumber daya layanan model AI. Resource ini merepresentasikan sekelompok Pod dengan konfigurasi komputasi, tipe akselerator, model dasar, dan server model yang sama. InferencePool dapat mencakup beberapa node untuk menyediakan ketersediaan tinggi.
InferenceObjective: Menentukan properti dan tujuan layanan model, termasuk nama model yang dilayani oleh Pod dalam InferencePool serta tingkat kekritisan-nya. Beban kerja yang ditandai sebagai Critical menerima pemrosesan prioritas.

Di Knative, mengaktifkan anotasi AI gateway memungkinkan Knative Service terintegrasi secara otomatis dengan kemampuan ini untuk mencapai penjadwalan trafik cerdas.

Persiapan

Anda telah membuat kluster managed ACK Pro yang memenuhi persyaratan berikut:
- Knative telah diterapkan. Untuk informasi selengkapnya, lihat Deploy and manage Knative components.
- Komponen Gateway API telah diinstal.
- Komponen Gateway with Inference Extension versi v1.4.0-apsara.4 atau yang lebih baru telah diinstal. Saat menginstal komponen tersebut, pilih Enable Gateway API Inference Extension.
- Kluster berisi node GPU dengan memori minimal 32 GiB per node. Topik ini menggunakan model Qwen1.5-4B sebagai contoh. Tambahkan label spesifik pada node menggunakan Node Label untuk menentukan versi driver. Atur Key menjadi ack.aliyun.com/nvidia-driver-version dan Value menjadi 550.144.03.
  Disarankan menggunakan versi driver GPU 550.144.03 atau yang lebih baru. Untuk informasi selengkapnya tentang cara mengonfigurasi versi driver, lihat Customize the GPU driver version of a node by specifying a version number.
Anda telah membuat bucket OSS.
Disarankan memilih wilayah yang sama dengan kluster Anda untuk menghindari biaya lalu lintas jaringan internal dan mengurangi penundaan transmisi cross-region.

Langkah 1: Aktifkan dukungan Gateway API di Knative

Ubah konfigurasi jaringan Knative untuk menetapkan Gateway API sebagai controller Ingress.

Edit ConfigMap config-network.

kubectl edit configmap config-network -n knative-serving

Pada bidang data, ubah ingress.class lalu simpan perubahan.

apiVersion: v1
data:
  ...
  # Ubah ingress.class untuk menggunakan Gateway API sebagai Ingress Controller.
  ingress.class: gateway-api.ingress.networking.knative.dev 
  ...
kind: ConfigMap
metadata:
  name: config-network
  namespace: knative-serving
  ...

Periksa apakah modifikasi telah berlaku.

kubectl get configmap config-network -n knative-serving -o yaml | grep "ingress.class"

Output yang diharapkan:

  ingress.class: gateway-api.ingress.networking.knative.dev

Langkah 2: Buat resource inference gateway

Buat resource Gateway untuk mendengarkan permintaan eksternal. Contoh ini mengonfigurasi gateway agar mendengarkan pada port 8888.

Buat file konfigurasi gateway bernama knative-gateway.yaml.

kind: Gateway
apiVersion: gateway.networking.k8s.io/v1
metadata:
  name: knative-gateway
  namespace: knative-serving
spec:
  gatewayClassName: ack-gateway
  listeners:
  - name: default
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
  - name: llm-gw
    protocol: HTTP
    # Port pendengar untuk layanan inferensi.
    port: 8888  
    allowedRoutes:
      namespaces:
        from: All

Terapkan resource gateway.
```
kubectl apply -f knative-gateway.yaml
```

Periksa status gateway.

kubectl get gateway knative-gateway -n knative-serving

Pada output, pastikan bahwa PROGRAMMED bernilai True dan alamat IP telah ditetapkan pada bidang ADDRESS.

NAME              CLASS         ADDRESS        PROGRAMMED   AGE
knative-gateway   ack-gateway   47.XX.XX.198   True         22s

Langkah 3: Siapkan data model dan konfigurasikan penyimpanan

Untuk menghindari pengunduhan ulang model setiap kali kontainer dimulai, pasang data model menggunakan volume persisten statis OSS.

1. Unduh model dan unggah ke OSS

Langkah ini menggunakan model Qwen1.5-4B-Chat sebagai contoh. Anda dapat sementara membeli instans ECS untuk menyiapkan data model lalu melepaskannya setelah digunakan.

Unduh model ke mesin lokal.

# Instal Git LFS.
sudo yum install -y git git-lfs
git lfs install

# Klon repositori model dan lewati smudge untuk mempercepat proses.
GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/qwen/Qwen1.5-4B-Chat.git

# Unduh file besar sesungguhnya.
cd Qwen1.5-4B-Chat
git lfs pull

Gunakan ossutil untuk mengunggah model ke bucket OSS.

Ganti <Bucket-Name> dengan nama bucket OSS Anda yang sebenarnya.

Untuk menginstal ossutil, lihat Install ossutil.

# Buat direktori.
ossutil mkdir oss://<Bucket-Name>/models/Qwen1.5-4B-Chat

# Unggah file. Opsi -r menunjukkan unggah rekursif.
ossutil cp -r ./ oss://<Bucket-Name>/models/Qwen1.5-4B-Chat

2. Konfigurasikan PV dan PVC

Untuk meningkatkan performa pemuatan model, contoh ini membuat volume persisten statis OSS. Untuk informasi selengkapnya, lihat Use a static ossfs 1.0 persistent volume.

Buat kredensial akses OSS (Secret).

Ganti <AccessKey-ID> dan <AccessKey-Secret> dengan informasi Anda yang sebenarnya.

kubectl create secret generic oss-secret \
  --from-literal=akId='<AccessKey-ID>' \
  --from-literal=akSecret='<AccessKey-Secret>' \
  --namespace default

Buat file bernama oss-storage.yaml.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: llm-model
  labels:
    alicloud-pvname: llm-model
spec:
  capacity:
    storage: 30Gi
  # Mode akses.
  accessModes:
    - ReadWriteMany            
  persistentVolumeReclaimPolicy: Retain
  storageClassName: oss
  csi:
    driver: ossplugin.csi.alibabacloud.com
    volumeHandle: llm-model
    # Ambil Informasi AccessKey dari objek Secret.
    nodePublishSecretRef:
      name: oss-secret
      namespace: default
    volumeAttributes:
      # Ganti dengan nama bucket OSS Anda yang sebenarnya.
      bucket: "<Your-Bucket-Name>"         
      # Endpoint wilayah tempat bucket berada.
      url: "http://oss-cn-hangzhou-internal.aliyuncs.com" 
      # Path relatif di OSS.
      path: "/models/Qwen1.5-4B-Chat"     
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: llm-model
  namespace: default
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: oss
  resources:
    requests:
      # Nyatakan kapasitas penyimpanan. Nilainya tidak boleh lebih besar dari ukuran total volume.
      storage: 30Gi
  selector:
    matchLabels:
      # Cocokkan persis PV berdasarkan label-nya.
      alicloud-pvname: llm-model

Terapkan PV dan PVC.
```
kubectl apply -f oss-storage.yaml
```

Langkah 4: Deploy layanan inferensi Knative

Buat Knative Service, aktifkan fitur AI gateway, dan konfigurasikan engine vLLM untuk inferensi.

Buat file konfigurasi layanan bernama qwen-service.yaml.

Deskripsi konfigurasi utama:

knative.aliyun.com/ai-gateway: inference: Mengaktifkan ekstensi inference gateway.
autoscaling.knative.dev/metric: "concurrency": Melakukan penskalaan otomatis berdasarkan jumlah permintaan konkuren.

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: qwen
  namespace: default
  annotations:
    # Aktifkan AI inference gateway.
    knative.aliyun.com/ai-gateway: inference          
    knative.aliyun.com/ai-gateway-inference-priority: "1"
  labels:
    release: qwen
spec:
  template:
    metadata:
      annotations:
        # Metrik penskalaan: concurrency.
        autoscaling.knative.dev/metric: "concurrency" 
        # Target konkurensi.
        autoscaling.knative.dev/target: "2"           
        # Jumlah maksimum instans.
        autoscaling.knative.dev/max-scale: "3"        
        # Jumlah minimum instans. Kontainer model besar membutuhkan waktu lama untuk memulai. Pertahankan setidaknya satu instans resident untuk menghindari timeout permintaan.
        autoscaling.knative.dev/min-scale: "1"        
      labels:
        release: qwen
    spec:
      containers:
      - name: vllm-container
        image: ac2-registry.cn-hangzhou.cr.aliyuncs.com/ac2/vllm:0.4.1-ubuntu22.04
        command:
        - sh
        - -c
        - python3 -m vllm.entrypoints.openai.api_server --port 8080 --trust-remote-code --model /models/Qwen1.5-4B-Chat/ --gpu-memory-utilization 0.95 --max-model-len 8192 --dtype half
        ports:
        - containerPort: 8080
        readinessProbe:
          tcpSocket:
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 5
        resources:
          limits:
            cpu: "32"
            memory: 64Gi
            # Minta sumber daya GPU.
            nvidia.com/gpu: "1" 
          requests:
            cpu: "8"
            memory: 32Gi
            nvidia.com/gpu: "1"
        volumeMounts:
        # Path mount harus sama dengan parameter model dalam perintah start.
        - mountPath: /models/Qwen1.5-4B-Chat 
          name: llm-model
      volumes:
      - name: llm-model
        persistentVolumeClaim:
          claimName: llm-model

Terapkan layanan.
```
kubectl apply -f qwen-service.yaml
```
Periksa progres deployment. Tunggu hingga Ready menjadi True.
```
kubectl get ksvc qwen -n default
```

Langkah 5: Validasi layanan inferensi

Setelah layanan diterapkan, akses API inferensi melalui alamat gateway.

Ambil alamat IP gateway.

export GATEWAY_HOST=$(kubectl -n knative-serving get gateway/knative-gateway -o jsonpath='{.status.addresses[0].value}')
echo "Gateway address: $GATEWAY_HOST"

Kirim permintaan uji.

Langkah ini mensimulasikan permintaan percakapan dalam format OpenAI.

curl http://${GATEWAY_HOST}:8888/v1/chat/completions \
  -H "Host: qwen.default.example.com" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "/models/Qwen1.5-4B-Chat/",
    "messages": [
      {"role": "user", "content": "Describe Kubernetes in one sentence."}
    ],
    "max_tokens": 50
  }'

Terminal harus mengembalikan data berformat JSON yang berisi bidang choices. Bidang content dalam field tersebut berisi tanggapan model.

Penagihan

Komponen Knative itu sendiri tidak dikenakan biaya tambahan. Namun, biaya untuk sumber daya komputasi, jaringan, dan sumber daya lain yang digunakan akan dikenakan oleh produk cloud terkait. Misalnya:

Instans GPU: Instans GPU mahal. Gunakan bersama node auto-scaling untuk mengontrol biaya.
OSS: Ini mencakup biaya penyimpanan dan biaya permintaan. Jika melibatkan akses jaringan publik, biaya lalu lintas keluar melalui Internet juga dikenakan.
Server Load Balancer (SLB): Instance SLB publik yang terpasang pada gateway dikenakan biaya trafik.

Untuk informasi selengkapnya, lihat Cloud product resource fees.

Referensi

Anda dapat deploy A2A dan deploy MCP Server di Knative untuk memanfaatkan arsitektur serverless-nya. Hal ini memungkinkan Anda menerapkan fitur-fitur lanjutan seperti penskalaan on-demand dan eksekusi berbasis event untuk layanan AI.