Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Das Trainingsgelände

Ziel: Laptop-Werkzeuge laufen, ~/ki-lab steht, und du weißt, ob dein Proxmox-Host eine GPU durchreichen kann. · Dauer: ca. 45 min · Voraussetzung: keine

Briefing

  • Teil A (Tag 1–5) läuft komplett auf dem Laptop: Docker, kind, kubectl, Helm, jq, curl, Python.
  • Sprachmodelle sind groß. Docker braucht mehr RAM und Disk als für normale Labs.
  • Jeder Modellserver im Buch spricht die OpenAI-API (/v1/models, /v1/chat/completions). Du lernst sie heute einmal ohne Kubernetes kennen.
  • Teil B–D brauchen einen Proxmox-Host mit IOMMU und eine NVIDIA-GPU. Heute prüfst du nur, eingerichtet wird an Tag 6.

Drill 1: Werkzeuge installieren

macOS mit Homebrew:

brew install colima docker kind kubernetes-cli helm jq k9s
brew list --versions colima docker kind kubernetes-cli helm jq k9s

Erwartet (Versionen können abweichen):

colima 0.10.3
docker 29.9.0
helm 4.3.0
jq 1.8.2
k9s 0.51.0
kind 0.33.0
kubernetes-cli 1.37.1

Linux: Docker Engine aus dem Paket-Repository von Docker, kind, kubectl und helm von den offiziellen Release-Seiten, jq und python3-venv über den Paketmanager. Docker Desktop statt Colima funktioniert ebenso.

kind version
kubectl version --client | head -1
helm version --short
python3 --version

Erwartet:

kind v0.33.0 go1.27.0 darwin/arm64
Client Version: v1.37.1
v4.3.0+gbec5b06
Python 3.14.8

Fortschritt speichern? Kostenlos registrieren

Drill 2: Docker groß genug machen

Ein Modell mit 0,5 Mrd. Parametern braucht rund 1 GB RAM, ein 3B-Modell schon 3–4 GB. Dazu kommen zwei kind-Nodes, Ingress, LiteLLM, Postgres und Open WebUI.

colima stop
colima start --cpu 6 --memory 12 --disk 60
docker info --format 'CPUs: {{.NCPU}}  RAM: {{.MemTotal}}'
colima ssh -- df -h / | tail -1

Erwartet (Werte hängen von deinem Laptop ab):

CPUs: 6  RAM: 12538998784
/dev/root        58G  9.1G   49G  16% /
Ressource Minimum Empfohlen
CPU 4 6 oder mehr
RAM 8 GB 12 GB
Disk im Docker-VM 20 GB frei 60 GB

Achtung: Images und Modelle landen in der Docker-VM, nicht direkt auf dem Mac. Läuft die VM-Disk voll, scheitern Pulls mit no space left on device. Prüfe vor jedem Tag mit docker system df.

Docker Desktop: Settings → Resources, dieselben Werte. Unter Linux gilt die Hardware des Hosts.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Arbeitsverzeichnis anlegen

mkdir -p ~/ki-lab/{code,tag01,tag02,tag03,tag04,tag05}
ls ~/ki-lab

Erwartet:

code
tag01
tag02
tag03
tag04
tag05

Der Begleitcode liegt kostenlos auf GitHub: https://github.com/thomaszachmann/llms-auf-kubernetes-zum-anfassen. Hol ihn und lege seinen Inhalt unter ~/ki-lab/code ab:

git clone https://github.com/thomaszachmann/llms-auf-kubernetes-zum-anfassen.git \
  ~/llms-auf-kubernetes-zum-anfassen 2>/dev/null \
  || git -C ~/llms-auf-kubernetes-zum-anfassen pull
