Tag 1: k0s mit k0sctl aufbauen
Ziel: Ein k0s-Cluster v1.36.6 mit einem Controller und drei Workern läuft, die Worker tragen ihre Zone als Label, und
kubectlaufk0s-ctrlspricht mit ihm. · Dauer: ca. 45 min · Voraussetzung: Tag 0
Briefing
- k0s ist ein einziges Binary mit API-Server, Scheduler, etcd, containerd, kubelet und CNI. Vom Betriebssystem braucht es nur den Kernel.
- k0sctl verteilt k0s per SSH: Download, Konfiguration, Join-Tokens, später Updates. Es läuft auf dem Arbeitsplatz und braucht dort Zugang zu allen Hosts.
- Ein reiner Controller ist kein Node: kein kubelet,
keine Pods, nicht in
kubectl get nodes. - Die Cluster-Beschreibung
k0sctl.yamlist die einzige Quelle der Wahrheit.k0sctl applygleicht den Cluster mit ihr ab, beliebig oft. - Du baust bewusst v1.36.6 auf. Das Update auf 1.37 übst du an Tag 15.
k0s-ctrl: k0sctl ──SSH──> k0s-ctrl k0scontroller (etcd, API, Scheduler)
──SSH──> k0s-w1/2/3 k0sworker (containerd, kubelet)
kubectl ──6443──> API konnectivity: Worker ──8132──> Controller
Drill 1: k0sctl laden
Binaries lädst du in diesem Buch immer passend zur Architektur.
dpkg --print-architecture liefert amd64 oder
arm64 – genau so heißen die Release-Dateien.
# auf k0s-ctrl
mkdir -p ~/k0s-lab/tag01 && cd ~/k0s-lab/tag01
ARCH=$(dpkg --print-architecture); echo $ARCH
V=v0.33.1
curl -sSfLO https://github.com/k0sproject/k0sctl/releases/download/$V/k0sctl-linux-$ARCH
curl -sSfLO https://github.com/k0sproject/k0sctl/releases/download/$V/checksums.txt
grep "k0sctl-linux-$ARCH\$" checksums.txt | sha256sum -c
sudo install -m 755 k0sctl-linux-$ARCH /usr/local/bin/k0sctl
k0sctl versionErwartet:
amd64
k0sctl-linux-amd64: OK
version: v0.33.1
commit: c4bfa95
Das \$ im grep verankert den Namen am
Zeilenende: sha256sum -c bekommt genau die eine Zeile für
deine Datei.
Fortschritt speichern? Kostenlos registrieren
Drill 2: kubectl passend zum Cluster
kubectl darf höchstens eine Minor-Version vom API-Server abweichen. Du nimmst genau die Version des Clusters.
# auf k0s-ctrl
K=v1.36.6
curl -sSfLO https://dl.k8s.io/release/$K/bin/linux/$ARCH/kubectl
curl -sSfLO https://dl.k8s.io/release/$K/bin/linux/$ARCH/kubectl.sha256
echo "$(cat kubectl.sha256) kubectl" | sha256sum -c
sudo install -m 755 kubectl /usr/local/bin/kubectl
kubectl version --clientErwartet:
kubectl: OK
Client Version: v1.36.6
Kustomize Version: v5.8.1
Auf dem Controller gäbe es auch sudo k0s kubectl. Das
läuft aber als root mit Admin-Rechten und nur dort. Für den Alltag ist
ein normales kubectl mit kubeconfig sauberer.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Das Gerüst von k0sctl init
# auf k0s-ctrl
k0sctl init --k0s -C 1 -i ~/.ssh/id_ed25519 [email protected] \
[email protected] [email protected] [email protected] > init.yaml
wc -l init.yaml
grep role: init.yaml
grep -A1 telemetry init.yaml
grep -c version: init.yamlErwartet:
88 init.yaml
role: controller
role: worker
role: worker
role: worker
telemetry:
enabled: true
0
-C 1 macht die erste Adresse zum Controller, alle
weiteren zu Workern. Das Gerüst schreibt jeden Standardwert aus – 88
Zeilen, die du nicht pflegen willst. Telemetrie ist an, und zwei Dinge
fehlen ganz: eine feste Version (0
Treffer) und die Zonen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Die eigene k0sctl.yaml
# auf k0s-ctrl
cat > k0sctl.yaml <<'EOF'
apiVersion: k0sctl.k0sproject.io/v1beta1
kind: Cluster
metadata:
name: k0s-lab
spec:
hosts:
- role: controller
ssh: {address: 172.16.0.176, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
- role: worker
ssh: {address: 172.16.0.186, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
installFlags: [--labels=topology.kubernetes.io/zone=a]
- role: worker
ssh: {address: 172.16.0.36, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
installFlags: [--labels=topology.kubernetes.io/zone=b]
- role: worker
ssh: {address: 172.16.0.72, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
installFlags: [--labels=topology.kubernetes.io/zone=a]
k0s:
version: v1.36.6+k0s.0
config:
apiVersion: k0s.k0sproject.io/v1beta1
kind: ClusterConfig
metadata:
name: k0s-lab
spec:
api:
address: 172.16.0.176
sans: [172.16.0.176]
network:
provider: kuberouter
podCIDR: 10.244.0.0/16
serviceCIDR: 10.96.0.0/12
telemetry:
enabled: false
EOFrole: controllerheißt Control Plane ohne Workloads.controller+workerlässt den Controller zusätzlich Pods tragen – für kleine Cluster gedacht, hier nicht gewollt.versionpinnt k0s. Ohne die Zeile nimmt k0sctl die neueste, und ein späteresapplyaktualisiert den Cluster ungefragt. Das Suffix+k0s.0gehört dazu.installFlagslanden in der systemd-Unit des Workers. Das Zonen-Label steht so nach jedem Start und jeder Neuregistrierung wieder am Node. Einkubectl labelhält das nicht (Tag 2).topology.kubernetes.io/zoneist das Standard-Label, das Scheduler und CSI-Treiber kennen. In LINSTOR setzt du die Zone an Tag 4 zusätzlich alsAux/zone.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Der Cluster entsteht
# auf k0s-ctrl
k0sctl apply --config k0sctl.yamlErwartet (gekürzt):
level=info msg="==> Running phase: Gather host facts"
level=info msg="172.16.0.72:22: detected amd64 architecture"
...
level=info msg="==> Running phase: Validate hosts"
level=info msg="validating clock skew"
...
level=info msg="172.16.0.72:22: downloading k0s v1.36.6+k0s.0"
...
level=info msg="==> Running phase: Initialize the k0s cluster"
level=info msg="172.16.0.176:22: installing k0s controller"
level=info msg="172.16.0.176:22: wait for kubernetes to reach ready state"
level=info msg="==> Running phase: Install workers"
level=info msg="172.16.0.176:22: generating a join token for worker 1"
...
level=info msg="172.16.0.186:22: waiting for node to become ready"
level=info msg="==> Finished in 2m38s"
level=info msg="k0s cluster version v1.36.6+k0s.0 is now installed"
k0sctl erkennt die Architektur jedes Hosts und lädt das passende k0s-Binary direkt dort herunter. Vorher prüft es die Uhrzeit aller Hosts – deshalb war NTP an Tag 0 wichtig.
Fortschritt speichern? Kostenlos registrieren
Drill 6: kubectl verbinden
# auf k0s-ctrl
mkdir -p ~/.kube
k0sctl kubeconfig --config k0sctl.yaml > ~/.kube/config
chmod 600 ~/.kube/config
grep server ~/.kube/config
kubectl get nodes -o wideErwartet (gekürzt):
server: https://172.16.0.176:6443
NAME STATUS ROLES AGE VERSION INTERNAL-IP ... CONTAINER-RUNTIME
k0s-w1 Ready <none> 50s v1.36.6+k0s 172.16.0.186 ... containerd://2.3.6
k0s-w2 Ready <none> 50s v1.36.6+k0s 172.16.0.36 ... containerd://2.3.6
k0s-w3 Ready <none> 50s v1.36.6+k0s 172.16.0.72 ... containerd://2.3.6
Drei Nodes, nicht vier: k0s-ctrl fehlt, und das ist
richtig so. Warte eine Minute, dann sind die Systempods bereit:
# auf k0s-ctrl
kubectl get pods -AErwartet:
NAMESPACE NAME READY STATUS RESTARTS AGE
kube-system coredns-7c5b856895-4dxld 1/1 Running 0 3m51s
kube-system coredns-7c5b856895-l4zk8 1/1 Running 0 3m51s
kube-system konnectivity-agent-4249z 1/1 Running 0 3m57s
kube-system konnectivity-agent-9rhdh 1/1 Running 0 3m57s
kube-system konnectivity-agent-hnlbn 1/1 Running 0 3m56s
kube-system kube-proxy-5brnr 1/1 Running 0 3m57s
kube-system kube-proxy-kl9cr 1/1 Running 0 3m57s
kube-system kube-proxy-vz59j 1/1 Running 0 3m57s
kube-system kube-router-b9zjl 1/1 Running 0 3m57s
kube-system kube-router-t9dhd 1/1 Running 0 3m57s
kube-system kube-router-zh4sq 1/1 Running 0 3m57s
kube-system metrics-server-5749cd655b-dpx5r 1/1 Running 0 4m1s
API-Server, Scheduler und etcd fehlen in der Liste. Sie laufen auf
k0s-ctrl als normale Prozesse unter systemd, nicht als
Pods. Direkt nach dem Aufbau siehst du kurz drei coredns-Pods: k0s
skaliert coredns um, sobald mehr als ein Node da ist.
Tipp:
kubectl -n kube-system wait --for=condition=Ready pod --allhängt hier bis zum Timeout, weil es auch auf den gerade gelöschten coredns-Pod wartet. Nimmkubectl get pods -Aoderrollout statusfür einzelne Deployments.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Auf den Hosts nachsehen
# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone
sudo k0s status
sudo k0s etcd member-list
ssh k0s-w1 sudo k0s statusErwartet (gekürzt):
NAME STATUS ROLES AGE VERSION ZONE
k0s-w1 Ready <none> 4m46s v1.36.6+k0s a
k0s-w2 Ready <none> 4m46s v1.36.6+k0s b
k0s-w3 Ready <none> 4m46s v1.36.6+k0s a
Version: v1.36.6+k0s.0
Process ID: 2604
Role: controller
Workloads: false
SingleNode: false
{"members":{"k0s-ctrl":"https://172.16.0.176:2380"}}
Version: v1.36.6+k0s.0
Process ID: 2551
Role: worker
Workloads: true
SingleNode: false
Kube-api probing successful: true
Workloads: false bestätigt: Auf dem Controller laufen
nie Pods. Ein einziges etcd-Mitglied heißt aber auch: Fällt
k0s-ctrl aus, laufen die Pods weiter, nur ändern kann
niemand mehr etwas. Wie drei Controller das lösen, steht an Tag 19.
Und noch einmal apply, ohne etwas zu ändern:
# auf k0s-ctrl
k0sctl apply --config k0sctl.yaml 2>&1 | grep -E 'phase|running k0s|Finished'Erwartet (gekürzt):
level=info msg="==> Running phase: Gather k0s facts"
level=info msg="172.16.0.176:22: is running k0s controller version v1.36.6+k0s.0"
level=info msg="172.16.0.186:22: is running k0s worker version v1.36.6+k0s.0"
...
level=info msg="==> Running phase: Run After Apply Hooks"
level=info msg="==> Running phase: Disconnect from hosts"
level=info msg="==> Finished in 9s"
Keine Install-Phase, nach neun Sekunden fertig. apply
ist idempotent: Du kannst es jederzeit gefahrlos laufen lassen.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig die Nodes mit ihrer Zone als eigene Spalte. Zeitziel: 15 s
- Zeig die k0s-Version auf
k0s-w2. Zeitziel: 15 s - Zeig alle Pods, die auf
k0s-w2laufen. Zeitziel: 30 s - Zeig, mit welcher API-Adresse kubectl spricht. Zeitziel: 20 s
Lösung
# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone
ssh k0s-w2 sudo k0s version
kubectl get pods -A -o wide --field-selector spec.nodeName=k0s-w2
kubectl config view -o jsonpath='{.clusters[0].cluster.server}{"\n"}'Erwartet (gekürzt):
...
v1.36.6+k0s.0
NAMESPACE NAME READY STATUS RESTARTS AGE ...
kube-system konnectivity-agent-9rhdh 1/1 Running 0 4m49s
kube-system kube-proxy-vz59j 1/1 Running 0 4m49s
kube-system kube-router-zh4sq 1/1 Running 0 4m49s
kube-system metrics-server-5749cd655b-dpx5r 1/1 Running 0 4m53s
https://172.16.0.176:6443
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zoneErwartet: drei Nodes Ready,
v1.36.6+k0s, Zonen a, b, a.
# auf k0s-ctrl
kubectl get pods -A --no-headers | grep -vc RunningErwartet: 0
# auf k0s-ctrl
sudo k0s status | grep -E 'Version|Workloads'Erwartet:
Version: v1.36.6+k0s.0
Workloads: false
Challenge
Starte ein Deployment spread mit vier Pause-Pods, die
sich gleichmäßig auf die beiden Zonen verteilen, und lösche es danach
wieder.
Hinweis: topologySpreadConstraints mit
dem Zonen-Label als topologyKey.
Lösung
# auf k0s-ctrl
cat > spread.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: spread, namespace: default}
spec:
replicas: 4
selector: {matchLabels: {app: spread}}
template:
metadata: {labels: {app: spread}}
spec:
topologySpreadConstraints:
- maxSkew: 1
topologyKey: topology.kubernetes.io/zone
whenUnsatisfiable: DoNotSchedule
labelSelector: {matchLabels: {app: spread}}
containers:
- name: pause
image: registry.k8s.io/pause:3.10
EOF
kubectl apply -f spread.yaml
kubectl rollout status deploy/spread --timeout=120s
kubectl get pods -l app=spread -o custom-columns=NODE:.spec.nodeName --no-headers \
| sort | uniq -cErwartet:
deployment.apps/spread created
...
deployment "spread" successfully rolled out
1 k0s-w1
2 k0s-w2
1 k0s-w3
Zwei Pods in Zone a (verteilt auf k0s-w1 und
k0s-w3), zwei in Zone b – dort gibt es nur
k0s-w2. Dieselbe Schieflage begegnet dir an Tag 12 wieder:
Zone b muss von jedem Volume eine Kopie tragen.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
# auf k0s-ctrl
kubectl delete deploy spreadInterview-Notiz
- Was unterscheidet k0s von kubeadm? Ein Binary ohne Abhängigkeiten, Control Plane als Prozesse unter systemd statt Static Pods, Controller standardmäßig ohne kubelet.
- Wie verteilst du k0s auf mehrere Hosts? Mit k0sctl und
einer deklarativen
k0sctl.yaml.applyist idempotent und dient auch für Erweiterung und Update. - Warum die Version pinnen? Ohne Pin zieht jedes
applydie neueste Version – ein ungeplantes Update mitten im Betrieb.
Enterprise-Notiz
- Drei Controller (etcd-Quorum) hinter einem Load Balancer oder mit
k0s Node-local Load Balancing. Mit externem Load Balancer zeigt
api.externalAddressauf dessen Adresse. k0sctl.yamlgehört ins Git, Änderungen per Review. Der SSH-Schlüssel des Automationshosts ist ein kritisches Geheimnis.- Air-Gap: k0sctl kann Binaries und Images vom Arbeitsplatz hochladen
(
uploadBinary, Airgap-Bundle) statt sie auf jedem Host herunterzuladen. - kubeconfig des Admins nicht verteilen. Für Menschen OIDC, für Automation eigene ServiceAccounts mit RBAC.