Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Nachweisen, dass du die KI-Plattform auf RKE2 allein ändern, absichern und wiederherstellen kannst · Dauer: 180 min Praxis + 30 min Fragen · Voraussetzung: Tag 15

Regeln

  • Cluster rke2-lab im Zustand nach Tag 15: alle Zeilen von wettkampf-check.sh zeigen ✔, Velero und etcd-S3 laufen.
  • Erlaubt: --help, Anhang A, offizielle Doku (docs.vllm.ai, docs.litellm.ai, docs.rke2.io, velero.io, qdrant.tech). Nicht erlaubt: Lösungen aus den Kapiteln abschreiben.
  • Jede Aufgabe zählt nur, wenn das Prüfskript sie mit ✔ bewertet. Du darfst es beliebig oft laufen lassen.
  • Aufgabe 9 löst ein Mitspieler aus, frühestens nach 60 min, ohne dir das Szenario zu nennen.
  • Bestanden: mindestens 70 von 100 Punkten und Aufgabe 8 (Backup) gelöst.
mkdir -p ~/ki-lab/pruefung && cd ~/ki-lab/pruefung
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-pruefung'

Teil 1: Praktische Prüfung

Aufgabe Thema Punkte
1 Cluster-Gesundheit 5
2 GPU geteilt, VRAM-Budget 10
3 vLLM umbauen 15
4 LiteLLM-Alias 10
5 Team und Key 15
6 RAG-Collection 10
7 Alarm und Dashboard 10
8 Backup und Snapshot (Pflicht) 15
9 Unbekannte Störung 10
Summe 100

Aufgabe 1: Cluster-Gesundheit (5 Punkte)

Alle sechs Nodes sind Ready, drei davon etcd-Mitglieder, die API antwortet über die VIP.

kubectl get nodes --no-headers | grep -c ' Ready '
kubectl get nodes -l node-role.kubernetes.io/etcd=true --no-headers | wc -l
curl -sk https://10.10.20.10:6443/livez; echo

Erwartet:

6
3
ok

Aufgabe 2: GPU geteilt, VRAM-Budget (10 Punkte)

rke2-gpu-1 meldet vier Slots per Time-Slicing, und die Summe der --gpu-memory-utilization aller drei vLLM-Deployments liegt unter 1,0.

kubectl get node rke2-gpu-1 -o jsonpath='{.status.allocatable.nvidia\.com/gpu}{"\n"}'
for d in vllm-chat vllm-embed vllm-code; do
  kubectl -n ki-models get deploy $d -o json \
    | jq -r '.spec.template.spec.containers[0].args[]' \
    | grep -oE 'utilization=[0-9.]+' | cut -d= -f2
done | paste -sd+ - | bc

Erwartet:

4
.95

Aufgabe 3: vLLM umbauen (15 Punkte)

Stelle vllm-chat auf FP8-KV-Cache und 8192 Tokens Kontext um. Der Modellname qwen3-8b und das GPU-Budget bleiben. Die Änderung steht auch in ~/ki-lab/code/vllm/vllm-chat.yaml, und chat-large antwortet danach lokal, nicht über den Fallback.

kubectl -n ki-models logs deploy/vllm-chat | grep -E 'KV cache size|concurrency'
curl -s -D - -o /dev/null $API/v1/chat/completions "${H[@]}" \
  -d '{"model": "chat-large", "messages": [{"role": "user", "content": "OK"}]}' \
  | grep -i '^x-litellm-model-group'

Erwartet (Zahlen hängen vom Budget ab):

INFO ... GPU KV cache size: 11,... tokens
INFO ... Maximum concurrency for 8,192 tokens per request: 1.4x
x-litellm-model-group: chat-large

Aufgabe 4: LiteLLM-Alias (10 Punkte)

Neuer Alias chat-kurz: zeigt auf vllm-chat, liefert höchstens 128 Tokens, hat keinen Fallback. Beide LiteLLM-Replikas kennen ihn.

curl -s $API/v1/models "${H[@]}" | jq -r '.data[].id' | sort
curl -s $API/v1/chat/completions "${H[@]}" -d '{"model": "chat-kurz",
  "messages": [{"role": "user", "content": "Erzähle lange."}]}' \
  | jq '.usage.completion_tokens'

Erwartet:

chat-kurz
chat-large
chat-large-eu
chat-small
code
embed
128

Aufgabe 5: Team und Key (15 Punkte)

Team team-pruefung: Modelle chat-kurz und embed, Budget 2 pro 7 Tage, 20 Requests pro Minute. Dazu ein Key pruefer, der einen Tag gilt und nie nach extern ausweicht. Lege ihn in $PRUEF_KEY ab.