cp -R ~/llms-auf-kubernetes-zum-anfassen/* ~/ki-lab/code/
ls ~/ki-lab/code

Alles, was du mehr als einmal brauchst, steht dort, zum Beispiel ~/ki-lab/code/kind-lab/up.sh ab Tag 1. Die Kapitel zeigen die meisten Dateien vollständig; wo sie nur die wichtigsten Zeilen zeigen, liegt die ganze Datei im Begleitcode.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Python-Umgebung

Ein venv nur für das Lab. Darin landen später das OpenAI-SDK, Testskripte und Lasttests.

python3 -m venv ~/ki-lab/.venv
~/ki-lab/.venv/bin/pip install --quiet --upgrade pip openai
~/ki-lab/.venv/bin/python -c "import openai; print(openai.__version__)"

Erwartet (Version kann abweichen):

3.27.0

Warum das OpenAI-SDK? llama.cpp, vLLM, Ollama und LiteLLM sprechen alle dieselbe API. Ein Client funktioniert gegen jeden Server, nur base_url und Key ändern sich.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Shell-Helfer

Drei Umgebungsvariablen beschreiben jedes Ziel: KI_API (Basis-URL inkl. /v1), KI_KEY (API-Key) und KI_MODEL (Modellname). Der Helfer ask schickt eine Frage und zeigt nur die Antwort.

cat >> ~/.zshrc <<'EOF'
# --- KI-Lab ---
alias kk='kubectl --context kind-ki-lab'
ask() {
  jq -n --arg m "${KI_MODEL:?KI_MODEL fehlt}" --arg q "$*" \
    '{model: $m, messages: [{role: "user", content: $q}], max_tokens: 200}' \
  | curl -s "${KI_API:?KI_API fehlt}/chat/completions" \
      -H "Authorization: Bearer ${KI_KEY:-none}" \
      -H "Content-Type: application/json" -d @- \
  | jq -r '.choices[0].message.content // .error'
}
EOF
source ~/.zshrc
type ask | head -1

Erwartet:

ask is a shell function from /Users/<du>/.zshrc

Warum jq -n statt eines JSON-Strings im Befehl? Die Frage darf Anführungszeichen und Umlaute enthalten, jq maskiert sie korrekt. .error zeigt Fehlermeldungen des Servers statt null.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Gegenprobe ohne Kubernetes

Läuft auf deinem Laptop bereits Ollama, siehst du die OpenAI-API hier zum ersten Mal. Ohne Ollama überspringst du den Drill, an Tag 2 läuft dasselbe gegen einen Pod.

export KI_API=http://127.0.0.1:11434/v1 KI_MODEL=ministral-3:3b
curl -s $KI_API/models | jq -r '.data[].id'
ask "Antworte in einem Satz: Was ist Kubernetes?"

Erwartet (Modellliste und Antwort weichen ab):

ministral-3:3b
gemma3:4b
Kubernetes ist ein Open-Source-Orchestrierungstool zur automatisierten
Verwaltung und Skalierung von Container-Anwendungen.

Dasselbe mit dem Python-SDK:

cat > ~/ki-lab/code/hallo.py <<'EOF'
import os

from openai import OpenAI

client = OpenAI(base_url=os.environ["KI_API"],
                api_key=os.environ.get("KI_KEY", "none"))
r = client.chat.completions.create(
    model=os.environ["KI_MODEL"],
    messages=[{"role": "user", "content": "Sag nur: Hallo Trainingslager"}],
    max_tokens=20,
)
print(r.choices[0].message.content)
print("Tokens:", r.usage.prompt_tokens, "+", r.usage.completion_tokens)
EOF
~/ki-lab/.venv/bin/python ~/ki-lab/code/hallo.py

Erwartet (Text weicht ab):

Hallo Trainingslager!
Tokens: 562 + 20

Warum 562 Prompt-Tokens für fünf Wörter? Ollama setzt das System-Prompt und Chat-Template des Modells davor. Tokens sind die Währung im ganzen Buch: Kosten, Latenz und Budgets (Tag 4) rechnen in Tokens.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Wildcard-DNS prüfen

Alle Lab-Hostnamen in kind enden auf .ki.localtest.me. Die öffentliche Domain localtest.me löst jeden Namen auf 127.0.0.1 auf, du brauchst keine /etc/hosts-Einträge.

dig +short chat.ki.localtest.me
dig +short irgendwas.ki.localtest.me

Erwartet:

127.0.0.1
127.0.0.1

Achtung: Manche Router und Firmen-DNS filtern Antworten mit 127.0.0.1 (DNS-Rebinding-Schutz). Kommt nichts zurück, trage 127.0.0.1 chat.ki.localtest.me und die anderen Namen in /etc/hosts ein.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Proxmox- und GPU-Checkliste

Teil B–D laufen auf Proxmox VE 9.x. Führe die Befehle als root auf dem Proxmox-Host aus. Sie ändern nichts.

pveversion
nproc; free -g | awk '/^Mem/ {print "RAM GB:", $2}'
pvesm status
lscpu | grep -E 'Model name|Virtualization'

Erwartet (gekürzt, kann je nach Version abweichen):

pve-manager/9.1.4/... (running kernel: 6.17.2-1-pve)
32
RAM GB: 125
Name         Type     Status     Total     Used    Available    %
local         dir     active    98497780  ...
local-lvm lvmthin     active   832888832  ...
Model name:      Intel(R) Xeon(R) Gold 6138 CPU @ 2.00GHz
Virtualization:  VT-x

Für die sechs VMs (Tag 7) brauchst du zusammen 36 vCPU (überbuchbar), 88 GB RAM und 580 GB Disk, verteilt auf Basis- und GPU-Host:

Name IP Rolle Ressourcen
rke2-cp-1..3 10.10.20.11–13 RKE2 server 4 vCPU, 8 GB, 60 GB
rke2-wk-1..2 10.10.20.21–22 RKE2 agent 8 vCPU, 16 GB, 100 GB
rke2-gpu-1 10.10.20.31 agent + GPU 8 vCPU, 32 GB, 200 GB

Prüfe, ob die geplanten IPs, die API-VIP .10 und der LoadBalancer-Pool .100–.120 frei sind:

for i in 10 11 12 13 21 22 31 100 120; do
  ping -c1 -W1 10.10.20.$i >/dev/null && echo "✘ 10.10.20.$i belegt" \
    || echo "✔ 10.10.20.$i frei"
done

Erwartet:

✔ 10.10.20.10 frei
✔ 10.10.20.11 frei
...
✔ 10.10.20.120 frei

Liegt dein Netz anders, notiere die Abweichung jetzt. Alle späteren Kapitel nutzen 10.10.20.0/24, Gateway und DNS .1, Domain lab.internal.

GPU und IOMMU

Auf dem GPU-Host, ebenfalls nur lesend:

lspci -nnk | grep -A3 -i nvidia
dmesg | grep -e DMAR -e IOMMU -e AMD-Vi | head -5
dmesg | grep 'remapping'

Erwartet (gekürzt, kann je nach Hardware abweichen):

3b:00.0 3D controller [0302]: NVIDIA Corporation AD104GL [L4] [10de:27b8] (rev a1)
        Subsystem: NVIDIA Corporation Device [10de:16ca]
        Kernel modules: nvidiafb, nouveau
DMAR: IOMMU enabled
DMAR-IR: Enabled IRQ remapping in x2apic mode
Prüfpunkt Gut Schlecht
GPU sichtbar Zeile mit NVIDIA und [10de:...] keine Ausgabe
IOMMU DMAR: IOMMU enabled oder AMD-Vi keine Ausgabe
Interrupt-Remapping Enabled IRQ remapping fehlt
Treiber noch egal –

Fehlt IOMMU: VT-d bzw. AMD-Vi im BIOS/UEFI aktivieren. Kernel-Parameter und vfio-pci richtest du an Tag 6 ein. Notiere die PCI-Adresse (3b:00.0) und die IDs (10de:27b8), Tag 6 und Tag 7 brauchen sie.

Die GPU muss allein in ihrer IOMMU-Gruppe liegen, zusammen mit ihren eigenen Funktionen (Audio, USB-C) ist in Ordnung:

for d in /sys/kernel/iommu_groups/*/devices/*; do
  g=${d#*/iommu_groups/}; g=${g%%/*}
  echo "Gruppe $g: $(lspci -nns "${d##*/}")"
