Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: vLLM auf der GPU

Ziel: vllm-chat serviert Qwen3-8B (FP8) auf rke2-gpu-1 mit Modell-Cache, Tool Calling, Metriken und einer KEDA-Regel auf die Warteschlange. · Dauer: ca. 150 min · Voraussetzung: Tag 10

Briefing

  • Ein Deployment vllm-chat in ki-models, Service vllm-chat.ki-models:8000, Modellname in der API qwen3-8b. LiteLLM hängt es in Tag 12 als chat-large ein.
  • Gewichte liegen auf local-path (/var/lib/ki-models auf dem GPU-Node) – nach dem ersten Download startet der Pod ohne Internet.
  • VRAM-Budget der L4 (24 GB): 80 % für den Chat, 12 % für das Embedding-Modell (Tag 13), Rest Reserve.
  • Eine GPU heißt: kein paralleler Rollout (maxSurge: 0), und eine zweite Replika braucht eine zweite Karte.
L4 24 GB   |<----------- vllm-chat 0.80 = 19.2 GB ----------->|<-embed 0.12->|res|
           | Gewichte 9.4 | Aktivierung ~1.5 | KV-Cache ~8.3  |  bge-m3     |   |

Achtung: Ohne GPU auf dieser Maschine sind vLLM-Logs, API-Antworten und Metrikwerte gegen docs.vllm.ai (v0.31) geprüft, aber nicht live getestet. Live getestet: Sizing-Skript, Modell-Metadaten von Hugging Face, alle Manifeste per kubectl apply --dry-run=server.

Drill 1: Modell wählen und VRAM rechnen

Modell (Hugging Face) Gewichte Lizenz Rolle im Lab
Qwen/Qwen3-8B-FP8 9,4 GB Apache-2.0 chat-large (Default, Ada/Hopper)
Qwen/Qwen3-8B-AWQ 6,1 GB Apache-2.0 4-Bit, auch Ampere/Turing
Qwen/Qwen3-8B (BF16) 16,4 GB Apache-2.0 volle Qualität, ab 24 GB allein
mistralai/Ministral-3-8B-Instruct-2512 ca. 10 GB (FP8) Apache-2.0 EU-Hersteller, Vision
Qwen/Qwen2.5-Coder-7B-Instruct 15,2 GB Apache-2.0 code (Tag 14)
BAAI/bge-m3 ca. 2,3 GB MIT embed (Tag 13)
meta-llama/Llama-3.1-8B-Instruct 16,1 GB Llama 3.1, gated nur mit HF-Token
google/gemma-3-12b-it 24,4 GB Gemma, gated passt in BF16 nicht auf eine L4

Größen und Lizenzen stammen aus der Hugging-Face-API (Stand Oktober 2026). „Gated“ heißt: Lizenz auf Hugging Face akzeptieren, dann mit Token laden. Lizenzbedingungen (Llama: Namensnennung, Nutzerschwelle; Gemma: Nutzungsrichtlinie) prüft beim Kunden die Rechtsabteilung.

Wie viel KV-Cache bleibt übrig? Die Rechnung kommt direkt aus der config.json des Modells:

mkdir -p ~/ki-lab/tag11 ~/ki-lab/code/vllm && cd ~/ki-lab/code/vllm
cat > kv-sizing.py <<'EOF'
"""KV-Cache-Rechnung für vLLM (Tag 11)."""
import json
import sys
import urllib.request

repo = sys.argv[1] if len(sys.argv) > 1 else "Qwen/Qwen3-8B-FP8"
url = f"https://huggingface.co/{repo}/resolve/main/config.json"
cfg = json.load(urllib.request.urlopen(url))
layers, kv_heads = cfg["num_hidden_layers"], cfg["num_key_value_heads"]
head_dim = cfg.get("head_dim") or cfg["hidden_size"] // cfg["num_attention_heads"]
kv_bytes = 2  # BF16-KV-Cache; mit --kv-cache-dtype fp8 halbiert
per_token = 2 * layers * kv_heads * head_dim * kv_bytes  # K und V
weights_gb = float(sys.argv[2]) if len(sys.argv) > 2 else 9.4  # Drill 1
gpu_gb, util, overhead_gb = 24, 0.80, 1.5
kv_gb = gpu_gb * util - weights_gb - overhead_gb
tokens = int(kv_gb * 1024**3 / per_token)
print(f"{repo}: {per_token / 1024:.0f} KiB KV pro Token")
print(f"KV-Budget {kv_gb:.1f} GB -> ca. {tokens:,} Tokens im Cache")
for ctx in (4096, 16384, 32768):
    print(f"  max-model-len {ctx:>6}: ca. {tokens // ctx} volle Sequenzen parallel")