curl -s $API/team/list "${H[@]}" | jq -c '.[] | select(.team_alias ==
  "team-pruefung") | {models, max_budget, budget_duration, rpm_limit}'
curl -s "$API/key/info?key=$PRUEF_KEY" "${H[@]}" \
  | jq -c '.info | {key_alias, metadata, expires: (.expires != null)}'

Erwartet:

{"models":["chat-kurz","embed"],"max_budget":2.0,"budget_duration":"7d",
"rpm_limit":20}
{"key_alias":"pruefer","metadata":{"disable_fallbacks":true},"expires":true}

Aufgabe 6: RAG-Collection (10 Punkte)

Lege in Qdrant die Collection pruefung an (1024 Dimensionen, Cosinus) und speichere mindestens drei Sätze mit Embeddings, die du über LiteLLM (embed, Key $PRUEF_KEY) erzeugst.

kubectl -n ki-chat port-forward svc/qdrant 6333:6333 >/dev/null 2>&1 &
curl -s localhost:6333/collections/pruefung -H 'api-key: lab-qdrant-key-1234' \
  | jq -c '.result | {points_count, dim: .config.params.vectors.size,
    distance: .config.params.vectors.distance}'

Erwartet:

{"points_count":3,"dim":1024,"distance":"Cosine"}

Aufgabe 7: Alarm und Dashboard (10 Punkte)

Ergänze einen Alarm KIPruefungEmbedWeg, der feuert, wenn vllm-embed drei Minuten lang keine Metriken liefert. Das Dashboard ki-dashboard aus Tag 15 ist geladen.

kubectl -n monitoring exec prometheus-kube-prometheus-stack-prometheus-0 \
  -c prometheus -- wget -qO- localhost:9090/api/v1/rules | jq -r '.data
  .groups[].rules[] | select(.name == "KIPruefungEmbedWeg") | .query'
kubectl -n monitoring get configmap -l grafana_dashboard=1 -o name

Erwartet (Reihenfolge der Labels kann abweichen):

absent(up{job="vllm-embed",namespace="ki-models"} == 1)
configmap/ki-dashboard

Aufgabe 8: Backup und Snapshot (15 Punkte, Pflicht)

Velero-Backup pruefung mit den Namespaces ki-gateway und ki-chat inklusive Volume-Daten, dazu ein etcd-Snapshot pruefung, der auch in S3 liegt.

velero backup describe pruefung --details \
  | grep -E '^Phase|Namespaces:|Completed:' | head -4
kubectl get etcdsnapshotfiles -o json | jq -r '.items[]
  | select(.spec.snapshotName | startswith("pruefung"))
  | "\(.spec.snapshotName) \(if .spec.s3 then "s3" else "lokal" end)"'

Erwartet (gekürzt, Namen weichen ab):

Phase:  Completed
  Included:  ki-gateway, ki-chat
pruefung-rke2-cp-1-1792351200 lokal
pruefung-rke2-cp-1-1792351200 s3

Aufgabe 9: Unbekannte Störung (10 Punkte)

Ein Mitspieler löst eines der Szenarien aus Tag 15 aus. Du hast das dort genannte Zeitlimit. Gelöst ist die Aufgabe, wenn wettkampf-check.sh nur ✔ zeigt und du Ursache und Lösung in zwei Sätzen benennst.

~/ki-lab/code/ops/wettkampf-check.sh | grep -c '✘'

Erwartet:

0

Prüfskript

Das Skript bewertet alle neun Aufgaben und zählt die Punkte (code/pruefung/pruefung.sh):

cat > ~/ki-lab/pruefung/pruefung.sh <<'EOF'
#!/usr/bin/env bash
# Abschlussprüfung (Anhang B): prüft Aufgabe 1-9 und zählt Punkte
# Aufruf: PRUEF_KEY=sk-... ./pruefung.sh
export KUBECONFIG=${KUBECONFIG:-$HOME/ki-lab/rke2.yaml}
API=https://llm.lab.internal
M=sk-lab-master-1234                                       # Lab-Wert
P=0; PFLICHT=0
aufgabe() {  # Nummer, Punkte, Titel, Prüfung
  if eval "$4" >/dev/null 2>&1; then
    echo "✔ A$1 $3 (+$2)"; P=$((P + $2)); [ "$1" = 8 ] && PFLICHT=1
  else
    echo "✘ A$1 $3 (0/$2)"
  fi
}
k() { kubectl "$@"; }
prom() {
  k -n monitoring exec prometheus-kube-prometheus-stack-prometheus-0 \
    -c prometheus -- wget -qO- "http://localhost:9090/api/v1/$1"
}
lit() { curl -s "$API$1" -H "Authorization: Bearer $M" "${@:2}"; }
args() {
  k -n ki-models get deploy "$1" -o jsonpath='{.spec.template.spec.containers[0].args}'
}

