Men-deploy layanan LLM dan menerapkan perutean cerdas di Knative - Container Service for Kubernetes

Berdasarkan Kubernetes Gateway API dan spesifikasi Inference Extension, komponen Gateway with Inference Extension berintegrasi dengan arsitektur Serverless Knative untuk menyederhanakan pengelolaan layanan inferensi AI generatif. Komponen ini menyediakan perutean dan load balancing Layer-7 yang efisien di berbagai beban kerja layanan inferensi serta mendukung autoscaling sumber daya GPU berdasarkan konkurensi permintaan.

Cara kerja

Gateway with Inference Extension memperluas Gateway API untuk skenario inferensi AI melalui CustomResourceDefinitions (CRDs) berikut.

InferencePool: Mengelompokkan sumber daya secara logis untuk layanan model AI. CRD ini merepresentasikan kumpulan Pod dengan konfigurasi komputasi, tipe akselerator, model dasar, dan model server yang sama. InferencePool dapat mencakup beberapa node untuk menyediakan ketersediaan tinggi.
InferenceObjective: Menentukan tujuan layanan model dengan menetapkan nama model yang dilayani oleh Pod dalam InferencePool serta tingkat kepentingannya. Beban kerja yang ditandai sebagai Critical mendapatkan prioritas pemrosesan yang lebih tinggi.

Di Knative, mengaktifkan anotasi AI gateway memungkinkan Knative Service secara otomatis menggunakan CRD tersebut untuk penjadwalan trafik cerdas.

Prasyarat

Anda telah membuat kluster ACK Managed Pro yang memenuhi persyaratan berikut:
- Knative telah dideploy. Untuk informasi selengkapnya, lihat Deploy and manage Knative components.
- Anda telah deployed Knative di kluster ACS.
- Komponen Gateway API Gateway API telah diinstal.
- Komponen Gateway with Inference ExtensionGateway with Inference Extension versi v1.4.0-apsara.4 atau yang lebih baru telah diinstal, dan Anda memilih Enable Gateway API Inference Extension saat instalasi.
- Kluster berisi node GPU, masing-masing dengan memori minimal 32 GiB (topik ini menggunakan Qwen1.5-4B sebagai contoh). Diperlukan Node Labels tertentu pada node untuk menentukan versi driver: atur key menjadi ack.aliyun.com/nvidia-driver-version dan value menjadi 550.144.03.
  
  Kami merekomendasikan versi driver node GPU 550.144.03 atau yang lebih baru. Untuk informasi selengkapnya, lihat Customize the GPU driver version of a node by specifying a version number.
- Pod harus meminta sumber daya GPU dan memiliki memori minimal 32 GiB (topik ini menggunakan Qwen1.5-4B sebagai contoh). Versi driver harus ditentukan menggunakan label Pod (labels): atur key menjadi alibabacloud.com/gpu-driver-version dan value menjadi 550.144.03. Kami merekomendasikan versi driver 550.144.03 atau yang lebih baru. Untuk informasi selengkapnya, lihat Specify the GPU model and driver version for an ACS GPU Pod.
Anda telah membuat bucket OSS.

Kami merekomendasikan memilih wilayah yang sama dengan kluster Anda untuk menghindari biaya transfer data lintas wilayah dan mengurangi latensi.

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 Anda.

apiVersion: v1
data:
  ...
  # Modify ingress.class to use the Gateway API as the Ingress controller.
  ingress.class: gateway-api.ingress.networking.knative.dev 
  ...
kind: ConfigMap
metadata:
  name: config-network
  namespace: knative-serving
  ...

Verifikasi bahwa perubahan telah diterapkan.

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 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
    # The port that the inference service listens on.
    port: 8888  
    allowedRoutes:
      namespaces:
        from: All

