Tag 0: Das Trainingsgelände
Ziel: Colima und die Kubernetes-Werkzeuge einrichten, das kind-Cluster
labmit drei Nodes bauen, die Images der App hineinladen und das Cluster einmal von innen ansehen. · Dauer: ca. 45 min · Voraussetzung: keine
Briefing
- kind („Kubernetes in Docker”) startet jeden Node als Docker-Container. Ein Cluster ist in wenigen Minuten gebaut und mit einem Befehl wieder weg.
- Das Labor-Cluster
labhat einen Control-Plane-Node (API-Server, etcd, Scheduler, Controller) und zwei Worker, auf denen deine Pods laufen. kubectlspricht nur mit dem API-Server. Welches Cluster gemeint ist, steht im Kontext in~/.kube/config, hierkind-lab.- Die Images der App baust du lokal und lädst sie mit
kind loadin die Nodes. Eine Registry brauchst du in Teil 1 nicht.
Mac Colima-VM (Linux, arm64)
┌────────────────────────┐ ┌────────────────────────────────────────────┐
│ ~/k8s-lab/ │ │ Docker │
│ setup/ code/ notes/ │ │ ┌──────────────────┐ ┌────────┐ ┌────────┐│
│ tagNN/ │ :6443 │ │lab-control-plane │ │lab- │ │lab- ││
│ kubectl ───────────────┼──────►│ │ API-Server, etcd │ │worker │ │worker2 ││
│ kind, helm, docker │ │ │ Scheduler, … │ │ Pods │ │ Pods ││
│ curl localhost:30080 ──┼──────►│ └──────────────────┘ └────────┘ └────────┘│
└────────────────────────┘ └────────────────────────────────────────────┘
Drill 1: Colima starten
Kubernetes braucht mehr Platz als ein Compose-Stack. Starte Colima
mit 4 CPUs, 8 GB RAM und 60 GB Platte (läuft Colima schon kleiner: erst
colima stop, die neuen Werte gelten beim nächsten
Start):
colima start --cpu 4 --memory 8 --disk 60
colima status
docker info --format 'Arch {{.Architecture}} · CPUs {{.NCPU}}'Erwartet (gekürzt, Werte weichen bei dir ab):
INFO[0000] colima is running using macOS Virtualization.Framework
INFO[0000] arch: aarch64
INFO[0000] runtime: docker
Arch aarch64 · CPUs 4
Fortschritt speichern? Kostenlos registrieren
Drill 2: Werkzeuge
brew install kind kubectl helm jq
kind version
kubectl version --client
helm version --short
jq --versionErwartet (gekürzt, kann je nach Version abweichen):
kind v0.33.0 go1.26.7 darwin/arm64
Client Version: v1.37.2
Kustomize Version: v5.8.1
v4.3.1+gc0d08d0
jq-1.8.2
Getestet ist das Buch mit kind v0.33.0 (Node-Image
kindest/node:v1.37.0), kubectl v1.37.2 und Helm v4.3.1.
kubectl darf eine Minor-Version neuer oder älter sein als das Cluster;
mehr Abstand meldet kubectl version als Warnung.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Arbeitsverzeichnis und Begleitcode
Den Begleitcode holst du einmal von GitHub nach
~/k8s-lab/code. Setup-Dateien und Demo-Anwendung bekommen
eigene Kopien:
mkdir -p ~/k8s-lab && cd ~/k8s-lab
git clone https://github.com/thomaszachmann/kubernetes-zum-anfassen.git ~/k8s-lab/code
cp -R ~/k8s-lab/code/setup ~/k8s-lab/setup
cp -R ~/k8s-lab/code/notes ~/k8s-lab/notes
ls ~/k8s-lab ~/k8s-lab/setup
grep -v '^#' ~/k8s-lab/setup/env.shErwartet:
Cloning into '/Users/du/k8s-lab/code'...
/Users/du/k8s-lab:
code notes setup
/Users/du/k8s-lab/setup:
env.sh kind.yaml
export LAB="${LAB:-$HOME/k8s-lab}"
export NOTES="$LAB/notes"
export CLUSTER="${CLUSTER:-lab}" # kind-Cluster, Kontext kind-$CLUSTER
export NODEPORT_HOST="${NODEPORT_HOST:-30080}" # Port auf dem Mac für NodePort/Gateway
export NS=notes
env.sh setzt nur Variablen. Ab jetzt beginnt jeder Tag
mit derselben Zeile:
source ~/k8s-lab/setup/env.shFortschritt speichern? Kostenlos registrieren
Drill 4: Das Cluster bauen
cat ~/k8s-lab/setup/kind.yamlErwartet:
# kind.yaml – Cluster des Trainingslagers: 1 Control-Plane, 2 Worker
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
image: kindest/node:v1.37.0
extraPortMappings:
- containerPort: 30080
hostPort: 30080
listenAddress: "127.0.0.1"
- role: worker
image: kindest/node:v1.37.0
- role: worker
image: kindest/node:v1.37.0
extraPortMappings veröffentlicht Port 30080 des
Control-Plane-Containers auf 127.0.0.1:30080. Dort kommt ab
Tag 3 die Weboberfläche an. --wait wartet, bis der
Control-Plane-Node bereit ist:
kind create cluster --name lab --config ~/k8s-lab/setup/kind.yaml --wait 120s
kubectl get nodesErwartet (gekürzt, dauert einige Minuten):
Creating cluster "lab" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
✓ Joining worker nodes
✓ Waiting ≤ 2m0s for control-plane = Ready
Set kubectl context to "kind-lab"
…
NAME STATUS ROLES AGE VERSION
lab-control-plane Ready control-plane 31s v1.37.0
lab-worker NotReady <none> 16s v1.37.0
lab-worker2 NotReady <none> 17s v1.37.0
kind wartet nur auf den Control-Plane-Node. Steht ein Worker kurz
danach noch auf NotReady, gib ihm ein paar Sekunden und
prüfe noch einmal mit kubectl get nodes.
Achtung: Bleibt ein Worker dauerhaft weg und zeigt
docker exec lab-worker journalctl -u kubelet | taildie Meldungtoo many open files, reichen die inotify-Limits der VM nicht. Abhilfe laut kind-Doku:colima ssh -- sudo sysctl -w fs.inotify.max_user_instances=512(gilt bis zum nächsten Neustart der VM).
Fortschritt speichern? Kostenlos registrieren
Drill 5: Cluster und Kontext
kubectl config get-contexts
kubectl cluster-info
kubectl get nodesErwartet (gekürzt, Ports, IPs und Zeiten weichen bei dir ab):
CURRENT NAME CLUSTER AUTHINFO NAMESPACE
* kind-lab kind-lab kind-lab
Kubernetes control plane is running at https://127.0.0.1:44025
CoreDNS is running at https://127.0.0.1:44025/api/v1/namespaces/kube-system/…
NAME STATUS ROLES AGE VERSION
lab-control-plane Ready control-plane 2m3s v1.37.0
lab-worker Ready <none> 103s v1.37.0
lab-worker2 Ready <none> 103s v1.37.0
kind hat den Kontext kind-lab angelegt und aktiviert.
Hast du mehrere Cluster, wählst du mit
kubectl config use-context kind-lab – oder jeder Befehl
bekommt --context kind-lab.
kubectl get nodes -o wide
kubectl get nodes \
-o custom-columns='NAME:.metadata.name,ARCH:.status.nodeInfo.architecture'Erwartet (gekürzt, Spalten ausgedünnt):
NAME STATUS … VERSION INTERNAL-IP … OS-IMAGE …
lab-control-plane Ready … v1.37.0 172.18.0.5 … Debian GNU/Linux 13 (trixie) …
lab-worker Ready … v1.37.0 172.18.0.7 … Debian GNU/Linux 13 (trixie) …
lab-worker2 Ready … v1.37.0 172.18.0.6 … Debian GNU/Linux 13 (trixie) …
NAME ARCH
lab-control-plane arm64
lab-worker arm64
lab-worker2 arm64
Jeder Node ist ein Debian-Container mit eigenem containerd (Spalte
CONTAINER-RUNTIME, hier containerd://2.3.4).
Die INTERNAL-IP stammt aus dem Docker-Netz
kind. custom-columns holt beliebige Felder aus
dem Objekt; die Anführungszeichen schützen [*] und
Ähnliches vor der zsh.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Nodes sind Container
docker ps --filter label=io.x-k8s.kind.cluster=lab \
--format 'table {{.Names}}\t{{.Image}}\t{{.Ports}}'Erwartet (gekürzt, Ports weichen ab):
NAMES IMAGE PORTS
lab-worker kindest/node:v1.37.0
lab-control-plane kindest/node:v1.37.0 127.0.0.1:44025->6443/tcp, 127.0.0.1:30080…
lab-worker2 kindest/node:v1.37.0
Port 6443 ist der API-Server, den kubectl über die
kubeconfig erreicht. Colima reicht beide Ports der VM an
localhost auf dem Mac weiter.
Was läuft auf welchem Node?
kubectl -n kube-system get pods \
-o custom-columns='NAME:.metadata.name,NODE:.spec.nodeName'
kubectl get nodes -o custom-columns='NAME:.metadata.name,TAINTS:.spec.taints[*].key'Erwartet (gekürzt):
NAME NODE
coredns-559f6c778d-jqljk lab-control-plane
coredns-559f6c778d-m27p9 lab-control-plane
etcd-lab-control-plane lab-control-plane
kindnet-55z8n lab-worker2
kindnet-l9b28 lab-control-plane
kindnet-sfjrf lab-worker
kube-apiserver-lab-control-plane lab-control-plane
kube-controller-manager-lab-control-plane lab-control-plane
kube-proxy-r7txb lab-worker
kube-proxy-x5vxq lab-control-plane
kube-proxy-z298x lab-worker2
kube-scheduler-lab-control-plane lab-control-plane
NAME TAINTS
lab-control-plane node-role.kubernetes.io/control-plane
lab-worker <none>
lab-worker2 <none>
| Komponente | Läuft auf | Aufgabe |
|---|---|---|
| kube-apiserver, etcd | Control Plane | API und Datenbank des Clusters |
| kube-scheduler | Control Plane | wählt für jeden neuen Pod einen Node |
| kube-controller-manager | Control Plane | gleicht Soll und Ist ab (Tag 2) |
| kube-proxy, kindnet | jedem Node | Service-Regeln (Tag 3) und Pod-Netz |
Der Taint auf dem Control-Plane-Node hält deine Pods fern; sie landen auf den Workern. Die Control-Plane-Komponenten selbst sind Pods, die der Kubelet direkt startet:
docker exec lab-control-plane crictl ps --name 'kube-apiserver|etcd'Erwartet (gekürzt, IDs weichen ab):
CONTAINER IMAGE CREATED STATE NAME …
663d30a4b0d69 bec5f0e1e2eeb 2 minutes ago Running kube-apiserver …
f7fb24e5203c7 270fbeb697171 2 minutes ago Running etcd …
Fortschritt speichern? Kostenlos registrieren
Drill 7: Images ins Cluster laden
Die Nodes haben eigene containerd-Speicher und sehen die Images
deines Docker nicht. Also baust du die drei Images der App und kopierst
sie mit kind load in jeden Node:
cd ~/k8s-lab/notes
for app in api worker web; do
docker build -q --build-arg VERSION=0.1.0 -t "notes-$app:0.1.0" "notes-$app"
kind load docker-image "notes-$app:0.1.0" --name lab
done
docker exec lab-worker crictl images | grep -E 'IMAGE|notes'Erwartet (gekürzt, IDs weichen ab):
sha256:9fe8638a26c7…
Image: "notes-api:0.1.0" with ID "sha256:9fe8638a26c7…" not yet present on node
"lab-control-plane", loading...
…
sha256:f5bbc3206d5b…
…
IMAGE TAG IMAGE ID SIZE
docker.io/library/notes-api 0.1.0 c5e677d5139c6 4.5MB
docker.io/library/notes-web 0.1.0 dd87288dc99da 64.2MB
docker.io/library/notes-worker 0.1.0 2d70b014e28b1 45.5MB
--build-arg VERSION landet in GET /version
der App. kind kopiert in alle drei Nodes. Im Test meldete es bei jedem
Aufruf not yet present und lud neu – harmlos, kostet nur
Zeit. Wichtig ist der feste Tag 0.1.0: Bei
latest würde Kubernetes immer aus dem Internet ziehen
wollen (Tag 1).
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl config current-contextErwartet: der Kontext des kind-Clusters.
kind-lab
kubectl get nodesErwartet: ein Control-Plane-Node und zwei Worker, alle
Ready.
NAME STATUS ROLES AGE VERSION
lab-control-plane Ready control-plane 110s v1.37.0
lab-worker Ready <none> 98s v1.37.0
lab-worker2 Ready <none> 98s v1.37.0
kubectl get pods -n kube-systemErwartet: alle Systempods Running und
1/1.
NAME READY STATUS RESTARTS AGE
coredns-559f6c778d-7jm7k 1/1 Running 0 101s
coredns-559f6c778d-j7t9l 1/1 Running 0 101s
etcd-lab-control-plane 1/1 Running 0 107s
kindnet-9r68x 1/1 Running 0 101s
…
kube-scheduler-lab-control-plane 1/1 Running 0 110s
docker exec lab-worker crictl images | grep notesErwartet: die drei Images der App in Version 0.1.0 im Node (genauso
in lab-worker2 und lab-control-plane).
docker.io/library/notes-api 0.1.0 a4c97999bb14c …
docker.io/library/notes-web 0.1.0 c7d26a572b58f …
docker.io/library/notes-worker 0.1.0 6552249803404 …
ls ~/k8s-lab/codeErwartet: der Begleitcode mit notes, setup
und einem Ordner pro Tag.
anhb
notes
setup
tag01
tag02
…
Challenge
Wirf das Cluster weg und baue es neu. Miss, wie lange es dauert, und prüfe danach, dass alle drei Nodes wieder die Images haben.
Hinweis: kind delete cluster löscht nur
die Node-Container; die Images liegen weiter in deinem Docker und müssen
nur neu verteilt werden.
Lösung
kind delete cluster --name lab
SECONDS=0
kind create cluster --name lab --config ~/k8s-lab/setup/kind.yaml --wait 120s
for app in api worker web; do
kind load docker-image "notes-$app:0.1.0" --name lab
done
echo "Dauer: ${SECONDS}s"
kubectl get nodes
docker exec lab-worker2 crictl images | grep -c notesErwartet (gekürzt, Zeiten weichen ab):
Deleting cluster "lab" ...
Deleted nodes: ["lab-control-plane" "lab-worker" "lab-worker2"]
Creating cluster "lab" ...
…
Image: "notes-api:0.1.0" with ID "sha256:9fe8638a26c7…" not yet present on node
"lab-worker2", loading...
…
Dauer: 121s
NAME STATUS ROLES AGE VERSION
lab-control-plane Ready control-plane 92s v1.37.0
lab-worker Ready <none> 78s v1.37.0
lab-worker2 Ready <none> 78s v1.37.0
3
kind load allein ist auch der Weg, wenn du eine
App-Version neu gebaut hast. Ein frisches Cluster ist leer: Alles, was
du ab Tag 1 anlegst, steht in Dateien unter ~/k8s-lab/tagNN
und ist mit kubectl apply schnell wieder da. Die Images
bleiben im Docker der VM und werden nur neu verteilt.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- kind ist für Labor und CI gedacht. Produktions-Cluster laufen auf VMs oder Blech (RKE2 in Teil 2) oder als Managed Service (EKS, AKS, GKE).
- Images kommen dort aus einer Registry mit Pull-Secret, festen Tags oder Digests und Signaturprüfung („Sichere Lieferketten zum Anfassen”).
- Mehrere Cluster heißt mehrere Kontexte: Ein
kubectl deleteim falschen Kontext ist ein Klassiker. Der Kontext gehört in den Shell-Prompt oder in Werkzeuge wiek9s. - Die kubeconfig von kind enthält ein Admin-Zertifikat. Für echte Cluster bekommt jeder Mensch eigene Zugangsdaten per OIDC und RBAC, nie die Admin-Datei.