k -n ki-chat port-forward svc/qdrant 16333:6333 >/dev/null 2>&1 &
PF=$!; trap 'kill $PF 2>/dev/null' EXIT; sleep 2

aufgabe 1 5 "Cluster gesund" '[ "$(k get nodes --no-headers | grep -c " Ready ")" \
  -eq 6 ] && [ "$(k get nodes -l node-role.kubernetes.io/etcd=true --no-headers \
  | wc -l)" -eq 3 ] && curl -sk --max-time 5 https://10.10.20.10:6443/livez'

aufgabe 2 10 "GPU geteilt, Budget < 1" '[ "$(k get node rke2-gpu-1 \
  -o jsonpath="{.status.allocatable.nvidia\.com/gpu}")" = 4 ] && \
  awk "BEGIN {exit !($(for d in vllm-chat vllm-embed vllm-code; do args $d \
  | grep -oE "utilization=[0-9.]+" | cut -d= -f2; done | paste -sd+ -) < 1)}"'

aufgabe 3 15 "vllm-chat fp8 + 8192" 'args vllm-chat | grep -q kv-cache-dtype=fp8 \
  && args vllm-chat | grep -q max-model-len=8192 \
  && k -n ki-models rollout status deploy/vllm-chat --timeout=5s \
  && grep -q kv-cache-dtype=fp8 ~/ki-lab/code/vllm/vllm-chat.yaml'

