Zum Inhalt springen
Trainingslager IT-Trainingslager

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-Plattform aus 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-snapshot sichert 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 per helm 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.json

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

Die 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 9093 und die Web-UI. Produktiv: alertmanager.config in 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.cred

Sicherheit: 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 get

Erwartet (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_servers

Der 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.bucket

Erwartet (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_NEU

Erwartet (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-upgrades installiert auf Ubuntu Kernel-Updates selbst – auf dem GPU-Node ist das genau Szenario 1. Dort Kernel-Pakete per apt-mark hold festhalten 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.sh

Erwartet: 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=15m

Der 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 ValueError

Erwartet (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 rechnen

Lessons: 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; echo

Zeitlimit: 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 --force

Zeitlimit: 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 -3

Erwartet (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 aus

Zeitlimit: 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 -3

Erwartet (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; done

Lessons: 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 Erneuerung

Zeitlimit: 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 -sha256

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

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

Lö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-chat

Zeitlimit: 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.sh

Erwartet:

✔ 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_url in 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.