Implementasi Antrian Permintaan Inferensi dan Penjadwalan Prioritas dengan Pengarahan Inferensi Cerdas - Container Service for Kubernetes

Gerbang dengan Ekstensi Inferensi mendukung antrian permintaan berbasis beban dan penjadwalan prioritas untuk layanan inferensi. Ketika server inferensi AI generatif beroperasi pada kapasitas penuh, gerbang memprioritaskan permintaan dalam antrian berdasarkan tingkat kritis model yang ditetapkan. Hal ini memastikan bahwa permintaan untuk model prioritas tinggi diproses terlebih dahulu. Topik ini menjelaskan kemampuan Gerbang dengan Ekstensi Inferensi.

Penting

Fitur ini memerlukan versi 1.4.0 atau lebih baru dari Gerbang dengan Ekstensi Inferensi.

Latar Belakang

Untuk layanan inferensi AI generatif, throughput permintaan server inferensi tunggal dibatasi secara ketat oleh sumber daya GPU-nya. Ketika banyak permintaan konkuren dikirim ke server yang sama, sumber daya seperti caching key-value (KV) di mesin inferensi menjadi sepenuhnya terisi, yang mengurangi waktu respons dan throughput token untuk semua permintaan.

Gerbang dengan Ekstensi Inferensi mengatasi hal ini dengan memantau beberapa metrik untuk menilai status internal setiap server inferensi. Ketika beban server mencapai kapasitas, gerbang menempatkan permintaan inferensi masuk ke dalam antrian, mencegah server kelebihan beban dan menjaga kualitas layanan secara keseluruhan.

Prasyarat

Sebuah Kluster ACK yang dikelola dengan kelompok node GPU telah dibuat. Anda juga dapat menginstal komponen Node Virtual ACK di kluster ACK yang dikelola untuk menggunakan daya komputasi GPU ACS.
Gerbang dengan Ekstensi Inferensi versi 1.4.0 telah diinstal dan Enable Gateway API Inference Extension telah dipilih. Untuk informasi lebih lanjut tentang entri operasi, lihat Langkah 2: Instal Komponen Gerbang dengan Ekstensi Inferensi.

Catatan

Untuk citra yang dijelaskan dalam topik ini, kami merekomendasikan menggunakan kartu A10 untuk kluster ACK dan kartu L20(GN8IS) untuk daya komputasi GPU Alibaba Cloud Container Compute Service (ACS).

Karena ukuran besar citra LLM, kami merekomendasikan Anda mentransfernya ke Container Registry terlebih dahulu dan menariknya menggunakan alamat jaringan internal. Kecepatan menarik dari jaringan publik bergantung pada konfigurasi bandwidth alamat IP elastis (EIP) kluster, yang dapat mengakibatkan waktu tunggu lebih lama.

Prosedur

Langkah 1: Menyebarkan layanan inferensi sampel

Buat file vllm-service.yaml.

Lihat 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

Sebarkan layanan inferensi sampel.
```
kubectl apply -f vllm-service.yaml
```

Langkah 2: Konfigurasikan pengarahan inferensi

Pada langkah ini, Anda akan membuat sumber daya InferencePool dan InferenceModel. Dengan menambahkan anotasi inference-epp-env.networking.x-k8s.io/experimental-use-queueing: "true" dan inference-epp-env.networking.x-k8s.io/experimental-use-scheduler-v2: "true" ke InferencePool, Anda mengaktifkan fitur antrian permintaan untuk layanan inferensi yang dipilih.

Buat file bernama inference-pool.yaml.

apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferencePool
metadata:
  annotations:
    inference-epp-env.networking.x-k8s.io/experimental-use-queueing: "true"
    inference-epp-env.networking.x-k8s.io/experimental-use-scheduler-v2: "true"
  name: qwen-pool
  namespace: default
spec:
  extensionRef:
    group: ""
    kind: Service
    name: qwen-ext-proc
  selector:
    app: qwen
  targetPortNumber: 8000
---
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceModel
metadata:
  name: qwen-model
spec:
  criticality: Critical
  modelName: qwen
  poolRef:
    group: inference.networking.x-k8s.io
    kind: InferencePool
    name: qwen-pool
  targetModels:
  - name: qwen
    weight: 100
---
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceModel
metadata:
  name: travel-helper-model
spec:
  criticality: Standard
  modelName: travel-helper
  poolRef:
    group: inference.networking.x-k8s.io
    kind: InferencePool
    name: qwen-pool
  targetModels:
  - name: travel-helper-v1
    weight: 100

Konfigurasi ini mendefinisikan dua sumber daya InferenceModel yang mewakili dua model yang disajikan oleh layanan inferensi sampel:

qwen-model: Mewakili model dasar qwen dan diberi level kritisitas Critical.
travel-helper-model: Mewakili model LoRA travel-helper dan diberi level kritisitas Standard.

Tingkat kritisitas yang tersedia, dalam urutan prioritas, adalah Critical > Standard > Sheddable. Ketika antrian diaktifkan dan server backend berada pada kapasitas penuh, permintaan untuk model prioritas tinggi akan diproses sebelum permintaan untuk model prioritas rendah.

Sebarkan konfigurasi pengarahan inferensi.
```
kubectl apply -f inference-pool.yaml
```

Langkah 3: Menyebarkan gerbang dan aturan pengarahan

Pada langkah ini, Anda akan mengonfigurasi gerbang dan HTTPRoute untuk mengarahkan permintaan untuk model qwen dan travel-helper ke backend InferencePool qwen-pool.