aufgabe 4 10 "Alias chat-kurz" 'lit /v1/models | jq -e ".data[] | select(.id ==
  \"chat-kurz\")" && [ "$(lit /v1/chat/completions -H "Content-Type: \
  application/json" -d "{\"model\":\"chat-kurz\",\"messages\":[{\"role\":
  \"user\",\"content\":\"Erzähle lange.\"}]}" | jq ".usage.completion_tokens")" \
  -le 128 ]'

aufgabe 5 15 "Team und Key" 'lit /team/list | jq -e ".[] | select(.team_alias ==
  \"team-pruefung\" and .max_budget == 2 and .rpm_limit == 20)" \
  && lit "/key/info?key=$PRUEF_KEY" | jq -e ".info | .key_alias == \"pruefer\"
  and .metadata.disable_fallbacks == true and .expires != null"'

aufgabe 6 10 "Qdrant-Collection pruefung" 'curl -s \
  localhost:16333/collections/pruefung -H "api-key: $(k -n ki-chat get secret \
  qdrant-auth -o jsonpath="{.data.api-key}" | base64 -d)" \
  | jq -e ".result.points_count >= 3 and .result.config.params.vectors.size == 1024"'

aufgabe 7 10 "Alarme + Dashboard" 'prom rules | jq -e "[.data.groups[].rules[]
  | select(.name == \"KIPruefungEmbedWeg\")] | length == 1" && k -n monitoring \
  get configmap -l grafana_dashboard=1 -o name | grep -q ki-dashboard'

aufgabe 8 15 "Backup + etcd-Snapshot (Pflicht)" '[ "$(k -n velero get \
  backup pruefung -o jsonpath="{.status.phase}")" = Completed ] \
  && k -n velero get backup pruefung -o jsonpath="{.spec.includedNamespaces}" \
  | grep -q ki-chat && k get etcdsnapshotfiles -o json | jq -e "[.items[]
  | select(.spec.snapshotName | startswith(\"pruefung\")) | select(.spec.s3)]
  | length > 0"'

aufgabe 9 10 "Störung behoben" '! ~/ki-lab/code/ops/wettkampf-check.sh \
  | grep -q "✘"'

echo "Punkte: $P / 100"
if [ "$P" -ge 70 ] && [ "$PFLICHT" = 1 ]; then echo "✔ bestanden"
else echo "✘ nicht bestanden (mind. 70 Punkte und Aufgabe 8)"; fi
EOF
chmod +x ~/ki-lab/pruefung/pruefung.sh
PRUEF_KEY=$PRUEF_KEY ~/ki-lab/pruefung/pruefung.sh

Erwartet (Beispiel mit einer verfehlten Aufgabe):

✔ A1 Cluster gesund (+5)
✔ A2 GPU geteilt, Budget < 1 (+10)
✔ A3 vllm-chat fp8 + 8192 (+15)
✔ A4 Alias chat-kurz (+10)
✔ A5 Team und Key (+15)
✘ A6 Qdrant-Collection pruefung (0/10)
✔ A7 Alarme + Dashboard (+10)
✔ A8 Backup + etcd-Snapshot (Pflicht) (+15)
✔ A9 Störung behoben (+10)
Punkte: 90 / 100
✔ bestanden

Zum Schluss aufräumen: Team team-pruefung und Key per /team/delete bzw. /key/delete, Collection pruefung per DELETE /collections/pruefung.

Teil 2: Wissensfragen

Je Frage ein bis zwei Sätze, ohne Hilfsmittel. 20 von 25 richtig: bestanden.

  1. Wie rechnest du den KV-Cache pro Token, und welcher Wert ergibt sich für Qwen3-8B in BF16?
  2. Worauf bezieht sich --gpu-memory-utilization, und welche Regel gilt für mehrere vLLM-Instanzen auf einer GPU?
  3. Warum startet vLLM mit zu großem --max-model-len gar nicht, statt einfach weniger parallel zu bedienen?
  4. Nenne drei Hebel für mehr parallele Sequenzen ohne neue Hardware.
  5. Warum ist vllm:num_requests_waiting ein besseres Skalierungssignal als die GPU-Auslastung?
  6. Eine Engine bekommt 3 Requests/s, jede Antwort dauert 6 s. Was folgt aus Little’s Law für --max-num-seqs?
  7. Warum hat vllm-chat maxSurge: 0, und welche Nebenwirkung hat das?
  8. Warum braucht Continue für Autocomplete ein eigenes Prompt-Template mit FIM-Tokens?
  9. Warum startet vLLM mit einem widerrufenen HF-Token nicht, obwohl die Gewichte im Cache liegen – und was hilft sofort?
  10. Warum referenziert die GPU-VM das Resource Mapping gpu0 statt der PCI-Adresse?
  11. Warum bekommt nur rke2-gpu-1 den Maschinentyp q35 und OVMF?
  12. Warum joinen die RKE2-Server in Ansible mit serial: 1?
  13. Warum verschwindet die API-VIP, wenn zwei von drei Servern ausfallen?
  14. Was macht rke2 server --cluster-reset ohne und mit --cluster-reset-restore-path?
  15. Welche RKE2-Besonderheit muss der GPU Operator kennen, und wie teilst du sie ihm mit?
  16. Was teilt Time-Slicing nicht zwischen den Pods einer GPU?
  17. Warum braucht in RKE2 jeder GPU-Pod die Toleration nvidia.com/gpu selbst?
  18. Warum ist ein Ready-Node noch kein funktionierender GPU-Node, und welche Metrik zeigt das?
  19. Warum brauchen zwei LiteLLM-Replikas Redis?
  20. Warum setzt du für lokale Modelle input_cost_per_token und output_cost_per_token?
  21. Wie verhinderst du, dass ein Team bei GPU-Ausfall Prompts an die EU-API schickt?
  22. Was bedeutet HTTP 422 mit Typ budget_exceeded in LiteLLM 1.104?
  23. Warum ENABLE_PERSISTENT_CONFIG=False in Open WebUI?
  24. Was musst du tun, wenn du das Embedding-Modell wechselst?
  25. Wann hilft dir ein etcd-Snapshot, wann Velero?

Lösungsschlüssel

  1. 2 (K und V) × Layer × KV-Heads × head_dim × Bytes; Qwen3-8B: 2 × 36 × 8 × 128 × 2 B = 144 KiB.
  2. Auf den gesamten VRAM der GPU (Gewichte, Aktivierungen und KV-Cache dieser Instanz); die Summe aller Instanzen muss unter 1,0 bleiben, sonst scheitert der zuletzt gestartete Pod.
  3. vLLM prüft beim Start, ob mindestens eine Sequenz maximaler Länge in den KV-Cache passt, und bricht sonst mit ValueError ab.
  4. --max-model-len senken, --kv-cache-dtype=fp8, quantisierte Gewichte (FP8/AWQ) – oder mehr --gpu-memory-utilization, wenn auf der GPU Platz ist.
  5. Die GPU steht unter vLLM fast immer bei 100 %; erst wartende Requests zeigen, dass Kapazität fehlt.
  6. L = 3 × 6 = 18 gleichzeitige Requests; --max-num-seqs muss mindestens 18 sein, sonst wächst die Warteschlange.
  7. Es gibt nur eine GPU; ein zweiter Pod fände keinen VRAM. Jede Änderung erzeugt eine Lücke, eine fehlerhafte einen Ausfall (LiteLLM-Fallback springt ein).
  8. vLLM unterstützt den Parameter suffix nicht, der Client baut den FIM-Prompt selbst; der Alias code verrät Continue nicht, welches Modell dahinter steckt.
  9. vLLM fragt beim Start Metadaten beim Hub ab, ein ungültiger Token ergibt 401 auch für öffentliche Modelle; sofort hilft HF_HUB_OFFLINE=1.
  10. Der API-Token darf mit Mapping.Use ein Mapping zuweisen, eine direkte PCI-Zuweisung erlaubt Proxmox nur root; außerdem ist die VM von der Adresse entkoppelt.
  11. pcie = true gibt es nur mit q35, und große BARs moderner GPUs brauchen einen UEFI-Gast.
  12. etcd verträgt nur ein neues Mitglied gleichzeitig.
  13. Ohne etcd-Quorum kann die API nicht schreiben, kube-vip kann seinen Lease plndr-cp-lock nicht erneuern und gibt die VIP ab.
  14. Ohne Pfad: etcd-Mitgliedschaft auf einen Knoten zurücksetzen, Daten bleiben. Mit Pfad: zusätzlich den Snapshot einspielen, der ganze Cluster springt zurück. Danach auf den anderen Servern server/db löschen und neu joinen.
  15. RKE2 betreibt ein eigenes containerd unter /run/k3s/containerd/containerd.sock; per Toolkit-Variable CONTAINERD_SOCKET in den Helm-Werten.
  16. Speicher und Fehler – nur die Rechenzeit wird geteilt.
  17. Der Admission-Controller ExtendedResourceToleration ist in RKE2 nicht aktiv.
  18. Der Kubelet läuft auch ohne NVIDIA-Treiber; kube_node_status_allocatable{resource="nvidia_com_gpu"} fällt auf 0 bzw. fehlt.
  19. Für gemeinsame RPM/TPM-Zähler, Cooldowns und Cache – sonst zählt jede Replika ihre Limits allein.
  20. Sonst bleibt spend bei 0, und Budgets wirken nie; die Werte bilden die interne Verrechnung ab.
  21. metadata.disable_fallbacks: true am Key (bzw. nur freigegebene Teams mit Fallback) plus Alarm auf litellm_deployment_successful_fallbacks_total.
  22. Das Budget von Key oder Team ist aufgebraucht; ältere Versionen antworten mit 429.
  23. Umgebungsvariablen gewinnen immer, die Konfiguration bleibt reproduzierbar; Änderungen im Admin-UI gelten nur bis zum Neustart.
  24. Alle Sammlungen neu einbetten, weil Dimension und Vektorraum nicht mehr passen.
  25. etcd-Snapshot: ganzer Cluster-Zustand ohne Volumes, z. B. bei Quorum-Verlust oder kaputtem Upgrade. Velero: einzelne Namespaces mit Volume-Daten, z. B. gelöschter Namespace oder verlorene CA.

Teil 3: Selbsteinschätzung

Thema kann ich im Lab gemacht
Werkzeuge, OpenAI-API, Tokens (Tag 0) [ ] [ ]
kind für KI-Workloads (Tag 1) [ ] [ ]
Modell im Pod, Probes, Cache (Tag 2) [ ] [ ]
vLLM-Flags und Sizing (Tag 3) [ ] [ ]
LiteLLM: Aliase, Keys, Budgets, Fallbacks (Tag 4) [ ] [ ]
Open WebUI in kind (Tag 5) [ ] [ ]
Proxmox: Token, Template, IOMMU (Tag 6) [ ] [ ]
VMs mit OpenTofu (Tag 7) [ ] [ ]
RKE2 HA mit Ansible, Upgrades (Tag 8) [ ] [ ]
LB-IPAM, Traefik, cert-manager, Longhorn, Monitoring (Tag 9) [ ] [ ]
GPU Operator, Time-Slicing, DCGM, DRA (Tag 10) [ ] [ ]
vLLM auf der GPU, KEDA (Tag 11) [ ] [ ]
LiteLLM HA, CNPG, Redis, ESO (Tag 12) [ ] [ ]
Open WebUI mit Keycloak und RAG (Tag 13) [ ] [ ]
Code-LLM mit Continue und Tabby (Tag 14) [ ] [ ]
Dashboards, Alarme, Backup, Desaster-Drills (Tag 15) [ ] [ ]

Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten.