Container Service for Kubernetes：Menggunakan kemampuan perutean yang sadar cache awalan dalam mode estimasi

Cache awalan otomatis di vLLM

vLLM mendukung cache awalan otomatis (APC). APC menyimpan status key-value (KV) yang telah dihitung oleh vLLM untuk permintaan sebelumnya. Jika permintaan baru memiliki awalan yang sama dengan permintaan sebelumnya, permintaan tersebut dapat menggunakan kembali cache KV yang ada, sehingga melewati perhitungan ulang untuk bagian awalan tersebut. Proses ini mempercepat pemrosesan permintaan inferensi model bahasa besar (LLM).

Perutean yang sadar cache awalan dalam mode estimasi

Perutean yang sadar cache awalan dalam mode estimasi adalah kebijakan penyeimbangan beban yang mengarahkan permintaan dengan awalan yang sama ke Pod server inferensi yang sama bila memungkinkan. Komponen Gateway with Inference Extension melacak permintaan yang diarahkan ke setiap server inferensi dan memperkirakan status cache awalan masing-masing server untuk meningkatkan rasio hit cache pada mesin inferensi.

Saat fitur APC diaktifkan pada server model, kebijakan perutean yang sadar cache awalan dalam mode estimasi dapat memaksimalkan rasio hit cache serta mengurangi waktu tanggapan permintaan. Kebijakan ini ideal untuk skenario dengan banyak permintaan yang berbagi awalan. Anda harus mengevaluasi kesesuaiannya berdasarkan kebutuhan bisnis Anda.

Skenario khas meliputi hal-hal berikut:

• Kueri dokumen panjang: Pengguna berulang kali mengajukan kueri terhadap dokumen panjang yang sama, seperti manual perangkat lunak atau laporan tahunan, dengan kueri berbeda.

• Percakapan multi-putaran: Pengguna dapat berinteraksi dengan aplikasi beberapa kali dalam sesi obrolan yang sama.

Langkah 1: Menyebarkan layanan inferensi contoh

1. Buat file bernama vllm-service.yaml.

   Klik untuk melihat konten YAML

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app: qwen
     name: qwen
   spec:
     replicas: 5
     selector:
       matchLabels:
         app: qwen
     template:
       metadata:
         annotations:
           prometheus.io/path: /metrics
           prometheus.io/port: "8000"
           prometheus.io/scrape: "true"
         labels:
           app: qwen
       spec:
         containers:
         - command:
           - sh
           - -c
           - vllm serve /models/Qwen-2.5-7B-Instruct --port 8000 --enable_prefix_caching --trust-remote-code --served-model-name /model/qwen --max-model-len 8192 --gpu-memory-utilization 0.95 --enforce-eager --enable-lora --max-loras 2 --max-cpu-loras 4 --lora-modules travel-helper-v1=/models/Qwen-TravelHelper-Lora travel-helper-v2=/models/Qwen-TravelHelper-Lora-v2
           image: registry-cn-hangzhou.ack.aliyuncs.com/dev/qwen-2.5-7b-instruct-lora:v0.1
           imagePullPolicy: IfNotPresent
           name: custom-serving
           ports:
           - containerPort: 8000
             name: http
             protocol: TCP
           readinessProbe:
             failureThreshold: 3
             initialDelaySeconds: 30
             periodSeconds: 30
             successThreshold: 1
             tcpSocket:
               port: 8000
             timeoutSeconds: 1
           resources:
             limits:
               nvidia.com/gpu: "1"
           terminationMessagePath: /dev/termination-log
           terminationMessagePolicy: File
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         dnsPolicy: ClusterFirst
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext: {}
         terminationGracePeriodSeconds: 30
         volumes:
         - emptyDir:
             medium: Memory
             sizeLimit: 30Gi
           name: dshm
   ---
   apiVersion: v1
   kind: Service
   metadata:
     labels:
       app: qwen
     name: qwen
   spec:
     ports:
     - name: http-serving
       port: 8000
       protocol: TCP
       targetPort: 8000
     selector:
       app: qwen

2. Sebarkan layanan inferensi contoh.

   kubectl apply -f vllm-service.yaml

Langkah 2: Menyebarkan rute inferensi

Pada langkah ini, Anda membuat sumber daya InferencePool dan InferenceModel.

1. Buat file bernama inference-pool.yaml.

   apiVersion: inference.networking.x-k8s.io/v1alpha2
   kind: InferencePool
   metadata:
     annotations:
       inference.networking.x-k8s.io/routing-strategy: "PREFIX_CACHE"
     name: vllm-qwen-pool
   spec:
     targetPortNumber: 8000
     selector:
       app: qwen
     extensionRef:
       name: inference-gateway-ext-proc
   ---
   apiVersion: inference.networking.x-k8s.io/v1alpha2
   kind: InferenceModel
   metadata:
     name: inferencemodel-qwen
   spec:
     modelName: /model/qwen
     criticality: Critical
     poolRef:
       group: inference.networking.x-k8s.io
       kind: InferencePool
       name: vllm-qwen-pool
     targetModels:
     - name: /model/qwen
       weight: 100

   Pada sumber daya InferencePool, tambahkan anotasi inference.networking.x-k8s.io/routing-strategy: "PREFIX_CACHE". Ini mengaktifkan perutean yang sadar cache awalan dalam mode estimasi untuk Pod dalam InferencePool.

