Tag 11: vLLM auf der GPU
Ziel:
vllm-chatserviert Qwen3-8B (FP8) aufrke2-gpu-1mit Modell-Cache, Tool Calling, Metriken und einer KEDA-Regel auf die Warteschlange. · Dauer: ca. 150 min · Voraussetzung: Tag 10
Briefing
- Ein Deployment
vllm-chatinki-models, Servicevllm-chat.ki-models:8000, Modellname in der APIqwen3-8b. LiteLLM hängt es in Tag 12 alschat-largeein. - Gewichte liegen auf
local-path(/var/lib/ki-modelsauf 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.pyErwartet (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-3Erwartet:
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 hpaErwartet (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 memoryErwartet (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 -wErwartet (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--revisionstattmain. - Kein Internet im Cluster: Gewichte über einen internen Mirror
(S3/Artifactory,
HF_ENDPOINT) oder vorab per Job auf ein RWX-Volume,HF_HUB_OFFLINE=1im Pod. - vLLM direkt nur intern:
--api-keyoder 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.