Tag 0: Das Trainingsgelände
Ziel: Laptop-Werkzeuge laufen,
~/ki-labsteht, 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 k9sErwartet (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 --versionErwartet:
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 -1Erwartet (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 mitdocker 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-labErwartet:
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/codeAlles, 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 -1Erwartet:
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.pyErwartet (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.meErwartet:
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, trage127.0.0.1 chat.ki.localtest.meund die anderen Namen in/etc/hostsein.
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"
doneErwartet:
✔ 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 nvidiaErwartet (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,asdfoder 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_KEYmit echtem Schlüssel nie in~/.zshrc, sondern aus dem Passwortmanager oder OpenBao.