2. Sebarkan rute inferensi.

   kubectl apply -f inference-pool.yaml

Langkah 3: Menyebarkan gerbang dan aturan perutean gerbang

Pada langkah ini, Anda membuat gerbang yang mendengarkan pada Port 8080 dan 8081. Di Port 8081, sumber daya HTTPRoute menentukan InferencePool yang disediakan oleh ekstensi inferensi sebagai backend, sehingga permintaan inferensi diarahkan ke kumpulan Pod yang ditentukan dalam InferencePool. Di Port 8080, sumber daya HTTPRoute lain menentukan Service sebagai backend, dan permintaan inferensi diarahkan ke kumpulan Pod yang sama menggunakan kebijakan penyeimbangan beban least-request HTTP standar.

1. Buat file bernama inference-gateway.yaml.

   apiVersion: gateway.networking.k8s.io/v1
   kind: GatewayClass
   metadata:
     name: qwen-inference-gateway-class
   spec:
     controllerName: gateway.envoyproxy.io/gatewayclass-controller
   ---
   apiVersion: gateway.networking.k8s.io/v1
   kind: Gateway
   metadata:
     name: qwen-inference-gateway
   spec:
     gatewayClassName: qwen-inference-gateway-class
     listeners:
       - name: http
         protocol: HTTP
         port: 8080
       - name: llm-gw
         protocol: HTTP
         port: 8081
   ---
   apiVersion: gateway.networking.k8s.io/v1
   kind: HTTPRoute
   metadata:
     name: qwen-backend
   spec:
     parentRefs:
       - name: qwen-inference-gateway
         sectionName: llm-gw
     rules:
       - backendRefs:
           - group: inference.networking.x-k8s.io
             kind: InferencePool
             name: vllm-qwen-pool
         matches:
           - path:
               type: PathPrefix
               value: /
   ---
   apiVersion: gateway.networking.k8s.io/v1
   kind: HTTPRoute
   metadata:
     name: qwen-backend-no-inference
   spec:
     parentRefs:
     - group: gateway.networking.k8s.io
       kind: Gateway
       name: qwen-inference-gateway
       sectionName: http
     rules:
     - backendRefs:
       - group: ""
         kind: Service
         name: qwen
         port: 8000
         weight: 1
       matches:
       - path:
           type: PathPrefix
           value: /
   ---
   apiVersion: gateway.envoyproxy.io/v1alpha1
   kind: BackendTrafficPolicy
   metadata:
     name: backend-timeout
   spec:
     timeout:
       http:
         requestTimeout: 1h
     targetRef:
       group: gateway.networking.k8s.io
       kind: Gateway
       name: qwen-inference-gateway

2. Sebarkan gerbang.

   kubectl apply -f inference-gateway.yaml

Langkah 4: Memverifikasi aturan perutean

1. Buat file bernama round1.txt dan round2.txt. Kedua file berisi bagian content yang identik. Gunakan isi round1.txt lalu round2.txt sebagai badan permintaan untuk LLM, kemudian periksa log extensionRef untuk memverifikasi bahwa perutean yang sadar cache awalan dalam mode estimasi dipicu.

   round1.txt:

   echo '{"max_tokens":24,"messages":[{"content":"Hi, here'\''s some system prompt: hi hi hi hi hi hi hi hi hi hi.For user 3, here are some other context: hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi.I would like to test your intelligence. for this purpose I would like you to play zork. you can interact with the game by typing in commands. I will forward these commands to the game and type in any response. are you ready?","role":"user"}],"model":"/model/qwen","stream":true,"stream_options":{"include_usage":true},"temperature":0}' > round1.txt

   round2.txt:

   echo '{"max_tokens":3,"messages":[{"content":"Hi, here'\''s some system prompt: hi hi hi hi hi hi hi hi hi hi.For user 3, here are some other context: hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi hi.I would like to test your intelligence. for this purpose I would like you to play zork. you can interact with the game by typing in commands. I will forward these commands to the game and type in any response. are you ready?","role":"user"},{"content":"Hi there! It looks like you're setting up a fun test. I'm ready to play Zork! You can","role":"assistant"},{"content":"% zork\nWelcome to Dungeon. This version created 11-MAR-91.\nYou are in an open field west of a big white house with a boarded\nfront door.\nThere is a small mailbox here.\n>","role":"user"},{"content":"Great!","role":"assistant"},{"content":"Opening the mailbox reveals:\n A leaflet.\n>","role":"user"}],"model":"/model/qwen","stream":true,"stream_options":{"include_usage":true},"temperature":0}' > round2.txt