EOF
python3 kv-sizing.py

Erwartet (live getestet):

Qwen/Qwen3-8B-FP8: 144 KiB KV pro Token
KV-Budget 8.3 GB -> ca. 60,438 Tokens im Cache
  max-model-len   4096: ca. 14 volle Sequenzen parallel
  max-model-len  16384: ca. 3 volle Sequenzen parallel
  max-model-len  32768: ca. 1 volle Sequenzen parallel

Warum --max-model-len=16384 statt der möglichen 40960? Jede Sequenz reserviert ihren KV-Cache blockweise bei Bedarf (PagedAttention), aber vLLM prüft beim Start, ob eine Sequenz maximaler Länge passt. 16k reicht für Chat und RAG und lässt Platz für Parallelität.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Namespace und HF-Token-Secret

export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl create namespace ki-models
read -rs HF_TOKEN && export HF_TOKEN      # Token von huggingface.co, nur Lesen
kubectl -n ki-models create secret generic hf-token \
  --from-literal=token="$HF_TOKEN"
unset HF_TOKEN
kubectl -n ki-models get secret hf-token -o jsonpath='{.data.token}' \
  | base64 -d | cut -c1-3

Erwartet:

namespace/ki-models created
secret/hf-token created
hf_

Sicherheit: Nur ein Read-Token („fine-grained“, Zugriff auf öffentliche gated Repos). Das Token landet in etcd – in Tag 12 lernst du, wie es stattdessen aus OpenBao kommt. Qwen ist nicht gated, deshalb ist das Secret im Deployment optional: true.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Deployment mit Modell-Cache

cat > vllm-chat.yaml <<'EOF'
# vLLM Chat-Modell auf rke2-gpu-1 (Tag 11)
# Qwen3-8B in FP8 (Apache-2.0, ~9 GB Gewichte) auf einer L4 mit 24 GB
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: vllm-chat-cache
  namespace: ki-models
spec:
  accessModes: ["ReadWriteOnce"]
  storageClassName: local-path
  resources:
    requests:
      storage: 60Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-chat
  namespace: ki-models
  labels:
    app: vllm-chat
spec:
  replicas: 1
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 0              # nie zwei Pods gleichzeitig auf der einen GPU
      maxUnavailable: 1
  selector:
    matchLabels:
      app: vllm-chat
  template:
    metadata:
      labels:
        app: vllm-chat
    spec:
      runtimeClassName: nvidia
      nodeSelector:
        nvidia.com/gpu.present: "true"
      tolerations:
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule
      terminationGracePeriodSeconds: 60
      containers:
        - name: vllm
          image: vllm/vllm-openai:v0.31.0
          args:                  # Entrypoint des Images ist "vllm serve"
            - Qwen/Qwen3-8B-FP8
            - --served-model-name=qwen3-8b
            - --max-model-len=16384
            - --gpu-memory-utilization=0.80
            - --max-num-seqs=32
            - --enable-prefix-caching
            - --enable-auto-tool-choice
            - --tool-call-parser=hermes
            - --reasoning-parser=qwen3
            - --port=8000
          env:
            - name: HF_HOME
              value: /models
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-token
                  key: token
                  optional: true       # Qwen ist nicht gated
          ports:
            - name: http
              containerPort: 8000
          startupProbe:          # Download + Laden + CUDA-Graphs: bis 15 min
            httpGet:
              path: /health
              port: http
            periodSeconds: 10
            failureThreshold: 90
          readinessProbe:
            httpGet:
              path: /health
              port: http
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /health
              port: http
            periodSeconds: 20
            failureThreshold: 3
          resources:
            requests:
              cpu: "2"
              memory: 12Gi
            limits:
              memory: 20Gi
              nvidia.com/gpu: "1"
          volumeMounts:
            - name: cache
              mountPath: /models
            - name: shm
              mountPath: /dev/shm
      volumes:
        - name: cache
          persistentVolumeClaim:
            claimName: vllm-chat-cache
        - name: shm
          emptyDir:
            medium: Memory
            sizeLimit: 2Gi
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-chat
  namespace: ki-models
  labels:
    app: vllm-chat