Terapkan sumber daya gerbang.
```
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, kami merekomendasikan menggunakan volume statis OSS untuk menyimpan dan memasang data model.

1. Unduh model dan unggah ke OSS

Langkah ini menggunakan model Qwen1.5-4B-Chat sebagai contoh. Anda dapat sementara membeli instance ECS untuk menyiapkan data model dan melepaskannya setelah selesai.

Unduh model ke direktori lokal.

# Install Git LFS
sudo yum install -y git git-lfs
git lfs install
# Clone the model repository (skip smudge to speed up)
GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/qwen/Qwen1.5-4B-Chat.git
# Download the actual large files
cd Qwen1.5-4B-Chat
git lfs pull

Gunakan ossutil untuk mengunggah model ke bucket OSS Anda.

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

Untuk menginstal ossutil, lihat Install ossutil.

# Create a directory.
ossutil mkdir oss://<Bucket-Name>/models/Qwen1.5-4B-Chat
# Upload files recursively (-r indicates recursive upload).
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 statis OSS. Untuk langkah-langkah detail, lihat Use an ossfs 1.0 static volumeUse an OSS static 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 oss-storage.yaml.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: llm-model
  labels:
    alicloud-pvname: llm-model
spec:
  capacity:
    storage: 30Gi
  # Access mode
  accessModes:
    - ReadWriteMany            
  persistentVolumeReclaimPolicy: Retain
  storageClassName: oss
  csi:
    driver: ossplugin.csi.alibabacloud.com
    volumeHandle: llm-model
    # Get AccessKey information from the Secret object.
    nodePublishSecretRef:
      name: oss-secret
      namespace: default
    volumeAttributes:
      # Replace with your actual OSS Bucket name.
      bucket: "<Your-Bucket-Name>"         
      # The internal endpoint for the bucket's region.
      url: "http://oss-cn-hangzhou-internal.aliyuncs.com" 
      # The relative path in OSS.
      path: "/models/Qwen1.5-4B-Chat"     
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: llm-model
  namespace: default
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: oss
  resources:
    requests:
      # Requested storage size, which cannot exceed the total volume size.
      storage: 30Gi
  selector:
    matchLabels:
      # Select the PV by using this label.
      alicloud-pvname: llm-model

Deploy 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 qwen-service.yaml.

Konfigurasi utama:

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

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: qwen
  namespace: default
  annotations:
    # Enable the AI inference gateway.
    knative.aliyun.com/ai-gateway: inference          
    knative.aliyun.com/ai-gateway-inference-priority: "1"
  labels:
    release: qwen
spec:
  template:
    metadata:
      annotations:
        # Autoscaling metric: concurrency.
        autoscaling.knative.dev/metric: "concurrency" 
        # Target concurrency.
        autoscaling.knative.dev/target: "2"           
        # Maximum number of instances.
        autoscaling.knative.dev/max-scale: "3"        
        # Minimum number of instances. For large models, a minimum of 1 is recommended to keep an instance warm and avoid request timeouts on cold starts.
        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
            # Request GPU resources.
            nvidia.com/gpu: "1" 
          requests:
            cpu: "8"
            memory: 32Gi
            nvidia.com/gpu: "1"
        volumeMounts:
        # The mount path must match the model parameter in the startup command.
        - mountPath: /models/Qwen1.5-4B-Chat 
          name: llm-model
      volumes:
      - name: llm-model
        persistentVolumeClaim:
          claimName: llm-model

Deploy layanan.
```
kubectl apply -f qwen-service.yaml
```
Periksa progres deployment (tunggu hingga Ready bernilai True).
```
kubectl get ksvc qwen -n default
```

Langkah 5: Verifikasi layanan inferensi

Setelah layanan dideploy, gunakan alamat IP gateway untuk mengakses API inferensi.

Dapatkan alamat IP gateway.

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

Kirim permintaan uji.

Langkah ini mensimulasikan permintaan chat berformat 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": "Explain Kubernetes in one sentence."}
    ],
    "max_tokens": 50
  }'

Terminal harus mengembalikan data JSON yang berisi bidang choices, di mana content berisi tanggapan model.

Tagihan

Komponen Knative itu sendiri tidak dikenai biaya tambahan. Namun, Anda akan ditagih untuk sumber daya cloud yang digunakan layanan Anda, seperti komputasi, jaringan, dan penyimpanan.

Instance GPU: Instance GPU mahal. Untuk mengontrol biaya, kami merekomendasikan menggunakannya dengan node scaling.
OSS: Biaya mencakup penyimpanan OSS dan biaya permintaan. Jika melibatkan akses publik, Anda juga dikenai biaya trafik keluar.
Server Load Balancer (SLB): Instance load balancer publik yang terikat ke gateway dikenai biaya trafik.

Untuk informasi selengkapnya, lihat Cloud product resource feesBilling.

Dokumen terkait

Knative juga mendukung deployment layanan lain, seperti A2A dan MCP Server. Hal ini memungkinkan Anda menerapkan manfaat Serverless seperti scaling sesuai permintaan dan pola berbasis event ke layanan AI lanjutan lainnya.