done | grep -i -B1 -A1 nvidia

Erwartet (gekürzt, kann je nach Hardware abweichen):

Gruppe 42: 3b:00.0 3D controller [0302]: NVIDIA Corporation AD104GL [L4] [10de:27b8]

Nach einem Reboot mit IOMMU liefert dieselbe Information pvesh get /nodes/$(hostname)/hardware/pci --pci-class-blacklist "".

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Auf dem Laptop:

for t in docker kind kubectl helm jq curl python3; do
  command -v "$t" >/dev/null && echo "✔ $t" || echo "✘ $t fehlt"
done
docker info >/dev/null 2>&1 && echo "✔ Docker-Daemon" || echo "✘ Docker-Daemon"
mem=$(docker info --format '{{.MemTotal}}')
[ "$mem" -ge 7500000000 ] && echo "✔ Docker-RAM" || echo "✘ Docker-RAM < 8 GB"
[ -d ~/ki-lab/code ] && echo "✔ ~/ki-lab" || echo "✘ ~/ki-lab fehlt"
~/ki-lab/.venv/bin/python -c 'import openai' 2>/dev/null \
  && echo "✔ venv + openai" || echo "✘ venv"
type ask >/dev/null 2>&1 && echo "✔ ask" || echo "✘ ask"
[ "$(dig +short chat.ki.localtest.me)" = 127.0.0.1 ] \
  && echo "✔ localtest.me" || echo "✘ localtest.me"

