Tag 12: LiteLLM produktiv
Ziel: LiteLLM läuft mit zwei Replikas hinter
https://llm.lab.internal, teilt Rate-Limits über Redis, speichert Teams und Keys in CloudNativePG und weicht bei GPU-Ausfall auf die Mistral API aus. · Dauer: ca. 150 min · Voraussetzung: Tag 11
Briefing
- Zwei Replikas brauchen gemeinsamen Zustand: Postgres (Keys, Teams, Spend) und Redis (RPM/TPM-Zähler, Cooldowns, Cache).
chat-large→vllm-chat(Tag 11). Fällt die GPU aus, springt der Router aufchat-large-eu(Mistral API, EU).- Teams bekommen Modelle, Budgets und Limits per API – nicht per Klick.
- Secrets kommen als ein Secret
litellm-env– im Lab perkubectl, sauber per External Secrets Operator aus OpenBao.
Client --TLS--> Traefik (llm.lab.internal, lab-ca)
|
litellm x2 (ki-gateway) ---- Redis (Limits, Cache)
| \________________ CNPG litellm-db (rw/ro)
| chat-large
+--> vllm-chat.ki-models:8000 (lokal, Tag 11)
+--> api.mistral.ai (Fallback chat-large-eu)
Achtung: Live getestet: die komplette
config.yamlmit LiteLLM 1.104.2 (pip-venv) gegen Ollama auf dem Laptop als Ersatz für vLLM und Mistral – inklusive zwei Proxy-Instanzen an einem Redis, Postgres, Teams, Keys, Fallback, Guardrail und/metrics. Kubernetes-Teile perhelm template+kubeconformundkubectl apply --dry-run=servervalidiert. Ausgaben aus dem Cluster sind „nicht live getestet“ markiert.
Drill 1: Namespace und Secret
litellm-env
export KUBECONFIG=~/ki-lab/rke2.yaml
mkdir -p ~/ki-lab/code/litellm-prod && cd ~/ki-lab/code/litellm-prod
kubectl create namespace ki-gateway
read -rs MISTRAL_API_KEY && export MISTRAL_API_KEY # von console.mistral.ai
kubectl -n ki-gateway create secret generic litellm-env \
--from-literal=PROXY_MASTER_KEY=sk-lab-master-1234 \
--from-literal=LITELLM_SALT_KEY=sk-lab-salt-1234 \
--from-literal=REDIS_PASSWORD=lab-redis-1234 \
--from-literal=MISTRAL_API_KEY="$MISTRAL_API_KEY"
unset MISTRAL_API_KEY
kubectl -n ki-gateway get secret litellm-env -o json | jq -r '.data | keys[]'Erwartet:
namespace/ki-gateway created
secret/litellm-env created
LITELLM_SALT_KEY
MISTRAL_API_KEY
PROXY_MASTER_KEY
REDIS_PASSWORD
Die ersten drei Werte sind Lab-Werte. LITELLM_SALT_KEY
verschlüsselt in der DB gespeicherte Provider-Credentials und darf sich
nach dem ersten Start nie mehr ändern. Ohne Mistral-Account: Dummy-Wert
setzen, dann schlägt nur der Fallback in Drill 6 fehl. In Drill 8
ersetzt du das Secret durch eines aus OpenBao.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Postgres mit CloudNativePG
helm repo add cnpg https://cloudnative-pg.github.io/charts
helm repo update cnpg
helm upgrade --install cnpg cnpg/cloudnative-pg --version 0.29.1 \
-n cnpg-system --create-namespace --wait
cat > litellm-db.yaml <<'EOF'
# Postgres für LiteLLM per CloudNativePG (Tag 12): 1 Primary + 1 Replica
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
name: litellm-db
namespace: ki-gateway
spec:
instances: 2
storage:
size: 5Gi
storageClass: longhorn
bootstrap:
initdb:
database: litellm
owner: litellm # Passwort erzeugt CNPG im Secret litellm-db-app
affinity:
enablePodAntiAffinity: true
topologyKey: kubernetes.io/hostname
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
memory: 1Gi
EOF
kubectl apply -f litellm-db.yaml
kubectl -n ki-gateway wait cluster/litellm-db --for=condition=Ready --timeout=300s
kubectl -n ki-gateway get cluster litellm-db
kubectl -n ki-gateway get secret litellm-db-app -o json \
| jq -r '.data | keys | join(" ")'Erwartet (Dry-Run live getestet, Rest gekürzt, nicht live getestet):
cluster.postgresql.cnpg.io/litellm-db created
cluster.postgresql.cnpg.io/litellm-db condition met
NAME AGE INSTANCES READY STATUS PRIMARY
litellm-db 2m 2 2 Cluster in healthy state litellm-db-1
dbname host jdbc-uri password pgpass port uri user username
Warum CNPG statt des Postgres im LiteLLM-Chart? Das Chart zieht
Bitnami-Legacy-Images ohne Updates. CNPG macht Failover, Backups
(Barman/S3) und rotiert Zugangsdaten; der Service
litellm-db-rw zeigt immer auf den Primary.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Redis für gemeinsamen Zustand
cat > redis.yaml <<'EOF'
# Redis für gemeinsame Rate-Limits, Cooldowns und Cache (Tag 12)
# Bewusst ohne Persistenz: Inhalt ist flüchtig, Spend liegt in Postgres.
apiVersion: apps/v1
kind: Deployment
metadata:
name: redis
namespace: ki-gateway
labels:
app: redis
spec:
replicas: 1
selector:
matchLabels:
app: redis
template:
metadata:
labels:
app: redis
spec:
securityContext:
runAsNonRoot: true
runAsUser: 999
containers:
- name: redis
image: redis:8.8-alpine
args: ["--requirepass", "$(REDIS_PASSWORD)", "--maxmemory", "256mb",
"--maxmemory-policy", "allkeys-lru", "--save", ""]
env:
- name: REDIS_PASSWORD
valueFrom:
secretKeyRef:
name: litellm-env
key: REDIS_PASSWORD
ports:
- name: redis
containerPort: 6379
readinessProbe:
tcpSocket:
port: redis
resources:
requests:
cpu: 50m
memory: 128Mi
limits:
memory: 384Mi
---
apiVersion: v1
kind: Service
metadata:
name: redis
namespace: ki-gateway
spec:
selector:
app: redis
ports:
- name: redis
port: 6379
targetPort: redis
EOF
kubectl apply -f redis.yaml
kubectl -n ki-gateway rollout status deploy/redisErwartet (Dry-Run live getestet, Rest nicht live getestet):
deployment.apps/redis created
service/redis created
deployment "redis" successfully rolled out
$(REDIS_PASSWORD) in args ersetzt das
Kubelet aus der Env-Variable – das Passwort steht so nicht im
Manifest.
Fortschritt speichern? Kostenlos registrieren
Drill 4: config.yaml und Helm-Release
Die Konfiguration erweitert Tag 4 um Redis, Fallback, interne Kosten und eine Guardrail.
cat > config.yaml <<'EOF'
# LiteLLM produktiv auf RKE2 (Tag 12)
# Lokal: vLLM auf rke2-gpu-1 (Tag 11). Fallback: Mistral API (EU) per Env-Key.
model_list:
- model_name: chat-large
litellm_params:
model: openai/qwen3-8b # --served-model-name in vLLM
api_base: os.environ/VLLM_CHAT_API_BASE
api_key: "none" # vLLM ohne --api-key
timeout: 120
rpm: 120 # Router-Limit dieses Deployments
input_cost_per_token: 0.0000002 # interne Verrechnung (Lab-Werte)
output_cost_per_token: 0.0000006
model_info:
mode: chat
- model_name: chat-small # Lab: dieselbe GPU, kürzere Antworten
litellm_params:
model: openai/qwen3-8b
api_base: os.environ/VLLM_CHAT_API_BASE
api_key: "none"
max_tokens: 512
input_cost_per_token: 0.0000002
output_cost_per_token: 0.0000006
model_info:
mode: chat
- model_name: chat-large-eu # nur als Fallback gedacht
litellm_params:
model: mistral/mistral-small-latest
api_key: os.environ/MISTRAL_API_KEY
timeout: 60
model_info:
mode: chat
router_settings:
routing_strategy: simple-shuffle
num_retries: 1
allowed_fails: 2 # danach Cooldown
cooldown_time: 30
fallbacks:
- chat-large: ["chat-large-eu"]
# gemeinsamer Zustand aller Replikas (RPM/TPM, Cooldowns)
redis_host: os.environ/REDIS_HOST
redis_port: os.environ/REDIS_PORT
redis_password: os.environ/REDIS_PASSWORD
litellm_settings:
drop_params: true
callbacks: ["prometheus"]
require_auth_for_metrics_endpoint: false # Prometheus scrapt ohne Key
cache: true
cache_params:
type: redis
host: os.environ/REDIS_HOST
port: os.environ/REDIS_PORT
password: os.environ/REDIS_PASSWORD
ttl: 600
supported_call_types: ["acompletion", "completion"]
guardrails:
- guardrail_name: lab-filter
litellm_params:
guardrail: litellm_content_filter
mode: pre_call
default_on: true
patterns:
- pattern_type: prebuilt
pattern_name: email
action: MASK
blocked_words:
- keyword: "STRENG VERTRAULICH"
action: BLOCK
general_settings:
master_key: os.environ/PROXY_MASTER_KEY
database_url: os.environ/DATABASE_URL
EOF
kubectl -n ki-gateway create configmap litellm-config --from-file=config.yamlErwartet:
configmap/litellm-config created
code, embed ergänzen Tag 13 und 14 als
weitere Einträge in model_list. Danach:
kubectl create configmap ... --dry-run=client -o yaml | kubectl apply -f -
und
kubectl -n ki-gateway rollout restart deploy/litellm.
Jetzt das Chart mit zwei Replikas, externer DB, Ingress und ServiceMonitor:
cat > litellm-values.yaml <<'EOF'
# LiteLLM Helm-Chart 1.104.2 (oci://ghcr.io/berriai/litellm-helm), Tag 12
replicaCount: 2
image:
tag: "1.104.2"
pullPolicy: IfNotPresent
proxyConfigMap:
create: false
name: litellm-config # aus config.yaml (kubectl create configmap)
masterkeySecretName: litellm-env
masterkeySecretKey: PROXY_MASTER_KEY
environmentSecrets:
- litellm-env # MISTRAL_API_KEY, REDIS_PASSWORD, PROXY_MASTER_KEY
envVars:
VLLM_CHAT_API_BASE: http://vllm-chat.ki-models:8000/v1
REDIS_HOST: redis.ki-gateway
REDIS_PORT: "6379"
db:
deployStandalone: false
useExisting: true
endpoint: litellm-db-rw # CNPG-Service des Primary
database: litellm
secret:
name: litellm-db-app # von CNPG erzeugt
usernameKey: username
passwordKey: password
migrationJob:
hooks:
argocd:
enabled: false
helm:
enabled: true # Job als pre-install/pre-upgrade-Hook
ingress:
enabled: true
className: traefik
annotations:
cert-manager.io/cluster-issuer: lab-ca
hosts:
- host: llm.lab.internal
paths:
- path: /
pathType: Prefix
tls:
- secretName: litellm-tls
hosts: ["llm.lab.internal"]
serviceMonitor:
enabled: true
interval: 30s
pdb:
enabled: true
minAvailable: 1
topologySpreadConstraints:
- maxSkew: 1
topologyKey: kubernetes.io/hostname
whenUnsatisfiable: ScheduleAnyway
labelSelector:
matchLabels:
app.kubernetes.io/name: litellm
resources:
requests:
cpu: 250m
memory: 768Mi
limits:
memory: 2Gi
EOF
helm upgrade --install litellm oci://ghcr.io/berriai/litellm-helm --version 1.104.2 \
-n ki-gateway -f litellm-values.yaml --wait --timeout 10m
kubectl -n ki-gateway get pods -l app.kubernetes.io/name=litellm -o wide \
| awk '{print $1, $3, $7}'
curl -s https://llm.lab.internal/health/readiness | jq -c '{status, db, cache}'Erwartet (Rendering und Dry-Run live getestet, Cluster-Ausgabe nicht live getestet):
Release "litellm" does not exist. Installing it now.
STATUS: deployed
NAME STATUS NODE
litellm-5c7d9b8f6-4kq2m Running rke2-wk-1
litellm-5c7d9b8f6-x8n3v Running rke2-wk-2
{"status":"healthy","db":"connected","cache":null}
| Wert | Warum? |
|---|---|
migrationJob als Helm-Hook |
Prisma-Migration läuft einmal vor dem Rollout; das Chart setzt in
den Proxy-Pods DISABLE_SCHEMA_UPDATE=true, damit zwei
Replikas nicht gleichzeitig migrieren |
pdb.minAvailable: 1 |
Node-Drain (RKE2-Upgrade, Tag 8) nimmt nie beide Pods |
topologySpreadConstraints |
Replikas auf verschiedene Worker; Taints halten sie von GPU- und Server-Nodes fern |
cache: null in /health/readiness |
normal – Redis prüft /cache/ping (Kontrollpunkt) |
Fortschritt speichern? Kostenlos registrieren
Drill 5: Teams, Virtual Keys und Budgets per API
export LITELLM_MASTER_KEY=sk-lab-master-1234 # Lab-Wert
H=(-H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json')
API=https://llm.lab.internal
TEAM=$(curl -s $API/team/new "${H[@]}" -d '{"team_alias": "team-platform",
"models": ["chat-large", "chat-small", "chat-large-eu"],
"max_budget": 20, "budget_duration": "30d", "rpm_limit": 60}' | jq -r .team_id)
curl -s "$API/team/info?team_id=$TEAM" "${H[@]}" \
| jq -c '.team_info | {team_alias, max_budget, budget_reset_at}'
KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
\"key_alias\": \"thomas-laptop\", \"models\": [\"chat-small\"],
\"max_budget\": 5, \"rpm_limit\": 2}" | jq -r .key)
echo "${KEY:0:6}..."
for i in 1 2 3; do
curl -s -o /dev/null -w '%{http_code}\n' $API/v1/chat/completions \
-H "Authorization: Bearer $KEY" -H 'Content-Type: application/json' \
-d "{\"model\": \"chat-small\", \"messages\": [{\"role\": \"user\",
\"content\": \"Zahl $i?\"}]}"
done
curl -s -w '\n' $API/v1/chat/completions -H "Authorization: Bearer $KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "chat-large", "messages": [{"role": "user", "content": "x"}]}' \
| jq -r '.error.type'Erwartet (live getestet, IDs und Datum weichen ab):
{"team_alias":"team-platform","max_budget":20.0,
"budget_reset_at":"2026-11-01T00:00:00Z"}
sk-pA5...
200
200
429
key_model_access_denied
Das dritte Request scheitert am rpm_limit: 2, egal
welche der beiden Replikas es bekommt – der Zähler liegt in Redis.
Getestet mit zwei Proxy-Instanzen an einem Redis: Request 1 an Instanz
A, 2 und 3 an Instanz B ergab 200 200 429.
sleep 30
curl -s $API/key/info -H "Authorization: Bearer $KEY" \
| jq -c '.info | {key_alias, spend, max_budget}'Erwartet (live getestet, Betrag weicht ab):
{"key_alias":"thomas-laptop","spend":0.0004188,"max_budget":5.0}
Ohne
input_cost_per_token/output_cost_per_token
bliebe spend bei lokalen Modellen 0 und Budgets wären
wirkungslos. Die Werte sind deine interne Verrechnung (Strom,
Abschreibung), keine Listenpreise.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Fallback auf die EU-API und Metriken
Simuliere den GPU-Ausfall: vllm-chat auf 0 (KEDA aus Tag
11 vorher pausieren).
kubectl -n ki-models annotate scaledobject vllm-chat \
autoscaling.keda.sh/paused-replicas=0 --overwrite
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=60s
curl -s -D hdr.txt $API/v1/chat/completions "${H[@]}" -d '{"model": "chat-large",
"messages": [{"role": "user", "content": "Antworte nur mit OK"}]}' \
| jq -c '{model, content: .choices[0].message.content}'
grep -i -E '^x-litellm-(model-group|attempted-fallbacks)' hdr.txtErwartet (live getestet mit totem Backend, Mistral-Antwort nicht live getestet):
{"model":"mistral-small-latest","content":"OK"}
x-litellm-model-group: chat-large-eu
x-litellm-attempted-fallbacks: 1
Prometheus sieht den Ausfall auch (promq aus Tag
10):
promq 'max by (litellm_model_name) (litellm_deployment_state)'
promq 'sum by (fallback_model) (litellm_deployment_successful_fallbacks_total)'
promq 'sum by (model_group) (rate(litellm_proxy_total_requests_metric_total[5m]))'Erwartet (Metriknamen live getestet, Werte nicht live getestet):
- 2
- 1
- 0.05
litellm_deployment_state: 0 = gesund, 1 = teilweise, 2 =
Ausfall. Das ist dein Alarm „lokales Modell weg, Daten fließen nach
extern“. GPU zurück:
kubectl -n ki-models annotate scaledobject vllm-chat \
autoscaling.keda.sh/paused-replicas-
kubectl -n ki-models scale deploy vllm-chat --replicas=1Fortschritt speichern? Kostenlos registrieren
Drill 7: Guardrail – maskieren und blocken
Die Guardrail lab-filter läuft vor jedem Call
(default_on: true): E-Mail-Adressen werden maskiert,
„STRENG VERTRAULICH“ blockiert.
curl -s $API/v1/chat/completions "${H[@]}" -d '{"model": "chat-large",
"messages": [{"role": "user", "content": "Fasse zusammen: STRENG VERTRAULICH"}]}' \
| jq -c '.error | {code, message}'
curl -s $API/v1/chat/completions "${H[@]}" -d '{"model": "chat-large",
"messages": [{"role": "user", "content":
"Wiederhole wörtlich nur diesen Text: Mail an [email protected]"}],
"chat_template_kwargs": {"enable_thinking": false}}' \
| jq -r '.choices[0].message.content'Erwartet (live getestet, Modellantwort variiert):
{"code":"400","message":"Content blocked: keyword 'streng vertraulich' detected"}
Mail an [EMAIL_REDACTED]
Das Modell bekommt die Adresse nie zu sehen – wichtig, sobald ein Fallback nach extern geht. Für deutsche PII (IBAN, Steuer-ID, Namen) reichen Muster nicht; dafür gibt es die Presidio-Integration (eigene Analyzer-Pods).
Fortschritt speichern? Kostenlos registrieren
Drill 8: Secrets aus OpenBao per ESO (kurz)
Voraussetzung: ein OpenBao unter
https://bao.lab.internal:8200 mit Lab-CA-Zertifikat und
Kubernetes-Auth für diesen Cluster (siehe OpenBao-Trainingslager, Tag
11).
bao kv put -mount=secret ki-gateway/litellm \
PROXY_MASTER_KEY=sk-lab-master-1234 LITELLM_SALT_KEY=sk-lab-salt-1234 \
REDIS_PASSWORD=lab-redis-1234 MISTRAL_API_KEY="$MISTRAL_API_KEY"
bao policy write litellm-read - <<'EOF'
path "secret/data/ki-gateway/litellm" { capabilities = ["read"] }
EOF
bao write auth/kubernetes/role/litellm bound_service_account_names=litellm-eso \
bound_service_account_namespaces=ki-gateway audience=openbao \
token_policies=litellm-read token_ttl=10m
helm repo add external-secrets https://charts.external-secrets.io
helm upgrade --install external-secrets external-secrets/external-secrets \
--version 2.12.0 -n external-secrets --create-namespace --wait
kubectl -n ki-gateway create configmap lab-ca --from-file=ca.crt=$HOME/ki-lab/lab-ca.crtcat > litellm-eso.yaml <<'EOF'
# Secrets aus OpenBao per External Secrets Operator (Tag 12, optional)
apiVersion: v1
kind: ServiceAccount
metadata:
name: litellm-eso
namespace: ki-gateway
---
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
name: openbao
namespace: ki-gateway
spec:
provider:
vault: # OpenBao spricht die Vault-API
server: https://bao.lab.internal:8200
path: secret
version: v2
caProvider:
type: ConfigMap
name: lab-ca
key: ca.crt
auth:
kubernetes:
mountPath: kubernetes
role: litellm
serviceAccountRef:
name: litellm-eso
audiences: ["openbao"]
---
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
name: litellm-env
namespace: ki-gateway
spec:
refreshInterval: 1h
secretStoreRef:
kind: SecretStore
name: openbao
target:
name: litellm-env
creationPolicy: Owner
dataFrom:
- extract:
key: ki-gateway/litellm # Keys = Env-Namen
EOF
kubectl -n ki-gateway delete secret litellm-env
kubectl apply -f litellm-eso.yaml
kubectl -n ki-gateway wait externalsecret/litellm-env --for=condition=Ready \
--timeout=60s
kubectl -n ki-gateway rollout restart deploy/litellm deploy/redisErwartet (Dry-Run live getestet, Rest nicht live getestet):
...
externalsecret.external-secrets.io/litellm-env condition met
deployment.apps/litellm restarted
deployment.apps/redis restarted
Die Keys in OpenBao heißen wie die Env-Variablen, deshalb reicht
dataFrom.extract. Ein Rotationswert in OpenBao wird nach
spätestens refreshInterval ins Secret übernommen – die Pods
brauchen danach einen Restart (oder Reloader).
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
export KUBECONFIG=~/ki-lab/rke2.yaml
M=sk-lab-master-1234; API=https://llm.lab.internal # Lab-Werte
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "CNPG litellm-db healthy" 'kubectl -n ki-gateway wait cluster/litellm-db \
--for=condition=Ready --timeout=5s'
check "2 LiteLLM-Replikas Ready" '[ "$(kubectl -n ki-gateway get deploy litellm \
-o jsonpath="{.status.readyReplicas}")" = 2 ]'
check "HTTPS + DB" 'curl -sf $API/health/readiness | grep -q connected'
check "Redis-Cache" 'curl -sf $API/cache/ping -H "Authorization: Bearer $M" \
| grep -q redis'
check "chat-large antwortet" 'curl -sf $API/v1/chat/completions \
-H "Authorization: Bearer $M" -H "Content-Type: application/json" \
-d "{\"model\":\"chat-large\",\"messages\":[{\"role\":\"user\",\"content\":\"Hi\"}]}"'
check "Team team-platform" 'curl -sf $API/team/list -H "Authorization: Bearer $M" \
| grep -q team-platform'
check "Metriken in Prometheus" '[ -n "$(promq litellm_deployment_state)" ]'Erwartet:
✔ CNPG litellm-db healthy
✔ 2 LiteLLM-Replikas Ready
✔ HTTPS + DB
✔ Redis-Cache
✔ chat-large antwortet
✔ Team team-platform
✔ Metriken in Prometheus
Challenge
Der Fallback schickt Prompts nach extern – auch für Teams, die
chat-large-eu gar nicht in ihrer Modellliste haben (live
geprüft!). Lege ein Team team-intern mit Key an, dessen
Requests bei GPU-Ausfall lieber scheitern als die EU-API zu nutzen.
Hinweis: LiteLLM liest
disable_fallbacks auch aus den metadata eines
Keys.
Lösung
T=$(curl -s $API/team/new "${H[@]}" -d '{"team_alias": "team-intern",
"models": ["chat-large", "chat-small"]}' | jq -r .team_id)
KI=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$T\",
\"key_alias\": \"intern-nofb\", \"metadata\": {\"disable_fallbacks\": true}}" \
| jq -r .key)
kubectl -n ki-models scale deploy vllm-chat --replicas=0 # KEDA vorher pausieren
curl -s -w '\n' $API/v1/chat/completions -H "Authorization: Bearer $KI" \
-H 'Content-Type: application/json' \
-d '{"model": "chat-large", "messages": [{"role": "user", "content": "OK?"}]}' \
| jq -r '.error.code'
kubectl -n ki-models scale deploy vllm-chat --replicas=1Erwartet (live getestet mit totem Backend):
500
Ohne disable_fallbacks kam derselbe Request mit
200 von der Fallback-Instanz zurück.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Datenfluss nach extern ist eine Compliance-Entscheidung: Fallback
nur für freigegebene Teams, AVV mit dem Anbieter, Alarm auf
litellm_deployment_stateund Fallback-Zähler. - Redis hochverfügbar (Sentinel oder Valkey-Operator) oder bewusst flüchtig lassen – fällt Redis aus, zählt jede Replika ihre Limits wieder lokal.
- CNPG mit Barman-Backups nach S3 und
ScheduledBackup; Spend-Logs wachsen schnell – Aufbewahrung und Partitionierung planen. - Admin-UI und
/key/*nicht öffentlich: SSO (Enterprise-Feature) oder eigener Ingress nur im Admin-Netz; Master-Key nur für Automatisierung, rotiert über OpenBao. - Guardrails ergänzen: Presidio für PII, Prompt-Injection-Prüfung, Logging-Policy (Prompts nicht im Klartext speichern, wenn der Betriebsrat mitredet).