spec:
  selector:
    app: vllm-chat
  ports:
    - name: http
      port: 8000
      targetPort: http
EOF
kubectl apply --dry-run=server -f vllm-chat.yaml && kubectl apply -f vllm-chat.yaml
kubectl -n ki-models logs -f deploy/vllm-chat | grep -E --line-buffered \
  'Loading weights took|KV cache|Maximum concurrency|Application startup'

Erwartet (Dry-Run live getestet, Log gekürzt, nicht live getestet, Zahlen weichen ab):

persistentvolumeclaim/vllm-chat-cache created (server dry run)
deployment.apps/vllm-chat created (server dry run)
service/vllm-chat created (server dry run)
...
INFO ... Loading weights took 6.12 seconds
INFO ... Available KV cache memory: 7.85 GiB
INFO ... GPU KV cache size: 57,152 tokens
INFO ... Maximum concurrency for 16,384 tokens per request: 3.49x
INFO:     Application startup complete.

Strg+C beendet das Log. Die KV-Zahlen sollten nah an deiner Rechnung aus Drill 1 liegen.

Teil Warum so?
startupProbe 90 × 10 s Erster Start lädt 9 GB; Liveness würde den Pod sonst mitten im Download töten
/dev/shm als emptyDir Memory PyTorch nutzt Shared Memory; der Container-Default (64 MB) ist zu klein
HF_HOME=/models Download-Cache auf dem PVC, zweiter Start lädt nur noch von Disk
limits.memory 20Gi Host-RAM für Tokenizer, CUDA-Graphs, Prozess – nicht VRAM

Fortschritt speichern? Kostenlos registrieren

Drill 4: Erste Anfrage und Tool Calling

kubectl -n ki-models port-forward svc/vllm-chat 8000:8000 >/dev/null 2>&1 &
curl -s localhost:8000/v1/models | jq -r '.data[] | "\(.id) \(.max_model_len)"'
curl -s localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
  "model": "qwen3-8b",
  "messages": [{"role": "user", "content": "Was ist ein Pod? Ein Satz."}],
  "max_tokens": 300
}' | jq -r '.choices[0].message | "DENKEN: \(.reasoning_content[0:60])...",
  "ANTWORT: \(.content)"'

Erwartet (nicht live getestet, Wortlaut variiert):

qwen3-8b 16384
DENKEN: Okay, the user is asking what a Pod is in one sentence. In Kuber...
ANTWORT: Ein Pod ist die kleinste deploybare Einheit in Kubernetes, die einen
oder mehrere Container mit gemeinsamem Netzwerk und Speicher kapselt.

Warum zwei Felder? --reasoning-parser=qwen3 trennt den <think>-Block in reasoning_content ab, Clients zeigen nur content. Ohne Denken: "chat_template_kwargs": {"enable_thinking": false} im Request.

Tool Calling: das Modell soll eine Funktion aufrufen statt zu raten.

curl -s localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
  "model": "qwen3-8b",
  "messages": [{"role": "user", "content": "Wie viele Pods laufen in ki-models?"}],
  "tools": [{"type": "function", "function": {
    "name": "count_pods",
    "description": "Zählt laufende Pods in einem Namespace",
    "parameters": {"type": "object", "required": ["namespace"],
      "properties": {"namespace": {"type": "string"}}}}}],
  "tool_choice": "auto",
  "chat_template_kwargs": {"enable_thinking": false}
}' | jq -c '.choices[0] | {finish_reason, call: .message.tool_calls[0].function}'

Erwartet (nicht live getestet):

{"finish_reason":"tool_calls","call":{"name":"count_pods",
"arguments":"{\"namespace\": \"ki-models\"}"}}

--enable-auto-tool-choice plus der passende Parser sind Pflicht, sonst steht der Tool-Call als Text in content. Qwen nutzt das Hermes-Format (hermes), Mistral-Modelle mistral, Qwen3-Coder qwen3_xml.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Engine-Flags und Quantisierung