Auf dem Proxmox-GPU-Host:

lspci -nn | grep -qi '10de:' && echo "✔ NVIDIA-GPU" || echo "✘ keine NVIDIA-GPU"
dmesg | grep -qE 'IOMMU enabled|AMD-Vi' && echo "✔ IOMMU" || echo "✘ IOMMU"
dmesg | grep -q 'remapping' && echo "✔ IRQ-Remapping" || echo "✘ IRQ-Remapping"

Challenge

Erweitere ask zu askt: Nach der Antwort soll eine Zeile mit der Zahl der erzeugten Tokens und der Antwortzeit in Sekunden erscheinen.

Hinweis: curl -w '%{time_total}' hängt die Laufzeit an die Ausgabe an, .usage.completion_tokens liefert die Token-Zahl.

Lösung

askt() {
  local out body secs
  out=$(jq -n --arg m "$KI_MODEL" --arg q "$*" \
      '{model: $m, messages: [{role: "user", content: $q}], max_tokens: 200}' \
    | curl -s -w '\n%{time_total}' "$KI_API/chat/completions" \
        -H "Authorization: Bearer ${KI_KEY:-none}" \
        -H "Content-Type: application/json" -d @-)
  secs=${out##*$'\n'}
  body=${out%$'\n'*}
  printf '%s' "$body" | jq -r --arg s "$secs" \
    '.choices[0].message.content, "--- \(.usage.completion_tokens) Tokens in \($s) s"'
}
askt "Nenne drei Kubernetes-Objekte, nur die Namen, kommagetrennt."

Erwartet (Text und Zeit weichen ab):

Deployment, Pod, ConfigMap
--- 25 Tokens in 0.940295 s

Warum printf '%s' statt echo? In der zsh wandelt echo die \n in der JSON-Antwort in echte Zeilenumbrüche um, danach scheitert jq mit control characters ... must be escaped. Mit Tokens pro Sekunde vergleichst du ab Tag 2 CPU, Quantisierung und später die GPU.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Werkzeugversionen im Team pinnen (mise, asdf oder ein Devcontainer), sonst weichen Ausgaben und Flags ab.
  • Python-Abhängigkeiten mit Lockfile (uv lock, pip-tools) und aus einem internen Mirror.
  • Für Kunden-GPU-Server vorab klären: BIOS-Zugriff, IOMMU/SR-IOV, Stromversorgung und Kühlung der Karte, Treiber-Lizenz (vGPU braucht NVIDIA-Lizenzen, Passthrough nicht).
  • Modelle aus dem Internet sind Software aus fremder Quelle: Lizenz, Herkunft und Prüfsummen dokumentieren.
  • KI_KEY mit echtem Schlüssel nie in ~/.zshrc, sondern aus dem Passwortmanager oder OpenBao.