Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Trainingsgelände aufbauen

Ziel: Alle Werkzeuge, die Linux-VM llm-vm und den kind-Cluster sre-lab einsatzbereit haben · Dauer: ca. 60 min · Voraussetzung: keine

Briefing

  • Auf dem Laptop laufen Werkzeuge, Docker und der kind-Cluster.
  • Die Linux-VM llm-vm ist 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 multipass

Tipp: Statt Docker Desktop geht auch brew install colima docker und colima 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 --classic

kind, 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 kind

Versionen prüfen:

kind version
kubectl version --client
helm version --short
go version
python3 --version
tofu version | head -1
ansible --version </dev/null | head -1

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

Erwartet:

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
EOF
multipass launch 24.04 --name llm-vm --cpus 4 --memory 8G --disk 40G \
  --cloud-init ~/sre-lab/vm/cloud-init.yaml --timeout 900
multipass list

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

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

Tipp: 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ßt multipass shell llm-vm oder ssh.

Achtung: Die VM belegt 8 GB RAM. Pause mit multipass stop llm-vm, weiter mit multipass 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 120s

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

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

Erwartet (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 wieder kind 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-linux

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

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

Erwartet (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/apt aus dem Internet – Werkzeuge, Container-Images und Modellgewichte vorab spiegeln (Tag 14).
  • Werkzeugversionen pinnen (z. B. .tool-versions mit 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.