Tag 0: Trainingsgelände aufbauen
Ziel: Alle Werkzeuge, die Linux-VM
llm-vmund den kind-Clustersre-labeinsatzbereit haben · Dauer: ca. 60 min · Voraussetzung: keine
Briefing
- Auf dem Laptop laufen Werkzeuge, Docker und der kind-Cluster.
- Die Linux-VM
llm-vmist dein „Kundenserver”: dort üben Linux-Internals (Tag 1), Netzwerk (Tag 2) und Modellserver (Tag 5). - Alles liegt unter
~/sre-lab, ein Ordner pro Tag. - Speicher ist knapp: kind-Cluster plus VM brauchen zusammen ca. 10 GB RAM. Stoppe die VM, wenn du sie nicht brauchst.
Laptop ──docker──► kind "sre-lab" (cp + 2 worker)
└────multipass─► VM "llm-vm" (Ubuntu 24.04, 4 CPU, 8 GB)
Drill 1: Werkzeuge installieren
macOS mit Homebrew:
brew install kind kubernetes-cli helm go [email protected] jq opentofu \
ansible trivy syft grype cosign kyverno
brew install --cask docker-desktop multipassTipp: Statt Docker Desktop geht auch
brew install colima dockerundcolima start --cpu 4 --memory 8. Gib der Docker-VM mindestens 6 GB RAM, sonst bleibt kind später hängen.
Linux (Ubuntu/Debian), Grundpakete über apt, den Rest als Snap oder Binary:
sudo apt-get update
sudo apt-get install -y docker.io jq curl python3 python3-venv \
ansible-core
sudo usermod -aG docker "$USER" # danach neu einloggen
sudo snap install multipass
sudo snap install kubectl --classic
sudo snap install helm --classic
sudo snap install go --classic
sudo snap install opentofu --classickind, trivy, syft,
grype, cosign und kyverno holst
du als Release-Binary von GitHub (jeweils Abschnitt „Installation” der
Projektdoku), z. B. kind:
curl -Lo kind https://kind.sigs.k8s.io/dl/v0.33.0/kind-linux-amd64
sudo install -m 0755 kind /usr/local/bin/kind && rm kindVersionen prüfen:
kind version
kubectl version --client
helm version --short
go version
python3 --version
tofu version | head -1
ansible --version </dev/null | head -1Erwartet (macOS, gekürzt, Versionen können abweichen):
kind v0.33.0 go1.27.0 darwin/arm64
Client Version: v1.37.1
v4.3.0+gbec5b06
go version go1.25.5 darwin/arm64
Python 3.14.8
OpenTofu v1.12.1
ansible [core 2.20.1]
Warum </dev/null bei ansible? Ansible verweigert den
Start, wenn stdin nicht blockierend ist (passiert in manchen Terminals
und CI-Runnern): ERROR: Ansible requires blocking IO.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Arbeitsverzeichnis anlegen
Der Begleitcode kommt von GitHub nach ~/sre-lab/code,
die übrigen Ordner legst du an:
git clone https://github.com/thomaszachmann/llm-plattformen-zum-anfassen.git \
~/sre-lab/code
mkdir -p ~/sre-lab/{k8s,vm} \
~/sre-lab/tag{00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15}
ls ~/sre-lab | xargsErwartet:
Cloning into '…/sre-lab/code'...
code k8s tag00 tag01 tag02 tag03 tag04 tag05 tag06 tag07 tag08 tag09 tag10 tag11
tag12 tag13 tag14 tag15 vm
| Ordner | Inhalt |
|---|---|
code/ |
Begleitcode: llmctl (Tag 3), llm-gateway (Tag 4) und mehr |
k8s/ |
kind.yaml, Manifeste, Helm-Values |
vm/ |
cloud-init, Skripte für die VM |
tagNN/ |
Spielwiese des jeweiligen Tages |
Fortschritt speichern? Kostenlos registrieren
Drill 3: Linux-VM llm-vm anlegen
Zuerst eine cloud-init-Datei, damit die Debug-Werkzeuge für Tag 1 und 2 gleich mit installiert werden:
cat > ~/sre-lab/vm/cloud-init.yaml <<'EOF'
#cloud-config
package_update: true
packages:
- strace
- stress-ng
- sysstat
- linux-tools-common
- dnsutils
- tcpdump
- nftables
- conntrack
- iperf3
- jq
- python3-venv
timezone: Europe/Berlin
EOFmultipass launch 24.04 --name llm-vm --cpus 4 --memory 8G --disk 40G \
--cloud-init ~/sre-lab/vm/cloud-init.yaml --timeout 900
multipass listErwartet (gekürzt, kann je nach Version abweichen):
Launched: llm-vm
Name State IPv4 Image
llm-vm Running 192.168.64.5 Ubuntu 24.04 LTS
multipass exec llm-vm -- bash -c 'uname -r; nproc; free -g | head -2'
multipass exec llm-vm -- cloud-init status --waitErwartet (gekürzt, kann je nach Version abweichen):
6.8.0-85-generic
4
total used free shared buff/cache available
Mem: 7 0 6 0 0 6
status: done
Rein in die VM:
multipass shell llm-vmTipp: Ohne Multipass (oder mit GPU für vLLM ab Tag 5) nimmst du eine Cloud-VM mit Ubuntu 24.04, z. B. eine GPU-Instanz mit 24 GB VRAM. Die cloud-init-Datei kannst du dort als „User Data” übergeben; Zugang dann per
ssh ubuntu@<ip>. Überall im Buch gilt: „auf der VM” heißtmultipass shell llm-vmoderssh.
Achtung: Die VM belegt 8 GB RAM. Pause mit
multipass stop llm-vm, weiter mitmultipass start llm-vm.
Fortschritt speichern? Kostenlos registrieren
Drill 4: kind-Cluster sre-lab anlegen
cat > ~/sre-lab/k8s/kind.yaml <<'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: sre-lab
nodes:
- role: control-plane
- role: worker
- role: worker
EOF
kind create cluster --config ~/sre-lab/k8s/kind.yaml --wait 120sErwartet (gekürzt, kann je nach Version abweichen):
Creating cluster "sre-lab" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
...
Set kubectl context to "kind-sre-lab"
kubectl config current-context
kubectl get nodesErwartet (Ausgabe mit drei Nodes, Alter variiert):
kind-sre-lab
NAME STATUS ROLES AGE VERSION
sre-lab-control-plane Ready control-plane 8m13s v1.37.0
sre-lab-worker Ready <none> 8m2s v1.37.0
sre-lab-worker2 Ready <none> 8m2s v1.37.0
Warum name: in der Datei? Dann reicht
--config; --name auf der Kommandozeile würde
den Wert überschreiben. Der kubectl-Kontext heißt immer
kind-<name>.
Namespaces für das ganze Buch gleich anlegen:
for ns in llm-system monitoring tenant-acme tenant-globex; do
kubectl create namespace "$ns"
done
kubectl get ns llm-system monitoring tenant-acme tenant-globexErwartet (Alter variiert):
namespace/llm-system created
namespace/monitoring created
namespace/tenant-acme created
namespace/tenant-globex created
NAME STATUS AGE
llm-system Active 5s
monitoring Active 5s
tenant-acme Active 5s
tenant-globex Active 5s
Tipp: Cluster weg und neu:
kind delete cluster --name sre-lab, dann wiederkind create cluster --config .... Das dauert eine Minute – nutze es, statt kaputte Zustände zu reparieren.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Python-venv für llmctl
cd ~/sre-lab
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip httpx pytest
python -c 'import httpx, pytest; print(httpx.__version__, pytest.__version__)'Erwartet (Versionen können abweichen):
0.28.1 9.1.1
Warum ein venv? Systemweites pip install ist auf
aktuellen macOS/Ubuntu-Pythons gesperrt (PEP 668,
externally-managed-environment). Ein venv pro Projekt ist
auch beim Kunden der saubere Weg.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Go prüfen
mkdir -p ~/sre-lab/tag00/gocheck && cd ~/sre-lab/tag00/gocheck
cat > main.go <<'EOF'
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Printf("Go %s auf %s/%s – bereit\n",
runtime.Version(), runtime.GOOS, runtime.GOARCH)
}
EOF
go mod init gocheck
go run .Erwartet (Version und Plattform variieren):
go: creating new go.mod: module gocheck
Go go1.25.5 auf darwin/arm64 – bereit
Cross-Compile für die VM (Linux, gleiche CPU-Architektur wie dein Laptop):
GOOS=linux GOARCH=$(go env GOARCH) go build -o gocheck-linux .
multipass transfer gocheck-linux llm-vm:/home/ubuntu/
multipass exec llm-vm -- /home/ubuntu/gocheck-linuxErwartet (im Ubuntu-24.04-Container getestet, Version variiert):
Go go1.25.5 auf linux/arm64 – bereit
Warum? Ein statisches Go-Binary ohne Abhängigkeiten auf einen Server kopieren – genau so lieferst du später Tools beim Kunden aus (Tag 4, Tag 14).
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cat > ~/sre-lab/tag00/check.sh <<'EOF'
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
for t in docker kind kubectl helm go python3 jq curl tofu ansible \
trivy syft grype cosign kyverno multipass; do
check "$t installiert" "command -v $t"
done
check "go >= 1.25" \
"go version | grep -Eq 'go1\.(2[5-9]|[3-9][0-9])'"
check "python >= 3.12" \
"python3 -c 'import sys; assert sys.version_info >= (3, 12)'"
check "docker daemon läuft" "docker info"
check "venv mit httpx/pytest" \
"~/sre-lab/.venv/bin/python -c 'import httpx, pytest'"
check "kind-Cluster sre-lab" "kind get clusters | grep -qx sre-lab"
check "3 Nodes Ready" \
"[ \$(kubectl --context kind-sre-lab get nodes --no-headers \
| grep -c ' Ready') -eq 3 ]"
check "Namespace tenant-acme" \
"kubectl --context kind-sre-lab get ns tenant-acme"
check "VM llm-vm läuft" "multipass info llm-vm | grep -q Running"
check "VM hat strace" "multipass exec llm-vm -- which strace"
EOF
bash ~/sre-lab/tag00/check.shErwartet (gekürzt):
✔ docker installiert
✔ kind installiert
...
✔ multipass installiert
✔ go >= 1.25
✔ python >= 3.12
✔ docker daemon läuft
✔ venv mit httpx/pytest
✔ kind-Cluster sre-lab
✔ 3 Nodes Ready
✔ Namespace tenant-acme
✔ VM llm-vm läuft
✔ VM hat strace
Challenge
Schreibe ein Skript ~/sre-lab/lab.sh mit den
Unterbefehlen up und down: down
stoppt die VM und löscht den kind-Cluster, up startet
beides wieder (Cluster nur anlegen, wenn er fehlt) und legt die vier
Namespaces idempotent an.
Hinweis:
kubectl create namespace X --dry-run=client -o yaml | kubectl apply -f -
ist idempotent.
Lösung
cat > ~/sre-lab/lab.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
NS="llm-system monitoring tenant-acme tenant-globex"
case "${1:-}" in
up)
multipass start llm-vm
if ! kind get clusters | grep -qx sre-lab; then
kind create cluster --config ~/sre-lab/k8s/kind.yaml --wait 120s
fi
for ns in $NS; do
kubectl --context kind-sre-lab create namespace "$ns" \
--dry-run=client -o yaml | kubectl --context kind-sre-lab apply -f -
done
;;
down)
multipass stop llm-vm || true
kind delete cluster --name sre-lab
;;
*)
echo "Usage: $0 up|down" >&2; exit 2
;;
esac
EOF
chmod +x ~/sre-lab/lab.sh
~/sre-lab/lab.sh upErwartet (gekürzt, kann abweichen):
namespace/llm-system configured
namespace/monitoring configured
namespace/tenant-acme configured
namespace/tenant-globex configured
Bei bestehenden Namespaces meldet apply „configured”
oder „unchanged” – entscheidend ist, dass ein zweiter Lauf nicht
scheitert.
Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- „Wie baust du dir eine Testumgebung?” – Reproduzierbar per Code:
kind-Config, cloud-init, ein
up/down-Skript. Wegwerfen ist billiger als reparieren. - kind simuliert Multi-Node-Kubernetes in Docker; GPU-Scheduling, echte Storage-Klassen und Netzwerk-Performance testest du damit nicht.
- Für Modellserver brauchst du echtes Linux (VM oder Bare Metal): Treiber, cgroups, systemd – genau wie beim Kunden on-prem.
- Brücke: Bei regulierten Kunden mit OpenShift gab es selten Cluster-Admin-Rechte – lokale Labs mit identischen Manifesten waren der Weg, Änderungen vorab zu testen.
Enterprise-Notiz
- Statt kind: verwaltete Cluster (EKS, GKE, AKS, OpenShift) oder beim Kunden on-prem RKE2/OpenShift; Versionen an den Kunden angleichen.
- VM-Images mit Packer bauen und versionieren, statt cloud-init bei jedem Start Pakete ziehen zu lassen.
- Air-Gap: Kein
brew/aptaus dem Internet – Werkzeuge, Container-Images und Modellgewichte vorab spiegeln (Tag 14). - Werkzeugversionen pinnen (z. B.
.tool-versionsmit asdf/mise), damit Team und CI dieselben Binaries nutzen. - GPU-Knoten sind teuer: Labs mit GPU per IaC (Tag 12) auf- und automatisch wieder abbauen.