Buat file bernama inference-gateway.yaml.

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: inference-gateway
spec:
  controllerName: gateway.envoyproxy.io/gatewayclass-controller
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: inference-gateway
spec:
  gatewayClassName: inference-gateway
  listeners:
    - name: llm-gw
      protocol: HTTP
      port: 8081
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: llm-route
  namespace: default
spec:
  parentRefs:
  - group: gateway.networking.k8s.io
    kind: Gateway
    name: inference-gateway
    sectionName: llm-gw
  rules:
  - backendRefs:
    - group: inference.networking.x-k8s.io
      kind: InferencePool
      name: qwen-pool
    matches:
    - headers:
      - type: Exact
        name: X-Gateway-Model-Name
        value: qwen
    - headers:
      - type: RegularExpression
        name: X-Gateway-Model-Name
        value: travel-helper.*
---
apiVersion: gateway.envoyproxy.io/v1alpha1
kind: BackendTrafficPolicy
metadata:
  name: backend-timeout
spec:
  timeout:
    http:
      requestTimeout: 24h
  targetRef:
    group: gateway.networking.k8s.io
    kind: Gateway
    name: inference-gateway

Sebarkan gerbang.
```
kubectl apply -f inference-gateway.yaml
```

Langkah 4: Validasi antrian dan penjadwalan prioritas

Pada langkah ini, Anda akan menggunakan alat benchmark vLLM untuk secara bersamaan melakukan pengujian beban pada model qwen dan travel-helper, mendorong server inferensi ke kapasitas penuh.

Sebarkan beban kerja benchmark.

kubectl apply -f- <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: vllm-benchmark
  name: vllm-benchmark
  namespace: default
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: vllm-benchmark
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: vllm-benchmark
    spec:
      containers:
      - command:
        - sh
        - -c
        - sleep inf
        image: registry-cn-hangzhou.ack.aliyuncs.com/dev/llm-benchmark:random-and-qa
        imagePullPolicy: IfNotPresent
        name: vllm-benchmark
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
EOF

Dapatkan 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=inference-gateway -o jsonpath='{.items[0].spec.clusterIP}')

Buka dua jendela terminal terpisah dan jalankan pengujian beban secara bersamaan.

Penting

Data berikut dihasilkan dalam lingkungan pengujian dan hanya untuk referensi. Hasil Anda mungkin berbeda tergantung pada lingkungan Anda.

Terminal 1: Uji Beban Model qwen (kritis)

kubectl exec -it deploy/vllm-benchmark -- env GW_IP=${GW_IP} python3 /root/vllm/benchmarks/benchmark_serving.py \
--backend vllm \
--model /models/DeepSeek-R1-Distill-Qwen-7B \
--served-model-name qwen \
--trust-remote-code \
--dataset-name random \
--random-prefix-len 1000 \
--random-input-len 3000 \
--random-output-len 3000 \
--random-range-ratio 0.2 \
--num-prompts 300 \
--max-concurrency 60 \
--host $GW_IP \
--port 8081 \
--endpoint /v1/completions \
--save-result \
2>&1 | tee benchmark_serving.txt

Hasil yang diharapkan:

============ Serving Benchmark Result ============
Successful requests:                     293       
Benchmark duration (s):                  1005.55   
Total input tokens:                      1163919   
Total generated tokens:                  837560    
Request throughput (req/s):              0.29      
Output token throughput (tok/s):         832.94    
Total Token throughput (tok/s):          1990.43   
---------------Time to First Token----------------
Mean TTFT (ms):                          21329.91  
Median TTFT (ms):                        15754.01  
P99 TTFT (ms):                           140782.55 
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          58.58     
Median TPOT (ms):                        58.36     
P99 TPOT (ms):                           91.09     
---------------Inter-token Latency----------------
Mean ITL (ms):                           58.32     
Median ITL (ms):                         50.56     
P99 ITL (ms):                            64.12     
==================================================

Terminal 2: Uji Beban Model travel-helper (standar)

kubectl exec -it deploy/vllm-benchmark -- env GW_IP=${GW_IP} python3 /root/vllm/benchmarks/benchmark_serving.py \
--backend vllm \
--model /models/DeepSeek-R1-Distill-Qwen-7B \
--served-model-name travel-helper \
--trust-remote-code \
--dataset-name random \
--random-prefix-len 1000 \
--random-input-len 3000 \
--random-output-len 3000 \
--random-range-ratio 0.2 \
--num-prompts 300 \
--max-concurrency 60 \
--host $GW_IP \
--port 8081 \
--endpoint /v1/completions \
--save-result \
2>&1 | tee benchmark_serving.txt

Hasil yang diharapkan:

============ Serving Benchmark Result ============
Successful requests:                     165       
Benchmark duration (s):                  889.41    
Total input tokens:                      660560    
Total generated tokens:                  492207    
Request throughput (req/s):              0.19      
Output token throughput (tok/s):         553.41    
Total Token throughput (tok/s):          1296.10   
---------------Time to First Token----------------
Mean TTFT (ms):                          44201.12  
Median TTFT (ms):                        28757.03  
P99 TTFT (ms):                           214710.13 
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          67.38     
Median TPOT (ms):                        60.51     
P99 TPOT (ms):                           118.36    
---------------Inter-token Latency----------------
Mean ITL (ms):                           66.98     
Median ITL (ms):                         51.25     
P99 ITL (ms):                            64.87     
==================================================

Hasil benchmark mengonfirmasi efektivitas penjadwalan prioritas di bawah beban penuh:

Waktu Respons Lebih Cepat: Rata-rata Waktu hingga Token Pertama (TTFT) model qwen prioritas tinggi adalah 50% lebih rendah dibandingkan model travel-helper prioritas standar.
Keandalan Lebih Tinggi: Model qwen juga mengembalikan 96% lebih sedikit kesalahan permintaan.