Tag 15: Betrieb und Wettkampf
Ziel: Du siehst GPU, Tokens und Latenz auf einem Dashboard, wirst bei Störungen alarmiert, kannst den Cluster aus Backups zurückholen und behebst acht typische Ausfälle unter Zeitdruck. · Dauer: ca. 300 min · Voraussetzung: Tag 14
Briefing
- Ein Dashboard
KI-Plattformaus drei Quellen: DCGM (GPU), vLLM (Tokens, TTFT, KV-Cache), LiteLLM (Requests, Spend, Fallbacks). - Alarme als
PrometheusRule ki-alerts– kube-prometheus-stack lädt sie ohne Release-Label (Tag 9). - Zwei Backup-Ebenen:
rke2 etcd-snapshotsichert den Cluster-Zustand, Velero sichert Namespaces samt Volume-Inhalten. Beide schreiben in ein S3 außerhalb des Clusters. - Upgrade-Reihenfolge: RKE2 → GPU-Treiber/Operator → vLLM. Vorher immer Snapshot und Backup.
- Wettkampf: acht Störungen, jede mit Zeitlimit. Stoppuhr beim Auslösen starten, beim grünen Prüfbefehl stoppen.
DCGM :9400 ─┐ ┌─> Grafana grafana.lab.internal
vLLM /metrics ├─> Prometheus (monitoring) ──┤
LiteLLM /metrics┘ PrometheusRule ki-alerts └─> Alertmanager
etcd (cp-1..3) ── rke2 etcd-snapshot ──┐
Namespaces + PVCs ── Velero/kopia ─────┴──> Garage-S3 s3.lab.internal:3900
Achtung: Ohne Cluster auf dieser Maschine sind Cluster-Ausgaben gegen die offizielle Doku (docs.rke2.io, velero.io, docs.vllm.ai, docs.litellm.ai, longhorn.io, cloudnative-pg.io) geprüft, aber nicht live getestet. Live geprüft: Dashboard-Generator, PromQL-Syntax aller Regeln, Manifeste per
kubeconform, Velero-Chart perhelm template, LiteLLM-Metriknamen und Fehlertexte im Quellcode von v1.104.2.
Drill 1: Dashboard für GPU, Tokens und Latenz
Statt JSON von Hand erzeugt ein kleines Skript das Dashboard aus einer Liste von PromQL-Abfragen:
mkdir -p ~/ki-lab/tag15 ~/ki-lab/code/ops && cd ~/ki-lab/code/ops
export KUBECONFIG=~/ki-lab/rke2.yaml
cat > make_dashboard.py <<'EOF'
#!/usr/bin/env python3
"""Erzeugt das Grafana-Dashboard "KI-Plattform" (Tag 15) als JSON auf stdout."""
import json
# (Titel, PromQL, Einheit, Legende)
PANELS = [
("GPU-Auslastung", "avg by (Hostname) (DCGM_FI_DEV_GPU_UTIL)",
"percent", "{{Hostname}}"),
("VRAM belegt", "sum by (Hostname) (DCGM_FI_DEV_FB_USED)"
" / sum by (Hostname) (DCGM_FI_DEV_FB_USED + DCGM_FI_DEV_FB_FREE)",
"percentunit", "{{Hostname}}"),
("GPU-Temperatur", "max by (Hostname) (DCGM_FI_DEV_GPU_TEMP)",
"celsius", "{{Hostname}}"),
("Tokens/s erzeugt",
"sum by (model_name) (rate(vllm:generation_tokens_total[1m]))",
"short", "{{model_name}}"),
("Prompt-Tokens/s",
"sum by (model_name) (rate(vllm:prompt_tokens_total[1m]))",
"short", "{{model_name}}"),
("TTFT p95", "histogram_quantile(0.95, sum by (le, model_name)"
" (rate(vllm:time_to_first_token_seconds_bucket[5m])))",
"s", "{{model_name}}"),
("Warteschlange", "sum by (model_name) (vllm:num_requests_waiting)",
"short", "{{model_name}}"),
("KV-Cache", "max by (model_name) (vllm:kv_cache_usage_perc)",
"percentunit", "{{model_name}}"),
("LiteLLM Requests/s", "sum by (model_group)"
" (rate(litellm_proxy_total_requests_metric_total[5m]))",
"reqps", "{{model_group}}"),
("LiteLLM Latenz p95", "histogram_quantile(0.95, sum by (le, model)"
" (rate(litellm_request_total_latency_metric_bucket[5m])))",
"s", "{{model}}"),
("Spend pro Team (24h)",
"sum by (team_alias) (increase(litellm_spend_metric_total[24h]))",
"short", "{{team_alias}}"),
("Fallbacks nach extern (1h)", "sum by (fallback_model)"
" (increase(litellm_deployment_successful_fallbacks_total[1h]))",
"short", "{{fallback_model}}"),
]
def panel(i: int, title: str, expr: str, unit: str, legend: str) -> dict:
return {
"id": i + 1,
"type": "timeseries",
"title": title,
"datasource": {"type": "prometheus", "uid": "prometheus"},
"gridPos": {"h": 8, "w": 12, "x": (i % 2) * 12, "y": (i // 2) * 8},
"fieldConfig": {"defaults": {"unit": unit}, "overrides": []},
"targets": [{"refId": "A", "expr": expr, "legendFormat": legend}],
}
print(json.dumps({
"title": "KI-Plattform",
"uid": "ki-plattform",
"schemaVersion": 39,
"time": {"from": "now-6h", "to": "now"},
"refresh": "30s",
"panels": [panel(i, *p) for i, p in enumerate(PANELS)],
}, indent=1, ensure_ascii=False))
EOF
python3 make_dashboard.py > ki-plattform.json
jq -r '.panels | length, .[0].title, .[-1].title' ki-plattform.jsonErwartet (live getestet):
12
GPU-Auslastung
Fallbacks nach extern (1h)
Grafana aus kube-prometheus-stack lädt jede ConfigMap mit dem Label
grafana_dashboard=1 im Namespace monitoring
(Sidecar):
kubectl -n monitoring create configmap ki-dashboard \
--from-file=ki-plattform.json --dry-run=client -o yaml \
| kubectl label --local -f - grafana_dashboard=1 -o yaml | kubectl apply -f -
sleep 30
curl -s -u admin:lab-grafana-1234 \
'https://grafana.lab.internal/api/search?query=KI-Plattform' | jq -r '.[].uid'Erwartet (nicht live getestet):
configmap/ki-dashboard created
ki-plattform
Öffne https://grafana.lab.internal/d/ki-plattform und
starte den Lasttest aus Tag 11, Drill 6. Tokens/s, Warteschlange und
KV-Cache bewegen sich gemeinsam, die GPU-Auslastung steht fast sofort
bei 100 %.
| Panel | Gesund | Handeln |
|---|---|---|
| VRAM belegt | konstant ~95 % (Summe der vLLM-Budgets) | sinkt plötzlich: ein vLLM-Pod ist weg |
| TTFT p95 | < 1 s | > 2 s: Warteschlange und KV-Cache prüfen |
| Spend pro Team | linear, vorhersehbar | Sprung: Fallback auf die EU-API |
| Fallbacks nach extern | 0 | > 0: lokales Modell ausgefallen |
Warum {{Hostname}} bei DCGM, aber
model_name bei vLLM? DCGM labelt nach Node, vLLM nach
--served-model-name. Die Labelnamen von LiteLLM
(team_alias, model_group,
fallback_model) stehen im Quellcode unter
litellm/types/integrations/prometheus.py.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Alarme
Zwei Exporter fehlen noch: Longhorn und cert-manager liefern Metriken erst mit ServiceMonitor.
helm upgrade longhorn longhorn/longhorn --version 1.13.0 -n longhorn-system \
--reuse-values --set metrics.serviceMonitor.enabled=true
helm upgrade cert-manager jetstack/cert-manager --version v1.21.2 -n cert-manager \
--reuse-values --set prometheus.servicemonitor.enabled=trueDie Regeln liegen komplett in code/ops/ki-alerts.yaml
(12 Alarme in vier Gruppen). Ein Auszug – die Gruppe für das
Gateway:
- name: ki-gateway
rules:
- alert: KIFallbackExtern
expr: >-
sum by (fallback_model)
(increase(litellm_deployment_successful_fallbacks_total[10m])) > 0
labels: {severity: warning}
annotations:
summary: Prompts gehen an {{ $labels.fallback_model }} (extern)
- alert: KIDeploymentAusfall
expr: max by (litellm_model_name) (litellm_deployment_state) == 2
for: 2m
labels: {severity: critical}
- alert: KITeamBudget
expr: >-
max by (team_alias) (litellm_remaining_team_budget_metric)
/ max by (team_alias) (litellm_team_max_budget_metric) < 0.1
for: 5m
labels: {severity: warning}kubectl apply -f ki-alerts.yaml
sleep 60
promq 'count by (alertname) (ALERTS)'
kubectl -n monitoring exec prometheus-kube-prometheus-stack-prometheus-0 \
-c prometheus -- wget -qO- localhost:9090/api/v1/rules \
| jq -r '.data.groups[] | select(.name | startswith("ki-"))
| "\(.name): \(.rules | length) Regeln"'Erwartet (nicht live getestet; promq aus Tag 10):
prometheusrule.monitoring.coreos.com/ki-alerts created
ki-gpu: 3 Regeln
ki-vllm: 3 Regeln
ki-gateway: 3 Regeln
ki-plattform: 3 Regeln
promq bleibt leer, solange nichts feuert – gut so. Die
Alarme im Überblick:
| Alarm | Auslöser | Szenario |
|---|---|---|
KIGPUFehlt |
kein Node meldet nvidia.com/gpu |
1 |
KIvLLMWeg |
up{job="vllm-chat"} fehlt 3 min |
2, 8 |
KIFallbackExtern |
Fallback auf chat-large-eu |
3 |
KITeamBudget |
Team unter 10 % Restbudget | 3 |
KILonghornDegraded |
longhorn_volume_robustness == 2 |
5 |
KIZertifikatLaeuftAb |
Zertifikat < 7 Tage gültig | 6 |
KIBackupAlt |
letztes Velero-Backup > 26 h | Drill 4 |
Tipp: Alertmanager hat im Lab keinen Empfänger. Für Tests reicht
kubectl -n monitoring port-forward svc/kube-prometheus-stack-alertmanager 9093und die Web-UI. Produktiv:alertmanager.configin den kps-Values mit E-Mail, Matrix oder Teams.
Fortschritt speichern? Kostenlos registrieren
Drill 3: S3-Ziel außerhalb des Clusters
Ein Backup im selben Cluster ist kein Backup. Du brauchst S3 auf
einer anderen Maschine: NAS, Cloud-Bucket in der EU oder eine kleine VM
s3-lab (10.10.20.40, Docker installiert).
MinIO verteilt keine Community-Images mehr – im Lab nimmst du
Garage (AGPL, ein Binary, S3-kompatibel).
# auf s3-lab (10.10.20.40), als root
mkdir -p /etc/garage /var/lib/garage/{meta,data}
cat > /etc/garage/garage.toml <<EOF
metadata_dir = "/var/lib/garage/meta"
data_dir = "/var/lib/garage/data"
db_engine = "sqlite"
replication_factor = 1
rpc_bind_addr = "[::]:3901"
rpc_public_addr = "127.0.0.1:3901"
rpc_secret = "$(openssl rand -hex 32)"
[s3_api]
s3_region = "garage"
api_bind_addr = "[::]:3900"
EOF
docker run -d --name garage --restart unless-stopped --network host \
-v /etc/garage/garage.toml:/etc/garage.toml -v /var/lib/garage:/var/lib/garage \
dxflrs/garage:v2.4.1
G="docker exec garage /garage"
NODE=$($G status | awk '/NO ROLE/ {print $1}')
$G layout assign -z lab -c 200G "$NODE" && $G layout apply --version 1
for b in ki-lab-backup ki-lab-etcd; do $G bucket create $b; done
$G key create ki-lab-backup-key
for b in ki-lab-backup ki-lab-etcd; do
$G bucket allow --read --write $b --key ki-lab-backup-key
done
$G key info ki-lab-backup-key --show-secret | grep -E 'Key ID|Secret key'Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
Key ID: GK3b1f...
Secret key: 9c2e...
Lege Key-ID und Secret auf dem Laptop in eine Datei mit Modus 600 und
s3.lab.internal in DNS bzw. /etc/hosts aller
Nodes (10.10.20.40):
cat > ~/ki-lab/s3-backup.cred <<'EOF'
[default]
aws_access_key_id=HIER-KEY-ID
aws_secret_access_key=HIER-SECRET
EOF
chmod 600 ~/ki-lab/s3-backup.credSicherheit: Der Key darf beide Buckets schreiben und lesen. Wer ihn hat, kann Backups löschen – produktiv kommt Object Lock bzw. ein zweiter, nur lesbarer Key für Restores dazu.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Velero – Backup und Restore-Probe
code/ops/velero-values.yaml (Chart 12.2.1, Velero 1.18),
hier gekürzt: AWS-Plugin gegen Garage, Volume-Inhalte per node-agent mit
kopia, tägliches Schedule ki-taeglich für alle Namespaces
mit Zustand.
configuration:
backupStorageLocation:
- name: default
default: true
provider: aws
bucket: ki-lab-backup
prefix: velero
config:
region: garage
s3ForcePathStyle: "true"
s3Url: http://s3.lab.internal:3900
uploaderType: kopia
defaultVolumesToFsBackup: true # PVC-Inhalte per node-agent (kopia)
credentials:
existingSecret: velero-s3 # Key "cloud" im AWS-Credentials-Format
snapshotsEnabled: false # Longhorn ohne CSI-Snapshot-Klasse im Lab
deployNodeAgent: true
schedules:
ki-taeglich:
schedule: "0 2 * * *"
template:
ttl: 168h
includedNamespaces: [ki-gateway, ki-chat, ki-code, keycloak,
cert-manager, monitoring]cd ~/ki-lab/code/ops
kubectl create namespace velero
kubectl -n velero create secret generic velero-s3 \
--from-file=cloud=$HOME/ki-lab/s3-backup.cred
helm repo add vmware-tanzu https://vmware-tanzu.github.io/helm-charts
helm upgrade --install velero vmware-tanzu/velero --version 12.2.1 \
-n velero -f velero-values.yaml --wait
brew install velero # CLI auf dem Laptop
velero backup-location get
velero schedule getErwartet (nicht live getestet, gekürzt):
NAME PROVIDER BUCKET/PREFIX PHASE LAST VALIDATED DEFAULT
default aws ki-lab-backup/velero Available 10s ago true
NAME STATUS CREATED SCHEDULE BACKUP TTL LAST BACKUP
velero-ki-taeglich Enabled 1m 0 2 * * * 168h0m0s n/a
Ein Backup, das nie zurückgespielt wurde, ist eine Vermutung. Restore-Probe mit einem Wegwerf-Namespace:
kubectl apply -f backup-test.yaml # Namespace, 1-Gi-PVC, Pod schreibt Datum
kubectl -n backup-test wait pod/schreiber --for=condition=Ready --timeout=120s
V1=$(kubectl -n backup-test exec schreiber -- cat /data/probe.txt); echo "$V1"
velero backup create probe --include-namespaces backup-test --wait
kubectl delete namespace backup-test
velero restore create probe-restore --from-backup probe --wait
kubectl -n backup-test wait pod/schreiber --for=condition=Ready --timeout=300s
V2=$(kubectl -n backup-test exec schreiber -- cat /data/probe.txt)
[ "$V1" = "$V2" ] && echo "✔ Restore identisch" || echo "✘ Daten weichen ab"Erwartet (nicht live getestet, gekürzt):
Fri Oct 16 19:02:11 UTC 2026
Backup completed with status: Completed.
namespace "backup-test" deleted
Restore completed with status: Completed.
✔ Restore identisch
Warum der Pod im Restore? Der node-agent spielt Volume-Daten über einen Init-Container im wiederhergestellten Pod zurück. Ein PVC ohne Pod bekommt bei Dateisystem-Backups keine Daten.
| Was | Velero? | Warum |
|---|---|---|
ki-models (Modell-Cache) |
nein | 30+ GB, jederzeit neu ladbar |
CNPG litellm-db, owui-db |
ja, zusätzlich CNPG-Backup | kopia-Kopie einer laufenden DB ist nur crash-konsistent |
Qdrant qdrant |
ja | Vektoren neu zu berechnen kostet Stunden GPU |
cert-manager |
ja | enthält den privaten Schlüssel der Lab-CA (Szenario 6) |
Fortschritt speichern? Kostenlos registrieren
Drill 5: etcd-Snapshots mit RKE2
Seit Tag 8 zieht RKE2 alle 6 Stunden einen lokalen Snapshot
(etcd-snapshot-schedule-cron, 12 behalten). Lokal heißt:
Stirbt die VM, ist der Snapshot mit weg. Darum zusätzlich nach S3 – über
dieselbe Ansible-Rolle:
cd ~/ki-lab/code/infra-rke2
cat >> group_vars/all.yml <<'EOF'
# Tag 15: etcd-Snapshots zusätzlich nach S3 (Garage auf s3-lab)
rke2_etcd_s3: true
rke2_etcd_s3_endpoint: s3.lab.internal:3900
rke2_etcd_s3_access_key: "{{ lookup('ansible.builtin.env', 'S3_KEY_ID') }}"
rke2_etcd_s3_secret_key: "{{ lookup('ansible.builtin.env', 'S3_SECRET') }}"
EOF
cat >> roles/rke2_server/templates/config.yaml.j2 <<'EOF'
{% if rke2_etcd_s3 | default(false) %}
etcd-s3: true
etcd-s3-endpoint: {{ rke2_etcd_s3_endpoint }}
etcd-s3-bucket: ki-lab-etcd
etcd-s3-region: garage
etcd-s3-insecure: true
etcd-s3-access-key: {{ rke2_etcd_s3_access_key }}
etcd-s3-secret-key: {{ rke2_etcd_s3_secret_key }}
{% endif %}
EOF
export S3_KEY_ID=$(awk -F= '/key_id/ {print $2}' ~/ki-lab/s3-backup.cred)
export S3_SECRET=$(awk -F= '/secret/ {print $2}' ~/ki-lab/s3-backup.cred)
source ~/ki-lab/rke2-token.env
ansible-playbook site.yml --limit rke2_serversDer Handler startet rke2-server neu – Server für Server,
wie beim Join. etcd-s3-insecure heißt nur „HTTP statt
HTTPS“ zum Garage im Lab-Netz.
ssh [email protected] 'sudo rke2 etcd-snapshot save --name drill'
ssh [email protected] 'sudo rke2 etcd-snapshot list' | grep drill
kubectl get etcdsnapshotfiles -o custom-columns=\
SNAPSHOT:.spec.snapshotName,NODE:.spec.nodeName,S3:.spec.s3.bucketErwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
drill-rke2-cp-1-1792177811 file:///var/lib/rancher/rke2/server/db/snapshots/...
drill-rke2-cp-1-1792177811 s3://ki-lab-etcd/drill-rke2-cp-1-1792177811 ...
SNAPSHOT NODE S3
drill-rke2-cp-1-1792177811 rke2-cp-1 <none>
drill-rke2-cp-1-1792177811 s3 ki-lab-etcd
Der Restore setzt den ganzen Cluster auf den Snapshot-Zeitpunkt zurück. Das Runbook (Szenario 7, Behebung B, nutzt dieselben Schritte ohne Restore-Pfad):
S=/var/lib/rancher/rke2/server/db/snapshots/drill-rke2-cp-1-1792177811
for h in 11 12 13; do ssh [email protected].$h 'sudo systemctl stop rke2-server'; done
ssh [email protected] "sudo rke2 server --cluster-reset \
--cluster-reset-restore-path=$S"
ssh [email protected] 'sudo systemctl start rke2-server'
for h in 12 13; do
ssh [email protected].$h 'sudo rm -rf /var/lib/rancher/rke2/server/db \
&& sudo systemctl start rke2-server'
done| Frage | etcd-Snapshot | Velero |
|---|---|---|
| Was steckt drin? | alle API-Objekte des Clusters | gewählte Namespaces + Volume-Daten |
| Volume-Inhalte | nein | ja (kopia) |
| Restore-Granularität | ganzer Cluster | Namespace, Label, Ressource |
| Typischer Fall | Quorum weg, kaputtes Upgrade | gelöschter Namespace, defekte DB |
Fortschritt speichern? Kostenlos registrieren
Drill 6: Upgrade-Reihenfolge RKE2 → GPU → vLLM
| Schritt | Warum in dieser Reihenfolge | Prüfung danach |
|---|---|---|
| 0 Snapshot + Backup | Rückweg für alles Folgende | velero backup get, etcd-snapshot list |
| 1 RKE2 (Plans, Tag 8) | regeneriert containerd-Config, Operator-Matrix hängt an der K8s-Version | runtimeclass nvidia, gpu-smoke.yaml |
| 2 Kernel + Treiber, dann Operator | Modul muss zum Kernel passen; der Validator prüft den Treiber | nvidia-smi, Allocatable = 4 |
| 3 vLLM-Image | neue Images brauchen eine neuere CUDA-Version und damit neue Treiber | Rollout, /v1/models, Dashboard |
ssh [email protected] 'sudo rke2 etcd-snapshot save --name pre-upgrade'
velero backup create pre-upgrade --from-schedule velero-ki-taeglich --wait
# 1. RKE2 – Zielversion vorher auf docs.rke2.io prüfen, keine Minor überspringen
NEU=v1.36.6+rke2r1
for p in server-plan agent-plan; do
kubectl -n system-upgrade patch plan $p --type merge \
-p "{\"spec\":{\"version\":\"$NEU\"}}"
done
kubectl -n system-upgrade get plans -w # bis beide COMPLETE True
kubectl apply -f ~/ki-lab/code/gpu/gpu-smoke.yaml
# 2. GPU-Node: Wartungsfenster! Ohne GPU springt LiteLLM auf die EU-API.
kubectl drain rke2-gpu-1 --ignore-daemonsets --delete-emptydir-data
cd ~/ki-lab/code/infra-rke2
ansible gpu_nodes -b -m ansible.builtin.apt -a 'upgrade=dist update_cache=true'
ansible gpu_nodes -b -m ansible.builtin.reboot
ansible-playbook gpu.yml
ssh [email protected] nvidia-smi --query-gpu=driver_version --format=csv,noheader
kubectl uncordon rke2-gpu-1
# danach: helm upgrade gpu-operator ... --version <neu> (Werte wie Tag 10)
# 3. vLLM – erst vllm-embed, dann vllm-code, zuletzt vllm-chat
VLLM_NEU=v0.31.1 # Tag auf docs.vllm.ai prüfen
kubectl -n ki-models set image deploy/vllm-embed vllm=vllm/vllm-openai:$VLLM_NEUErwartet (nicht live getestet, gekürzt):
plan.upgrade.cattle.io/server-plan patched
plan.upgrade.cattle.io/agent-plan patched
node/rke2-gpu-1 drained
...
580.105.08
node/rke2-gpu-1 uncordoned
Achtung:
unattended-upgradesinstalliert auf Ubuntu Kernel-Updates selbst – auf dem GPU-Node ist das genau Szenario 1. Dort Kernel-Pakete perapt-mark holdfesthalten und nur in Schritt 2 bewusst freigeben.
Fortschritt speichern? Kostenlos registrieren
Wettkampf-Regeln
Vor dem ersten Szenario: Sicherheitsnetz ziehen und die Umgebung
setzen. Jedes Szenario endet, wenn wettkampf-check.sh
(Kontrollpunkt) nur ✔ zeigt.
mkdir -p ~/ki-lab/tag15 && cd ~/ki-lab/tag15
export KUBECONFIG=~/ki-lab/rke2.yaml
export LITELLM_MASTER_KEY=sk-lab-master-1234 API=https://llm.lab.internal # Lab
H=(-H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json')
ssh [email protected] 'sudo rke2 etcd-snapshot save --name vor-wettkampf'
velero backup create vor-wettkampf --from-schedule velero-ki-taeglich --wait
~/ki-lab/code/ops/wettkampf-check.shErwartet: zehn Zeilen mit ✔. Die Funktion promq aus Tag
10 muss in der Shell definiert sein.
Tipp: Lass einen Mitspieler die Störung auslösen, ohne dir das Szenario zu nennen. Dann trainierst du den Diagnose-Pfad statt die Lösung.
Szenario 1: GPU weg nach Kernel-Update
Szenario: Nachts hat
unattended-upgrades auf rke2-gpu-1 einen neuen
Kernel installiert und neu gestartet. Für diesen Kernel gibt es kein
passendes NVIDIA-Modul. Im Lab simulierst du das, indem du das Laden des
Moduls verbietest.
Auslöser:
ssh [email protected] 'echo "install nvidia /bin/false" \
| sudo tee /etc/modprobe.d/zz-wettkampf.conf && sudo update-initramfs -u \
&& sudo reboot'Zeitlimit: 20 min
Symptome: rke2-gpu-1 ist kurz
NotReady, danach wieder Ready – aber alle
vLLM-Pods bleiben Pending, LiteLLM springt für
chat-large auf die EU-API, embed und
code liefern Fehler. Alarm KIGPUFehlt.
vllm-chat-7f9c8d6b4-p3q8w 0/1 Pending 0 4m
0/6 nodes are available: 1 Insufficient nvidia.com/gpu, ...
Diagnose-Pfad:
kubectl get node rke2-gpu-1 \
-o jsonpath='{.status.allocatable.nvidia\.com/gpu}{"\n"}'
kubectl -n gpu-operator get pods | grep -v -E 'Running|Completed'
ssh [email protected] 'uname -r; nvidia-smi -L; sudo modprobe nvidia'
ssh [email protected] 'dpkg -l "linux-modules-nvidia-*" | awk "/^ii/ {print \$2}"'Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
0
nvidia-operator-validator-f6g9h 0/1 Init:0/4 0 5m
6.8.0-90-generic
NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver.
modprobe: ERROR: Error running install command '/bin/false' for module nvidia
linux-modules-nvidia-580-server-6.8.0-88-generic
Im echten Fall meldet modprobe stattdessen
FATAL: Module nvidia not found in directory /lib/modules/6.8.0-90-generic,
und die Modulpakete enden auf einer älteren
Kernel-Version als uname -r.
Lösung (Lab):
ssh [email protected] 'sudo rm /etc/modprobe.d/zz-wettkampf.conf \
&& sudo update-initramfs -u && sudo reboot'Im echten Fall: passendes Modulpaket nachinstallieren
(sudo apt install linux-modules-nvidia-580-server-$(uname -r))
bzw. die Rolle nvidia_host erneut laufen lassen, oder per
GRUB den alten Kernel booten. Danach:
ssh [email protected] nvidia-smi -L
kubectl -n gpu-operator delete pod -l app=nvidia-device-plugin-daemonset
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=15mDer Neustart des Device Plugins meldet die vier Slots sofort neu an, statt auf den Validator-Zyklus zu warten.
Lessons: Kernel auf GPU-Nodes festhalten
(apt-mark hold linux-image-generic linux-headers-generic),
Kernel und Treiber nur gemeinsam upgraden (Drill 6), Alarm auf fehlende
GPU-Kapazität statt auf Pod-Status. Ein Ready-Node ist noch
lange kein funktionierender GPU-Node.
Szenario 2: vLLM startet nicht – max-model-len zu groß
Szenario: Ein Kollege will „den vollen Kontext“ und
setzt --max-model-len=40960. Bei einem Budget von 0.50 (Tag
14) passt eine einzige Sequenz dieser Länge nicht mehr in den
KV-Cache.
Auslöser:
kubectl -n ki-models get deploy vllm-chat -o json \
| jq '.spec.template.spec.containers[0].args |= map(
if startswith("--max-model-len") then "--max-model-len=40960" else . end)' \
| kubectl replace -f -Zeitlimit: 10 min
Symptome: Wegen maxSurge: 0 ist der
alte Pod sofort weg, der neue landet in CrashLoopBackOff.
chat-large antwortet nur noch über den Fallback,
chat-small gar nicht. Alarme KIvLLMWeg,
KIFallbackExtern.
Diagnose-Pfad:
kubectl -n ki-models get pods -l app=vllm-chat
kubectl -n ki-models get pod -l app=vllm-chat -o jsonpath='{.items[0].status
.containerStatuses[0].lastState.terminated.reason}{"\n"}'
kubectl -n ki-models logs deploy/vllm-chat --previous | grep -A4 ValueErrorErwartet (gekürzt, nicht live getestet, Zahlen hängen vom GPU-Budget ab):
vllm-chat-5d9b7c8f4-x2m7k 0/1 CrashLoopBackOff 3 4m
Error
ValueError: To serve at least one request with the models's max seq len (40960),
(5.62 GiB KV cache is needed, which is larger than the available KV cache memory
(0.81 GiB). Based on the available memory, the estimated maximum model length is
5898. Try increasing `gpu_memory_utilization` or decreasing `max_model_len` when
initializing the engine.
| Meldung | Ursache | Hebel |
|---|---|---|
max seq len ... KV cache is needed |
--max-model-len zu groß |
senken, --kv-cache-dtype=fp8 |
Free memory on device ... less than desired |
Summe der Budgets > 1,0 | Budgets neu verteilen (Tag 14) |
torch.OutOfMemoryError: CUDA out of memory |
Laufzeit, Nachbar auf geteilter GPU | --gpu-memory-utilization senken |
OOMKilled (Exit 137) |
Host-RAM über limits.memory |
Limit erhöhen |
Lösung:
kubectl -n ki-models rollout undo deploy/vllm-chat
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=15m
python3 ~/ki-lab/code/vllm/kv-sizing.py Qwen/Qwen3-8B-FP8 # erst rechnenLessons: kv-sizing.py (Tag 11) vor
jeder Änderung an Kontext oder Budget. Mit einer GPU und
maxSurge: 0 ist jede falsche Flag-Änderung ein Ausfall –
Änderungen nur per Git und Review, nicht per kubectl edit.
lastState.terminated.reason unterscheidet sofort zwischen
VRAM-Problem (Error) und Host-RAM
(OOMKilled).
Szenario 3: Budget leer – der Fallback hat bezahlt
Szenario: Die GPU fällt aus, LiteLLM schickt
chat-large an die Mistral API. Echte Kosten laufen auf, das
Team-Budget ist schnell leer, und plötzlich bekommt das Team Fehler
statt Antworten.
Auslöser:
kubectl -n ki-models annotate scaledobject vllm-chat \
autoscaling.keda.sh/paused-replicas=0 --overwrite
TP=$(curl -s $API/team/list "${H[@]}" \
| jq -r '.[] | select(.team_alias=="team-platform") | .team_id')
curl -s $API/team/update "${H[@]}" \
-d "{\"team_id\": \"$TP\", \"max_budget\": 0.0001}" >/dev/null
K=$(curl -s $API/key/generate "${H[@]}" \
-d "{\"team_id\": \"$TP\", \"key_alias\": \"wettkampf\"}" | jq -r .key)
for i in $(seq 1 8); do
curl -s -o /dev/null -w '%{http_code} ' $API/v1/chat/completions \
-H "Authorization: Bearer $K" -H 'Content-Type: application/json' \
-d '{"model": "chat-large", "messages": [{"role": "user",
"content": "Erzähle eine lange Geschichte über Kubernetes."}]}'
sleep 3
done; echoZeitlimit: 10 min
Symptome: Erst 200, dann
422. Alarme KIDeploymentAusfall,
KIFallbackExtern, KITeamBudget.
200 200 200 422 422 422 422 422
Diagnose-Pfad:
curl -s $API/v1/chat/completions -H "Authorization: Bearer $K" \
-H 'Content-Type: application/json' \
-d '{"model": "chat-large", "messages": [{"role": "user", "content": "x"}]}' \
| jq -c '.error | {type, code, message: .message[0:60]}'
curl -s "$API/team/info?team_id=$TP" "${H[@]}" \
| jq -c '.team_info | {team_alias, spend, max_budget}'
promq 'sum by (fallback_model)
(increase(litellm_deployment_successful_fallbacks_total[15m]))'
promq 'sum by (model) (increase(litellm_spend_metric_total[15m]))'Erwartet (Fehlertext und Status-Code aus dem Quellcode von v1.104.2, Werte nicht live getestet):
{"type":"budget_exceeded","code":"422","message":"Budget has been exceeded! Team=
3f0c... Current cost: 0.00041, Max budget: 0.0001"}
{"team_alias":"team-platform","spend":0.00041,"max_budget":0.0001}
- 3
- 0.00041
Die Ausgabe ist hier umbrochen; promq zeigt
-, weil diese Metriken kein pod-Label tragen.
Zwei Ursachen, eine Wirkung: Das lokale Modell fehlt (Fallback-Zähler
> 0), und der Fallback kostet echtes Geld (Spend nur auf
mistral-small-latest). Ältere LiteLLM-Versionen melden
Budgetüberschreitungen mit 429 statt 422.
Lösung:
kubectl -n ki-models annotate scaledobject vllm-chat \
autoscaling.keda.sh/paused-replicas-
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=15m
curl -s $API/team/update "${H[@]}" \
-d "{\"team_id\": \"$TP\", \"max_budget\": 20}" >/dev/null
curl -s "$API/team/info?team_id=$TP" "${H[@]}" | jq -c '.team_info.max_budget'
curl -s $API/key/delete "${H[@]}" -d "{\"keys\": [\"$K\"]}" | jq -c .Lessons: Ein Fallback nach extern ist Datenabfluss
und Kostenstelle – Alarm darauf,
disable_fallbacks für interne Teams (Tag 12, Challenge).
Budgets sind die letzte Sicherung, nicht das Monitoring. Der Wert von
budget_duration setzt den Spend erst am Periodenende
zurück; im Notfall hebt nur /team/update die Sperre
auf.
Szenario 4: Postgres-Failover (CloudNativePG)
Szenario: Der Node mit dem Primary von
litellm-db stirbt. CNPG muss die Replica befördern, LiteLLM
muss sich neu verbinden.
Auslöser:
P=$(kubectl -n ki-gateway get cluster litellm-db \
-o jsonpath='{.status.currentPrimary}'); echo "Primary: $P"
kubectl -n ki-gateway delete pod "$P" --grace-period=0 --forceZeitlimit: 10 min
Symptome: Für einige Sekunden scheitern
/key/generate und /team/* mit 500.
Chat-Requests mit bekannten Keys laufen meist weiter – LiteLLM hält Keys
im Cache. Spend-Updates landen im Log als Fehler.
Diagnose-Pfad:
kubectl -n ki-gateway get cluster litellm-db
kubectl -n ki-gateway get pods -l cnpg.io/cluster=litellm-db -L cnpg.io/instanceRole
curl -s $API/health/readiness | jq -c '{status, db}'
kubectl -n ki-gateway logs deploy/litellm --since=5m \
| grep -iE 'prisma|database|connect' | tail -3Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
NAME AGE INSTANCES READY STATUS PRIMARY
litellm-db 9d 2 1 Failing over litellm-db-2
litellm-db-1 0/1 Init:0/1 0 12s
litellm-db-2 1/1 Running 0 9d primary
{"status":"healthy","db":"connected"}
Lösung: Meist keine – CNPG befördert
litellm-db-2, der Service litellm-db-rw zeigt
um, litellm-db-1 kommt als Replica zurück
(pg_rewind). Bleibt LiteLLM bei
"db": "Not connected":
kubectl -n ki-gateway rollout restart deploy/litellm
kubectl -n ki-gateway wait cluster/litellm-db --for=condition=Ready --timeout=300s
curl -s $API/key/generate "${H[@]}" -d '{"key_alias": "failover-test",
"duration": "5m"}' | jq -r '.key_alias'Lessons: Clients nutzen immer -rw, nie
einen Pod-Namen. Mit zwei Instanzen gibt es während des Neuaufbaus keine
Redundanz – produktiv drei. Geplante Wechsel per Switchover
(kubectl cnpg promote litellm-db litellm-db-1 -n ki-gateway,
Plugin per kubectl krew install cnpg) statt Pod löschen.
Für Point-in-Time-Recovery braucht CNPG eigene Backups (Barman Cloud
Plugin nach S3) – Velero allein reicht für Datenbanken nicht.
Szenario 5: Longhorn-Volume degraded
Szenario: rke2-wk-2 fällt hart aus
(Netzteil). Darauf liegen Replicas von Prometheus, Postgres und dem
Open-WebUI-Volume, eventuell sogar die angehängten Volumes selbst.
Auslöser:
ssh [email protected] 'qm stop 222' # rke2-wk-2 hart ausZeitlimit: 20 min
Symptome: Nach ca. 40 s NotReady, nach
5 min hängen Pods dieses Nodes in Terminating. Ersatz-Pods
mit RWO-Volume starten nicht, weil Longhorn das Volume noch am toten
Node sieht. Alarm KILonghornDegraded.
Diagnose-Pfad:
kubectl get nodes
kubectl get pods -A -o wide --field-selector spec.nodeName=rke2-wk-2
kubectl -n longhorn-system get volumes.longhorn.io -o custom-columns=\
PVC:.status.kubernetesStatus.pvcName,STATE:.status.state,\
ROBUST:.status.robustness,NODE:.status.currentNodeID
kubectl get events -A --field-selector reason=FailedAttachVolume | tail -3Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
rke2-wk-2 NotReady <none> 9d v1.36.5+rke2r1
ki-gateway litellm-db-2 1/1 Terminating ... rke2-wk-2
PVC STATE ROBUST NODE
litellm-db-1 attached degraded rke2-wk-1
litellm-db-2 attached unknown rke2-wk-2
open-webui attached degraded rke2-wk-1
... Multi-Attach error for volume "pvc-..." Volume is already exclusively
attached to one node and can't be attached to another
Lösung A (Node kommt zurück):
ssh [email protected] 'qm start 222'
kubectl wait node/rke2-wk-2 --for=condition=Ready --timeout=600s
kubectl -n longhorn-system get volumes.longhorn.io \
-o jsonpath='{.items[*].status.robustness}{"\n"}'Longhorn baut die Replicas nach, bis überall healthy
steht.
Lösung B (Node bleibt weg): Longhorn darf Pods auf
toten Nodes selbst löschen und die Volumes woanders anhängen. Neue
Replicas entstehen nach replica-replenishment-wait-interval
(Default 600 s).
kubectl -n longhorn-system patch settings.longhorn.io \
node-down-pod-deletion-policy --type merge \
-p '{"value": "delete-both-statefulset-and-deployment-pod"}'
kubectl get pods -A --field-selector spec.nodeName=rke2-wk-2 --no-headers \
| awk '$4=="Terminating" {print $1, $2}' \
| while read -r ns p; do kubectl -n "$ns" delete pod "$p" --force \
--grace-period=0; doneLessons: Mit zwei Replicas braucht Longhorn einen
dritten Storage-Node zum Neuaufbau. Prüfe, ob Longhorn auf
rke2-gpu-1 überhaupt laufen darf: Der GPU-Taint aus Tag 10
sperrt den Node für neue DaemonSet-Pods ohne Toleration (Longhorn-Wert
defaultSettings.taintToleration: nvidia.com/gpu:NoSchedule).
Die Node-Down-Policy gehört von Anfang an in die Longhorn-Values, nicht
in die Nacht des Ausfalls.
Szenario 6: Zertifikat ungültig – die Lab-CA ist weg
Szenario: Jemand räumt im Namespace
cert-manager auf und löscht lab-ca-keypair.
cert-manager erzeugt sofort eine neue Root-CA. Ab der
nächsten Erneuerung vertraut kein Client mehr den Zertifikaten.
Abgelaufene Zertifikate (cert-manager tot, Webhook kaputt) zeigen
dieselben Symptome mit certificate has expired.
Auslöser:
kubectl -n cert-manager delete secret lab-ca-keypair
sleep 30
kubectl -n ki-gateway delete secret litellm-tls # simuliert die ErneuerungZeitlimit: 15 min
Symptome: https://llm.lab.internal
liefert TLS-Fehler, Continue meldet „fetch failed“, Python-Clients
CERTIFICATE_VERIFY_FAILED. Open WebUI läuft weiter – intern
spricht es HTTP mit litellm.ki-gateway:4000.
curl: (60) SSL certificate problem: unable to get local issuer certificate
Diagnose-Pfad:
echo | openssl s_client -connect llm.lab.internal:443 \
-servername llm.lab.internal 2>/dev/null \
| openssl x509 -noout -issuer -enddate
kubectl get certificate -A
kubectl -n cert-manager get secret lab-ca-keypair -o jsonpath='{.data.ca\.crt}' \
| base64 -d | openssl x509 -noout -fingerprint -sha256
openssl x509 -in ~/ki-lab/lab-ca.crt -noout -fingerprint -sha256Erwartet (gekürzt, nicht live getestet):
issuer=CN=KI-Lab Root CA
notAfter=Jan 14 19:31:02 2027 GMT
NAMESPACE NAME READY SECRET AGE
cert-manager lab-ca True lab-ca-keypair 9d
ki-gateway litellm-tls True litellm-tls 40s
sha256 Fingerprint=7A:91:...
sha256 Fingerprint=C4:0E:...
Gleicher Name, anderer Fingerabdruck: neue CA. Alles steht auf
READY True – cert-manager ist zufrieden, nur die Clients
nicht. Zeigt -issuer stattdessen
CN=TRAEFIK DEFAULT CERT, fehlt das TLS-Secret ganz.
Lösung: Alte CA aus dem Velero-Backup zurück, dann alle Lab-CA-Zertifikate neu ausstellen lassen.
velero restore create ca-zurueck --from-backup vor-wettkampf \
--include-namespaces cert-manager --include-resources secrets \
--existing-resource-policy update --wait
kubectl get certificate -A -o json | jq -r '.items[]
| select(.spec.issuerRef.name == "lab-ca")
| "\(.metadata.namespace) \(.spec.secretName)"' \
| while read -r ns s; do kubectl -n "$ns" delete secret "$s"; done
sleep 30
curl -sf https://llm.lab.internal/health/readiness | jq -r .statusErwartet (nicht live getestet):
Restore completed with status: Completed.
healthy
Lessons: Der CA-Schlüssel ist das wertvollste Secret
im Cluster – Backup, eingeschränkte RBAC auf cert-manager,
produktiv gar nicht im Cluster (Vault/OpenBao-Issuer).
READY True heißt nur „ausgestellt“, nicht „vertraut“: Prüfe
von außen mit openssl s_client. Für echtes Ablaufen gibt es
KIZertifikatLaeuftAb (7 Tage Vorlauf).
Szenario 7: VIP weg – etcd ohne Quorum
Szenario: Wartung auf dem Proxmox-Host, zwei
Server-VMs werden gleichzeitig gestoppt. Nur rke2-cp-1
läuft noch.
Auslöser:
ssh [email protected] 'qm stop 212 && qm stop 213'Zeitlimit: 10 min (A) / 30 min (B)
Symptome: kubectl hängt oder scheitert,
rke2.lab.internal antwortet nicht. Überraschung: Chat,
LiteLLM und vLLM laufen weiter – die Datenebene braucht die API nicht,
nur Änderungen und Neustarts brauchen sie.
Unable to connect to the server: dial tcp 10.10.20.10:6443: i/o timeout
Diagnose-Pfad:
ping -c2 -W1 10.10.20.10
curl -s -o /dev/null -w '%{http_code}\n' https://llm.lab.internal/health/readiness
ssh [email protected] 'ip -br addr show eth0'
ssh [email protected] 'C="sudo CRI_CONFIG_FILE=/var/lib/rancher/rke2/agent/etc/\
crictl.yaml /var/lib/rancher/rke2/bin/crictl"; $C logs --tail 3 \
$($C ps --name etcd -q) 2>&1 | cut -c1-120'Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
2 packets transmitted, 0 received, 100% packet loss
200
eth0 UP 10.10.20.11/24
{"level":"info",...,"msg":"... is starting a new election at term 9"}
{"level":"warn",...,"msg":"prober detected unhealthy status","remote-peer-id":...}
Die Kette: etcd hat 1 von 3 Stimmen → kein Leader → die API kann
nicht schreiben → kube-vip kann seinen Lease plndr-cp-lock
nicht erneuern → kube-vip gibt die VIP ab. Die VIP fehlt also als
Folge, nicht als Ursache.
Lösung A (VMs kommen zurück):
ssh [email protected] 'qm start 212 && qm start 213'
until kubectl get --raw=/livez >/dev/null 2>&1; do sleep 5; done; echo "API ok"
kubectl get nodes -l node-role.kubernetes.io/etcd=trueLösung B (cp-2 und cp-3 endgültig verloren): etcd
auf rke2-cp-1 als Ein-Knoten-Cluster neu starten, dann die
anderen frisch joinen.
ssh [email protected] 'sudo systemctl stop rke2-server \
&& sudo rke2 server --cluster-reset 2>&1 | tail -2'
ssh [email protected] 'sudo systemctl start rke2-server'Erwartet (gekürzt, nicht live getestet):
Managed etcd cluster membership has been reset, restart without --cluster-reset
flag now. Backup and delete ${datadir}/server/db on each peer etcd server and
rejoin the nodes.
Danach rke2-cp-2 und -3 neu bauen (Tag 7,
Challenge: tofu plan -replace=...) und mit
ansible-playbook site.yml --limit rke2-cp-2 bzw.
rke2-cp-3 einzeln joinen. Kommen die alten VMs doch zurück:
vor dem Start /var/lib/rancher/rke2/server/db löschen,
sonst versuchen sie, dem alten Cluster beizutreten.
Lessons: Drei Server tolerieren einen Ausfall, nicht
zwei – Wartung immer nur an einem Server. Proxmox-HA-Regeln
(Anti-Affinity) verteilen die Server auf verschiedene Hosts.
--cluster-reset ohne Restore-Pfad behält die Daten, mit
--cluster-reset-restore-path (Drill 5) springst du
zurück.
Szenario 8: HF-Token widerrufen – Modell lädt nicht
Szenario: Der Hugging-Face-Token wurde nach einem
Leak widerrufen. Bei nächster Gelegenheit startet vllm-chat
neu – und kommt nicht mehr hoch, obwohl die Gewichte im Cache
liegen.
Auslöser:
kubectl -n ki-models create secret generic hf-token \
--from-literal=token=hf_widerrufen00000000000000000000000 \
--dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-models rollout restart deploy/vllm-chatZeitlimit: 10 min
Symptome: Neuer Pod in
CrashLoopBackOff, chat-large läuft über den
Fallback. Ein ungültiger Token ist schlimmer als keiner: Der Hub lehnt
auch Downloads öffentlicher Modelle mit 401 ab.
Diagnose-Pfad:
kubectl -n ki-models logs deploy/vllm-chat --previous | grep -m2 -iE '401|token'
T=$(kubectl -n ki-models get secret hf-token -o jsonpath='{.data.token}' \
| base64 -d)
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $T" \
https://huggingface.co/api/whoami-v2; unset T
ssh [email protected] 'sudo du -sh /var/lib/ki-models/*vllm-chat-cache*'Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):
huggingface_hub.errors.HfHubHTTPError: 401 Client Error: Unauthorized for url:
https://huggingface.co/api/models/Qwen/Qwen3-8B-FP8/... Invalid credentials ...
401
9.6G /var/lib/ki-models/pvc-8b2f..._ki-models_vllm-chat-cache
Der Cache ist da, vLLM fragt beim Start trotzdem den Hub nach Metadaten – und bricht am 401 ab.
Lösung: Sofort aus dem Cache starten, dann den Token aufräumen.
kubectl -n ki-models set env deploy/vllm-chat HF_HUB_OFFLINE=1
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=10m
kubectl -n ki-models delete secret hf-token # Qwen ist nicht gated (optional)Für gated Modelle: neuen Read-Token anlegen und das Secret ersetzen (Tag 11, Drill 2) – oder aus OpenBao per ESO, dann rotiert er an einer Stelle.
Lessons: Produktiv lädt kein Pod beim Start aus dem
Internet: HF_HUB_OFFLINE=1 plus vorbefüllter Cache oder
interner Mirror. Tokens sind Abhängigkeiten mit Ablaufdatum –
inventarisieren, nur lesend, je Zweck einer. Gleiches gilt für den
Netzausfall nach draußen: Mit Offline-Modus ist er kein Ereignis.
Bewertung
| Szenario | Zeitlimit | geschafft |
|---|---|---|
| 1 GPU weg nach Kernel-Update | 20 min | [ ] |
| 2 max-model-len zu groß | 10 min | [ ] |
| 3 Budget leer durch Fallback | 10 min | [ ] |
| 4 Postgres-Failover | 10 min | [ ] |
| 5 Longhorn degraded (A / B) | 10 / 20 min | [ ] |
| 6 Lab-CA verloren | 15 min | [ ] |
| 7 VIP weg, kein Quorum (A / B) | 10 / 30 min | [ ] |
| 8 HF-Token widerrufen | 10 min | [ ] |
6 von 8 in der Zeit: bereit für die Rufbereitschaft. Für jedes
verpasste Limit eine Zeile ins Runbook: Welcher Befehl hätte dich
schneller zur Ursache geführt? Zum Schluss den Wettkampf-Key löschen und
vor-wettkampf behalten, bis alles grün ist.
Kontrollpunkt
Dasselbe Skript beendet jedes Szenario. Es liegt als
code/ops/wettkampf-check.sh im Begleitmaterial:
cat > ~/ki-lab/code/ops/wettkampf-check.sh <<'EOF'
#!/usr/bin/env bash
# Gesamtprüfung der KI-Plattform (Tag 15): alle Zeilen ✔ = Szenario gelöst
export KUBECONFIG=${KUBECONFIG:-$HOME/ki-lab/rke2.yaml}
API=${API:-https://llm.lab.internal}
export M=${LITELLM_MASTER_KEY:-sk-lab-master-1234} # Lab-Wert
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "6 Nodes Ready" '[ "$(kubectl get nodes --no-headers \
| awk "\$2==\"Ready\"" | wc -l)" -eq 6 ]'
check "API über VIP" 'curl -sk --max-time 5 https://10.10.20.10:6443/livez'
check "GPU-Slots auf rke2-gpu-1" '[ "$(kubectl get node rke2-gpu-1 \
-o jsonpath="{.status.allocatable.nvidia\.com/gpu}")" = 4 ]'
check "vllm-chat/-embed/-code Ready" 'for d in vllm-chat vllm-embed vllm-code; do
kubectl -n ki-models rollout status deploy/$d --timeout=5s || exit 1; done'
check "chat-large lokal (kein Fallback)" 'curl -s -D - -o /dev/null --max-time 60 \
$API/v1/chat/completions -H "Authorization: Bearer $M" \
-H "Content-Type: application/json" -d "{\"model\":\"chat-large\",
\"messages\":[{\"role\":\"user\",\"content\":\"OK\"}],\"max_tokens\":5}" \
| grep -qi "^x-litellm-model-group: chat-large\s*$"'
check "Team-Budgets nicht erschöpft" '[ "$(curl -s $API/team/list \
-H "Authorization: Bearer $M" | jq "[.[] | select(.max_budget != null
and .spend >= .max_budget)] | length")" -eq 0 ]'
check "CNPG litellm-db + owui-db" '
kubectl -n ki-gateway wait cluster/litellm-db --for=condition=Ready --timeout=5s &&
kubectl -n ki-chat wait cluster/owui-db --for=condition=Ready --timeout=5s'
check "Longhorn-Volumes healthy" '[ -z "$(kubectl -n longhorn-system get \
volumes.longhorn.io -o json | jq -r ".items[] | select(.status.state
== \"attached\") | .status.robustness" | grep -vx healthy)" ]'
check "TLS mit Lab-CA" 'curl -sf --max-time 5 $API/health/readiness'
check "Velero-Ziel verfügbar" '[ "$(kubectl -n velero get backupstoragelocation \
default -o jsonpath="{.status.phase}")" = Available ]'
EOF
chmod +x ~/ki-lab/code/ops/wettkampf-check.sh
~/ki-lab/code/ops/wettkampf-check.shErwartet:
✔ 6 Nodes Ready
✔ API über VIP
✔ GPU-Slots auf rke2-gpu-1
✔ vllm-chat/-embed/-code Ready
✔ chat-large lokal (kein Fallback)
✔ Team-Budgets nicht erschöpft
✔ CNPG litellm-db + owui-db
✔ Longhorn-Volumes healthy
✔ TLS mit Lab-CA
✔ Velero-Ziel verfügbar
Dazu einmalig:
kubectl -n monitoring get prometheusrule ki-alerts und
velero backup get zeigen die Regeln und mindestens ein
Completed-Backup.
Challenge
Beweise, dass der Alarm KIFallbackExtern wirklich im
Alertmanager ankommt – ohne die GPU anzufassen.
Hinweis: LiteLLM kennt den Request-Parameter
mock_testing_fallbacks: true; er lässt das erste Deployment
absichtlich scheitern.
Lösung
for i in 1 2 3; do
curl -s $API/v1/chat/completions "${H[@]}" -d '{"model": "chat-large",
"mock_testing_fallbacks": true,
"messages": [{"role": "user", "content": "Antworte nur mit OK"}]}' \
| jq -r .model
done
sleep 120
kubectl -n monitoring exec alertmanager-kube-prometheus-stack-alertmanager-0 \
-c alertmanager -- wget -qO- localhost:9093/api/v2/alerts \
| jq -r '.[] | select(.labels.alertname == "KIFallbackExtern")
| "\(.labels.alertname) \(.labels.fallback_model) \(.status.state)"'Erwartet (nicht live getestet):
mistral-small-latest
mistral-small-latest
mistral-small-latest
KIFallbackExtern chat-large-eu active
Drei Requests haben echte Prompts an die Mistral API geschickt – genau das, was der Alarm melden soll. Nach zehn Minuten ohne Fallback löst er sich von selbst auf.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- SLOs statt Bauchgefühl: TTFT p95, Fehlerquote und Verfügbarkeit pro
Alias (
chat-large,code) definieren und mit Burn-Rate-Alarmen überwachen; Alertmanager mit Bereitschaftsplan und Eskalation. - Backups nach 3-2-1: S3 mit Object Lock (unveränderbar), zweiter Standort, regelmäßige automatisierte Restore-Tests. Datenbanken über CNPG-Backups mit WAL-Archiv, Velero für den Rest.
- Upgrades als Pipeline: Staging-Cluster mit derselben GPU-Klasse,
Canary-GPU-Node, Freigabe nach Lasttest (
vllm bench serve) und Dashboard-Vergleich. - Runbooks pro Alarm verlinken (
runbook_urlin den Annotations) und nach jedem echten Vorfall ein Postmortem ohne Schuldzuweisung. - Game Days wie dieser Wettkampf zweimal im Jahr mit dem ganzen Team, Störungen ausgelöst von jemandem außerhalb der Bereitschaft.