2. Ambil alamat IP publik gerbang.

   export GATEWAY_IP=$(kubectl get gateway/qwen-inference-gateway -o jsonpath='{.status.addresses[0].value}')

3. Kirim dua permintaan sesi untuk mensimulasikan skenario percakapan multi-putaran.

   curl -X POST ${GATEWAY_IP}:8081/v1/chat/completions -H 'Content-Type: application/json' -d @./round1.txt
   curl -X POST ${GATEWAY_IP}:8081/v1/chat/completions -H 'Content-Type: application/json' -d @./round2.txt

4. Periksa log untuk memastikan perutean yang sadar cache awalan dalam mode estimasi berfungsi.

   kubectl logs deploy/epp-default-inference-gateway-ext-proc -n envoy-gateway-system|grep "Do prefix"

   Keluaran yang diharapkan:

   2025-05-23T03:33:09Z    INFO    scheduling/prefixcache_filter.go:311    Do prefix-aware routing!        {"request": "v68m4zx472", "matching ratio": " 0.54 > 0.50"}

   Log berisi pesan Do prefix-aware routing!, yang menunjukkan bahwa perutean yang sadar cache awalan dalam mode estimasi berfungsi.

(Opsional) Langkah 5: Mengevaluasi kinerja layanan inferensi dengan uji percakapan multi-putaran

Langkah ini menggunakan kluster ACK sebagai contoh dan menunjukkan cara menggunakan alat uji stres untuk menjalankan uji percakapan multi-putaran. Tujuannya adalah membandingkan kinerja perutean HTTP standar dengan perutean inferensi yang sadar cache awalan.

1. Sebarkan alat uji stres llm-qa-benchmark.

   kubectl apply -f- <<EOF
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app: llm-qa-benchmark
     name: llm-qa-benchmark
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm-qa-benchmark
     template:
       metadata:
         labels:
           app: llm-qa-benchmark
       spec:
         containers:
         - command:
           - sh
           - -c
           - sleep inf
           image: registry-cn-hangzhou.ack.aliyuncs.com/dev/llm-qa-benchmark:v0.1
           imagePullPolicy: IfNotPresent
           name: llm-qa-benchmark
           terminationMessagePath: /dev/termination-log
           terminationMessagePolicy: File
         restartPolicy: Always
   EOF

2. Ambil alamat IP internal gerbang.

   export GW_IP=$(kubectl get svc -n envoy-gateway-system -l gateway.envoyproxy.io/owning-gateway-namespace=default,gateway.envoyproxy.io/owning-gateway-name=qwen-inference-gateway -o jsonpath='{.items[0].spec.clusterIP}')

3. Jalankan uji stres.

   Penting

   Hasil berikut berasal dari lingkungan pengujian. Hasil aktual Anda mungkin berbeda.

   Perutean HTTP standar kubectl exec -it deploy/llm-qa-benchmark -- env GW_IP=${GW_IP} python3 multi-round-qa.py \ --num-users 8 \ --num-rounds 15 \ --qps 0.1 \ --shared-system-prompt 100 \ --sharegpt \ --user-history-prompt 2000 \ --answer-len 100 \ --model /model/qwen \ --time 600 \ --base-url http://${GW_IP}:8080/v1 Keluaran yang diharapkan: ==================== Performance summary ====================== QPS: 0.1000 reqs/s Processing speed: 0.1080 reqs/s Requests on-the-fly: 0 Input tokens per second: 259.0703 tokens/s Output tokens per second: 4.8576 tokens/s Average generation throughput (per request): 26.6710 tokens/req/s Average TTFT: 0.3669s Time range: 1748231183.2753935 - 1748231766.4799275 (583.20s) ===============================================================

   Perutean layanan inferensi kubectl exec -it deploy/llm-qa-benchmark -- env GW_IP=${GW_IP} python3 multi-round-qa.py \ --num-users 8 \ --num-rounds 15 \ --qps 0.1 \ --shared-system-prompt 100 \ --sharegpt \ --user-history-prompt 2000 \ --answer-len 100 \ --model /model/qwen \ --time 600 \ --base-url http://${GW_IP}:8081/v1 Keluaran yang diharapkan: ==================== Performance summary ====================== QPS: 0.1000 reqs/s Processing speed: 0.1081 reqs/s Requests on-the-fly: 0 Input tokens per second: 259.3009 tokens/s Output tokens per second: 4.8548 tokens/s Average generation throughput (per request): 26.9300 tokens/req/s Average TTFT: 0.2761s Time range: 1748231885.874972 - 1748232468.5918882 (582.72s) ===============================================================

   Hasil menunjukkan bahwa Average TTFT untuk perutean layanan inferensi jauh lebih rendah dibandingkan perutean HTTP standar.