Zum Inhalt springen
Trainingslager IT-Trainingslager

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 auf chat-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 per kubectl, 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.yaml mit 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 per helm template + kubeconform und kubectl apply --dry-run=server validiert. 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/redis

Erwartet (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.yaml

Erwartet:

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.txt

Erwartet (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=1

Fortschritt 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.crt
cat > 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/redis

Erwartet (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=1

Erwartet (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_state und 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).