Flag Wirkung Lab-Wert
--gpu-memory-utilization Anteil des gesamten VRAMs für diese Instanz (Default 0.92) 0.80 (Embed braucht 0.12)
--max-model-len maximale Kontextlänge (Prompt + Antwort) 16384
--max-num-seqs parallele Sequenzen pro Schritt 32
--enable-prefix-caching KV-Blöcke gleicher Präfixe (System-Prompt, RAG-Kontext) wiederverwenden an
--quantization Verfahren der Gewichte; AWQ/FP8 erkennt vLLM aus der config.json automatisch
--kv-cache-dtype fp8 KV-Cache in FP8: doppelt so viele Tokens, minimal ungenauer aus

Prüfe, was vLLM aus dem Modell gelesen hat:

kubectl -n ki-models logs deploy/vllm-chat | grep -E -m3 \
  'quantization=|dtype=|enable_prefix_caching'

Erwartet (gekürzt, nicht live getestet):

INFO ... non-default args: {'model': 'Qwen/Qwen3-8B-FP8', 'max_model_len': 16384,
'served_model_name': ['qwen3-8b'], 'gpu_memory_utilization': 0.8, ...}
INFO ... dtype=torch.bfloat16, ... quantization=fp8, enforce_eager=False, ...

Quantisierung in einem Satz: FP8 halbiert die Gewichte bei kaum messbarem Qualitätsverlust und rechnet auf Ada/Hopper nativ. AWQ (4 Bit) viertelt sie, läuft auch auf älteren Karten, kostet aber etwas Qualität. Ein BF16-Modell kannst du mit --quantization fp8 beim Laden quantisieren – dann lädst du allerdings die vollen 16 GB herunter.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Metriken und Lasttest

cat > vllm-monitoring.yaml <<'EOF'
# Prometheus scrapt /metrics aller vLLM-Services in ki-models (Tag 11)
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: vllm
  namespace: ki-models
spec:
  selector:
    matchExpressions:
      - key: app
        operator: In
        values: ["vllm-chat", "vllm-embed", "vllm-code"]
  endpoints:
    - port: http
      path: /metrics
      interval: 15s
EOF
kubectl apply -f vllm-monitoring.yaml
curl -s localhost:8000/metrics | grep -E '^vllm:(num_requests|kv_cache_usage)'

Erwartet (nicht live getestet, Labels gekürzt):

servicemonitor.monitoring.coreos.com/vllm created
vllm:num_requests_running{engine="0",model_name="qwen3-8b"} 0.0
vllm:num_requests_waiting{engine="0",model_name="qwen3-8b"} 0.0
vllm:kv_cache_usage_perc{engine="0",model_name="qwen3-8b"} 0.0

Der ServiceMonitor wählt Services per Label app – auch die von Tag 13 (vllm-embed) und Tag 14 (vllm-code), sofern deren Service dieses Label trägt.

Jetzt Last: vllm bench serve läuft direkt im Pod und nutzt den Tokenizer aus dem Cache.

kubectl -n ki-models exec deploy/vllm-chat -- vllm bench serve \
  --model qwen3-8b --tokenizer Qwen/Qwen3-8B-FP8 --endpoint /v1/completions \
  --dataset-name random --random-input-len 1024 --random-output-len 256 \
  --num-prompts 200 --max-concurrency 48 2>&1 | grep -E 'Successful|throughput|TTFT'

Erwartet (nicht live getestet, Werte stark hardwareabhängig):

Successful requests:                     200
Request throughput (req/s):              2.41
Output token throughput (tok/s):         598.7
Mean TTFT (ms):                          2210.43
P99 TTFT (ms):                           6034.12

Während der Test läuft, im zweiten Terminal die wichtigsten PromQL-Abfragen (Funktion promq aus Tag 10):

promq 'sum(vllm:num_requests_running{model_name="qwen3-8b"})'
promq 'sum(vllm:num_requests_waiting{model_name="qwen3-8b"})'
promq 'max(vllm:kv_cache_usage_perc{model_name="qwen3-8b"})'
promq 'histogram_quantile(0.95, sum by (le)
  (rate(vllm:time_to_first_token_seconds_bucket[5m])))'
promq 'sum(rate(vllm:generation_tokens_total[1m]))'
promq 'sum(rate(vllm:prefix_cache_hits_total[5m]))
  / sum(rate(vllm:prefix_cache_queries_total[5m]))'
