Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Das Trainingsgelände

Ziel: Colima und die Kubernetes-Werkzeuge einrichten, das kind-Cluster lab mit 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 lab hat einen Control-Plane-Node (API-Server, etcd, Scheduler, Controller) und zwei Worker, auf denen deine Pods laufen.
  • kubectl spricht nur mit dem API-Server. Welches Cluster gemeint ist, steht im Kontext in ~/.kube/config, hier kind-lab.
  • Die Images der App baust du lokal und lädst sie mit kind load in 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 --version

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

Erwartet:

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

Fortschritt speichern? Kostenlos registrieren

Drill 4: Das Cluster bauen

cat ~/k8s-lab/setup/kind.yaml

Erwartet:

# 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 nodes

Erwartet (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 | tail die Meldung too 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 nodes

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

Erwartet: der Kontext des kind-Clusters.

kind-lab
kubectl get nodes

Erwartet: 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-system

Erwartet: 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 notes

Erwartet: 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/code

Erwartet: 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 notes

Erwartet (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 delete im falschen Kontext ist ein Klassiker. Der Kontext gehört in den Shell-Prompt oder in Werkzeuge wie k9s.
  • 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.