Abfrage Bedeutung Handeln, wenn …
num_requests_running Sequenzen im Batch dauerhaft = --max-num-seqs
num_requests_waiting Warteschlange > 0 über Minuten: skalieren
kv_cache_usage_perc KV-Cache-Füllstand 0–1 nahe 1: Preemption, Latenz steigt
TTFT p95 Zeit bis zum ersten Token > 2 s im Chat spürbar

Warum ist die Warteschlange das beste Skalierungssignal? GPU-Auslastung steht bei vLLM fast immer bei 100 %, CPU sagt nichts. Erst wenn Requests warten, fehlt Kapazität.

Fortschritt speichern? Kostenlos registrieren

Drill 7: KEDA auf die Warteschlange

helm repo add kedacore https://kedacore.github.io/charts
helm repo update kedacore
helm upgrade --install keda kedacore/keda --version 2.21.0 \
  -n keda --create-namespace --wait
cat > keda-scaledobject.yaml <<'EOF'
# KEDA skaliert vllm-chat nach Warteschlange (Tag 11)
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: vllm-chat
  namespace: ki-models
spec:
  scaleTargetRef:
    name: vllm-chat
  minReplicaCount: 1
  maxReplicaCount: 2           # Lab: zweite Replika braucht eine zweite GPU!
  pollingInterval: 15
  cooldownPeriod: 300          # Modell-Laden ist teuer: langsam herunterskalieren
  triggers:
    - type: prometheus
      metadata:
        serverAddress: http://kube-prometheus-stack-prometheus.monitoring:9090
        query: sum(vllm:num_requests_waiting{namespace="ki-models",
          model_name="qwen3-8b"})
        threshold: "5"
EOF
kubectl apply -f keda-scaledobject.yaml
kubectl -n ki-models get scaledobject vllm-chat
kubectl -n ki-models get hpa

Erwartet (Dry-Run live getestet, Rest nicht live getestet):

scaledobject.keda.sh/vllm-chat created
NAME        SCALETARGETKIND      SCALETARGETNAME   MIN   MAX   READY   ACTIVE
vllm-chat   apps/v1.Deployment   vllm-chat         1     2     True    False
NAME                 REFERENCE              TARGETS     MINPODS   MAXPODS
keda-hpa-vllm-chat   Deployment/vllm-chat   0/5 (avg)   1         2

Starte den Lasttest aus Drill 6 erneut mit --max-concurrency 96. KEDA skaliert auf 2, und dann passiert die Lektion des Tages:

kubectl -n ki-models get pods -l app=vllm-chat
kubectl -n ki-models logs -l app=vllm-chat --tail=3 | grep -i memory

Erwartet (nicht live getestet, gekürzt):

NAME                         READY   STATUS             RESTARTS
vllm-chat-6d8f7c9b5-k2m4x    1/1     Running            0
vllm-chat-6d8f7c9b5-r7t9q    0/1     CrashLoopBackOff   2
ValueError: Free memory on device (4.1/22.0 GiB) on startup is less than
desired GPU memory utilization (0.8, 17.6 GiB). ...

Time-Slicing meldet vier Slots, aber VRAM gibt es nur einmal. Bis ein zweiter GPU-Node da ist, deckelst du KEDA:

kubectl -n ki-models patch scaledobject vllm-chat --type merge \
  -p '{"spec":{"maxReplicaCount":1}}'

Fortschritt speichern? Kostenlos registrieren

Drill 8: Rolling Update auf einer GPU

maxSurge: 0 heißt: erst den alten Pod beenden, dann den neuen starten. Das kostet eine Lücke von ein bis zwei Minuten – dafür startet der neue Pod nicht gegen belegten VRAM. LiteLLM fängt die Lücke in Tag 12 per Fallback ab.

kubectl -n ki-models patch deploy vllm-chat --type json -p '[{"op": "replace",
  "path": "/spec/template/spec/containers/0/args/4", "value": "--max-num-seqs=48"}]'
kubectl -n ki-models get pods -l app=vllm-chat -w

Erwartet (nicht live getestet, Strg+C nach 1/1):

NAME                         READY   STATUS        RESTARTS   AGE
vllm-chat-6d8f7c9b5-k2m4x    1/1     Terminating   0          40m
vllm-chat-7f9c8d6b4-p3q8w    0/1     Pending       0          0s
vllm-chat-7f9c8d6b4-p3q8w    0/1     Running       0          5s
vllm-chat-7f9c8d6b4-p3q8w    1/1     Running       0          82s

Der zweite Start dauert nur gut eine Minute, weil die Gewichte schon auf local-path liegen. Mit strategy: Recreate (wie vllm-embed in Tag 13) erreichst du dasselbe; RollingUpdate mit maxSurge: 0 skaliert aber sauber mit, sobald es mehr Replikas auf mehreren GPUs gibt.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
export KUBECONFIG=~/ki-lab/rke2.yaml
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "vllm-chat Ready" 'kubectl -n ki-models rollout status deploy/vllm-chat \
  --timeout=10s'
check "Modell-Cache auf local-path" '[ "$(kubectl -n ki-models get pvc \
  vllm-chat-cache -o jsonpath="{.spec.storageClassName}")" = local-path ]'
check "API liefert qwen3-8b" 'kubectl -n ki-models exec deploy/vllm-chat -- \
  python3 -c "import urllib.request as u; print(u.urlopen( \
  \"http://localhost:8000/v1/models\").read())" | grep -q qwen3-8b'
check "Prometheus kennt vllm:num_requests_waiting" '[ -n "$(promq \
  "vllm:num_requests_waiting{model_name=\"qwen3-8b\"}")" ]'
check "ScaledObject Ready" '[ "$(kubectl -n ki-models get scaledobject \
  vllm-chat -o jsonpath="{.status.conditions[?(@.type==\"Ready\")].status}")" \
  = True ]'
check "maxSurge 0" '[ "$(kubectl -n ki-models get deploy vllm-chat -o \
  jsonpath="{.spec.strategy.rollingUpdate.maxSurge}")" = 0 ]'

Erwartet:

✔ vllm-chat Ready
✔ Modell-Cache auf local-path
✔ API liefert qwen3-8b
✔ Prometheus kennt vllm:num_requests_waiting
✔ ScaledObject Ready
✔ maxSurge 0

Challenge

Stelle vllm-chat auf die AWQ-Variante um und vergleiche die KV-Cache-Größe im Log mit FP8. Der Modellname in der API bleibt qwen3-8b, damit LiteLLM nichts merkt.

Hinweis: Nur das erste Argument ändert sich; das Sizing-Skript nimmt Repo-Namen und Gewichtsgröße (6,1 GB) als Parameter.

Lösung

sed -i.bak 's#- Qwen/Qwen3-8B-FP8#- Qwen/Qwen3-8B-AWQ#' vllm-chat.yaml
python3 kv-sizing.py Qwen/Qwen3-8B-AWQ 6.1
kubectl apply -f vllm-chat.yaml
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=20m
kubectl -n ki-models logs deploy/vllm-chat | grep -E 'quantization=|KV cache size'

Erwartet (Rechnung live getestet, Log nicht live getestet):

Qwen/Qwen3-8B-AWQ: 144 KiB KV pro Token
KV-Budget 11.6 GB -> ca. 84,468 Tokens im Cache
...
INFO ... quantization=awq_marlin ...
INFO ... GPU KV cache size: 81,840 tokens

Der KV-Bedarf pro Token bleibt gleich – nur die Gewichte schrumpfen, also passt mehr Kontext. Zurück zu FP8: mv vllm-chat.yaml.bak vllm-chat.yaml && kubectl apply -f vllm-chat.yaml.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Modell-Freigabe als Prozess: Lizenz, Herkunft, Hash der Gewichte (hf download <repo> --revision <commit>), Pinning per --revision statt main.
  • Kein Internet im Cluster: Gewichte über einen internen Mirror (S3/Artifactory, HF_ENDPOINT) oder vorab per Job auf ein RWX-Volume, HF_HUB_OFFLINE=1 im Pod.
  • vLLM direkt nur intern: --api-key oder NetworkPolicy, sodass nur LiteLLM (ki-gateway) Port 8000 erreicht.
  • Skalierung über mehrere GPU-Nodes: KEDA auf Warteschlange plus Cluster-Autoscaler/Kapazität, Routing mit Prefix-Cache-Affinität (vLLM Production Stack, llm-d, KServe).
  • SLOs auf TTFT p95 und Inter-Token-Latenz statt CPU – Alarme aus den PromQL-Abfragen aus Drill 6.