Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: k0s verstehen und verwalten

Ziel: Du weißt, welche Prozesse wo laufen, wo k0s seine Dateien ablegt, warum kubectl logs hängen kann, und du änderst die Konfiguration nur noch über k0sctl apply. · Dauer: ca. 45 min · Voraussetzung: Tag 1

Briefing

  • Pro Node ein systemd-Dienst: k0scontroller oder k0sworker. Alle Komponenten sind Kindprozesse, alle Logs stehen in dessen Journal.
  • Alles liegt unter /var/lib/k0s – auch das kubelet. Für CSI-Treiber ist das der wichtigste Unterschied zu anderen Distributionen.
  • konnectivity: Weil der Controller kein Node ist, bauen die Worker einen Tunnel zu ihm auf. logs, exec, port-forward und Metriken laufen hindurch.
  • Änderungen am Cluster gehören in k0sctl.yaml. Was du von Hand änderst, überschreibt k0s beim nächsten Neustart.
 kubectl get ──────────> kube-apiserver ──> etcd           (geht immer)
 kubectl logs/exec ────> kube-apiserver ──> konnectivity-server :8132
                                              ^ Tunnel von jedem Worker
                                              └─ konnectivity-agent ──> kubelet

Drill 1: Ein Dienst pro Node

# auf k0s-ctrl
mkdir -p ~/k0s-lab/tag02 && cd ~/k0s-lab/tag02
systemctl list-units 'k0s*' --no-legend
ps -eo comm --no-headers | sort -u | grep -E 'kube|etcd|konn'
ssh k0s-w1 "systemctl list-units 'k0s*' --no-legend"
ssh k0s-w1 "ps -eo comm --no-headers | sort -u | grep -E 'kubelet|containerd$'"
ssh k0s-w1 'systemctl cat k0sworker | grep ExecStart'

Erwartet (gekürzt):

  k0scontroller.service loaded active running k0s - Zero Friction Kubernetes
etcd
konnectivity-se
kube-apiserver
kube-controller
kube-scheduler
  k0sworker.service loaded active running k0s - Zero Friction Kubernetes
containerd
kubelet
ExecStart=/usr/local/bin/k0s worker --data-dir=/var/lib/k0s --labels=topology.kuber...
Node Dienst darunter
Controller k0scontroller etcd, kube-apiserver, Scheduler, Controller-Manager, konnectivity-server
Worker k0sworker containerd, kubelet; als Pods kube-proxy, kube-router, konnectivity-agent

Macht ein Node Ärger, fragst du zuerst systemd, nicht kubectl. Ein Worker mit gestopptem Dienst ist in Kubernetes nur NotReady – ohne Begründung.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Wo k0s seine Dateien ablegt

# auf k0s-ctrl
sudo ls /var/lib/k0s
sudo grep -A3 '^  api:' /etc/k0s/k0s.yaml
ssh k0s-w1 'sudo ls /var/lib/k0s; sudo ls /var/lib/k0s/kubelet | head -4'
ssh k0s-w1 'ls /var/lib/kubelet'

Erwartet (gekürzt):

bin
etcd
konnectivity.conf
manifests
pki
  api:
    address: 172.16.0.176
    sans:
    - 172.16.0.176
bin
containerd
images
kubelet
kubelet.conf
worker-profile.yaml
actuated_pods_state
allocated_pods_state
checkpoints
cpu_manager_state
device-plugins
Pfad Inhalt
/etc/k0s/k0s.yaml Cluster-Konfiguration auf dem Controller, von k0sctl geschrieben
/var/lib/k0s/pki, /var/lib/k0s/etcd Zertifikate und etcd-Daten – der Cluster-Zustand
/var/lib/k0s/kubelet Arbeitsverzeichnis des kubelets (nicht /var/lib/kubelet)
/var/lib/k0s/containerd Images und Container-Dateisysteme

/var/lib/kubelet gibt es trotzdem, aber nur mit device-plugins. Ein CSI-Treiber, der dort seinen Socket ablegt, findet also ein Verzeichnis und meldet keinen Fehler – das kubelet sucht aber woanders. An Tag 7 läufst du genau in diese Falle.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Werkzeuge im Binary

k0s bringt kubectl, ctr und einen Systemcheck mit. Auf den Nodes musst du nichts nachinstallieren.

# auf k0s-ctrl
sudo k0s kubectl get nodes
ssh k0s-w1 'sudo k0s ctr -n k8s.io images ls -q | head -3'
ssh k0s-w1 'sudo k0s sysinfo | head -4'
ssh k0s-w1 'sudo k0s sysinfo | grep -v "(pass)"'

Erwartet:

NAME     STATUS   ROLES    AGE   VERSION
k0s-w1   Ready    <none>   13m   v1.36.6+k0s
k0s-w2   Ready    <none>   13m   v1.36.6+k0s
k0s-w3   Ready    <none>   13m   v1.36.6+k0s
quay.io/k0sproject/apiserver-network-proxy-agent:v0.36.0-k0s.2
quay.io/k0sproject/apiserver-network-proxy-agent@sha256:f39f4e902eeef002c4e9f4d8c34...
quay.io/k0sproject/cni-node:v1.9.1-k0s.2
Total memory: 3.8 GiB (pass)
File system of /var/lib/k0s: ext4 (pass)
Disk space available for /var/lib/k0s: 24.4 GiB (pass)
Relative disk space available for /var/lib/k0s: 86% (pass)
      CONFIG_NF_CONNTRACK_IPV4: IPv4 connection tracking support (required for NAT)...
      CONFIG_NF_NAT_IPV4: IPv4 NAT: unknown (warning)
      CONFIG_NF_CONNTRACK_IPV6: IPv6 connection tracking support (required for NAT)...
      CONFIG_NF_NAT_IPV6: IPv6 NAT: unknown (warning)

k0s sysinfo ist der erste Befehl auf einem Node, der nicht starten will. Die vier Warnungen sind harmlos: Diese Kernel-Optionen gibt es seit Linux 4.19 bzw. 5.1 nicht mehr unter diesem Namen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Journal für alles

# auf k0s-ctrl
sudo journalctl -u k0scontroller --since -10min -o cat \
  | grep -o 'component=[a-z-]*' | sort | uniq -c | sort -rn | head -8

Erwartet (Zahlen schwanken):

   2243 component=grpc
    631 component=kube-apiserver
    428 component=kube-controller-manager
    244 component=konnectivity
    150 component=controller-runtime
     91 component=kube-scheduler
     77 component=etcd
     55 component=cfssl

Jede Zeile trägt component=. Damit filterst du das Journal nach API-Server, etcd oder konnectivity, ohne zu wissen, welcher Prozess gerade welche PID hat.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Wenn logs hängt

Je Worker hält ein konnectivity-agent eine Verbindung zu Port 8132 auf dem Controller. Du kappst sie mit einer Firewall-Regel und schaust, was noch geht.

# auf k0s-ctrl
sudo ss -tn state established '( sport = :8132 )' | tail -n +2 | wc -l
sudo iptables -I INPUT -p tcp --dport 8132 -j DROP
kubectl get nodes --no-headers | wc -l
kubectl -n kube-system logs ds/kube-router -c kube-router --tail=1 --request-timeout=20s

Erwartet:

3
3
Unable to connect to the server: context deadline exceeded (Client.Timeout exceeded...

get antwortet sofort, logs läuft nach 20 Sekunden in den Timeout. Die Meldung „Unable to connect to the server“ führt in die Irre: Der API-Server ist erreichbar, nur der Weg von ihm zum kubelet fehlt. Das Journal sagt es deutlicher:

# auf k0s-ctrl
sleep 30
sudo journalctl -u k0scontroller --since -1min -o cat | grep component=konnectivity \
  | grep -o 'No agent available' | uniq -c
kubectl -n kube-system get pods -l k8s-app=konnectivity-agent

Erwartet:

     22 No agent available
NAME                       READY   STATUS    RESTARTS   AGE
konnectivity-agent-4249z   1/1     Running   0          14m
konnectivity-agent-9rhdh   0/1     Running   0          14m
konnectivity-agent-hnlbn   0/1     Running   0          14m

Regel entfernen und warten:

# auf k0s-ctrl
sudo iptables -D INPUT -p tcp --dport 8132 -j DROP
sleep 15
kubectl -n kube-system get pods -l k8s-app=konnectivity-agent
kubectl -n kube-system logs ds/kube-router -c kube-router --tail=1 | cut -c1-60

Erwartet (gekürzt):

NAME                       READY   STATUS    RESTARTS   AGE
konnectivity-agent-4249z   1/1     Running   0          15m
konnectivity-agent-9rhdh   1/1     Running   0          15m
konnectivity-agent-hnlbn   1/1     Running   0          15m
I1119 23:52:31.283921    3076 bgp_policies.go:991] Ensuring t...

Nach rund zehn Sekunden sind die Tunnel wieder da. Dasselbe Bild siehst du nach jedem Neustart des Controllers, bis sich alle Agents neu verbunden haben.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Handarbeit hält nicht

# auf k0s-ctrl
kubectl label node k0s-w3 topology.kubernetes.io/zone=b --overwrite
kubectl get node k0s-w3 -L topology.kubernetes.io/zone
ssh k0s-w3 sudo systemctl restart k0sworker
sleep 30
kubectl get node k0s-w3 -L topology.kubernetes.io/zone

Erwartet:

node/k0s-w3 labeled
NAME     STATUS   ROLES    AGE   VERSION       ZONE
k0s-w3   Ready    <none>   15m   v1.36.6+k0s   b
NAME     STATUS   ROLES    AGE   VERSION       ZONE
k0s-w3   Ready    <none>   16m   v1.36.6+k0s   a

Beim Start setzt das kubelet die Labels aus --labels neu. Dein kubectl label hat nur bis zum nächsten Neustart gehalten. Bei einer Zone ist das gefährlich: Placement und Topologie würden zwischen zwei Neustarts etwas anderes glauben als LINSTOR.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Konfiguration über k0sctl ändern

Für Speicher-Nodes lohnt sich Graceful Node Shutdown: Beim Herunterfahren beendet das kubelet erst die Pods, damit DRBD sauber freigeben kann. Diese Einstellung gehört in die kubelet-Konfiguration. k0s verteilt sie als Worker-Profil.

# auf k0s-ctrl
cp ../tag01/k0sctl.yaml .
sed -i 's|zone=\([ab]\)\]|zone=\1, --profile=storage]|' k0sctl.yaml
cat >> k0sctl.yaml <<'EOF'
        workerProfiles:
        - name: storage
          values:
            shutdownGracePeriod: 60s
            shutdownGracePeriodCriticalPods: 20s
EOF
diff ../tag01/k0sctl.yaml k0sctl.yaml

Erwartet:

11c11
<     installFlags: [--labels=topology.kubernetes.io/zone=a]
---
>     installFlags: [--labels=topology.kubernetes.io/zone=a, --profile=storage]
14c14
...
34a35,39
>         workerProfiles:
>         - name: storage
>           values:
>             shutdownGracePeriod: 60s
>             shutdownGracePeriodCriticalPods: 20s

Erst schauen, was passieren würde:

# auf k0s-ctrl
k0sctl apply --config k0sctl.yaml --dry-run 2>&1 | grep dry-run: | cut -c1-80

Erwartet (gekürzt):

dry-run:  - restart the k0s service
dry-run: * 172.16.0.186:22 :
dry-run:  - reinstall k0s using `k0s install worker --labels=topology.kubernetes...
dry-run:  - restart k0s service
...

Controller neu starten, alle Worker neu installieren. Auf einem großen Cluster willst du das nicht auf allen Workern gleichzeitig, also einer nach dem anderen:

# auf k0s-ctrl
k0sctl apply --config k0sctl.yaml --concurrency 1 2>&1 \
  | grep -E 'Reinstall|reinstalling'
kubectl get --raw /api/v1/nodes/k0s-w1/proxy/configz | python3 -m json.tool \
  | grep shutdownGrace
ssh k0s-w1 'systemd-inhibit --list --no-pager | grep -c kubelet'

Erwartet:

level=info msg="==> Running phase: Reinstall"
level=info msg="Reinstalling max 1 workers in parallel"
level=info msg="172.16.0.186:22: reinstalling k0s"
level=info msg="172.16.0.36:22: reinstalling k0s"
level=info msg="172.16.0.72:22: reinstalling k0s"
        "shutdownGracePeriod": "1m0s",
        "shutdownGracePeriodCriticalPods": "20s",
0

Die Konfiguration ist angekommen, aber das kubelet hat keine Shutdown-Sperre bei systemd-logind angemeldet. Ohne sie wartet beim Herunterfahren niemand auf die Pods.

# auf k0s-ctrl
ssh k0s-w1 'sudo journalctl -u k0sworker -o cat' \
  | grep -o 'Failed to start node shut.*' | cut -c1-88
ssh k0s-w1 'systemd-analyze cat-config systemd/logind.conf \
  | grep -E "^# /.*conf$|^Inhibit"'

Erwartet (gekürzt):

Failed to start node shutdown manager\" err=\"node shutdown manager was timed out af...
# /etc/systemd/logind.conf
# /etc/systemd/logind.conf.d/99-kubelet.conf
InhibitDelayMaxSec=60
# /usr/lib/systemd/logind.conf.d/unattended-upgrades-logind-maxdelay.conf
InhibitDelayMaxSec=30

Das kubelet hat seine 60 Sekunden in 99-kubelet.conf geschrieben. systemd liest die Drop-ins aber nach Dateinamen sortiert über alle Verzeichnisse hinweg, und unattended-upgrades-… kommt nach 99-…. Gewonnen haben die 30 Sekunden aus dem Paket unattended-upgrades, und das kubelet gibt auf. Eine eigene Datei, die zuletzt sortiert, löst das:

# auf k0s-w1
sudo tee /etc/systemd/logind.conf.d/zz-kubelet.conf >/dev/null <<'EOF'
[Login]
InhibitDelayMaxSec=60
EOF
sudo systemctl restart systemd-logind
sudo systemctl restart k0sworker
sleep 25
systemd-inhibit --list --no-pager | grep kubelet

Erwartet (gekürzt):

kubelet                      0   root 6348 kubelet         shutdown Kubelet needs ti...

Wiederhole das auf k0s-w2 und k0s-w3. Ab jetzt ist ~/k0s-lab/tag02/k0sctl.yaml die gültige Cluster-Beschreibung. Die logind-Datei gehört nicht in k0sctl, sondern in die Host-Vorbereitung – an Tag 16 übernimmt sie Ansible.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, seit wann k0scontroller läuft. Zeitziel: 20 s
  2. Zeig die letzten fünf Journalzeilen von k0sworker auf k0s-w2. Zeitziel: 20 s
  3. Zähl die laufenden Container auf k0s-w1 mit containerd-Mitteln. Zeitziel: 30 s
  4. Zeig die Shutdown-Einstellungen aus der laufenden kubelet-Konfiguration von k0s-w2. Zeitziel: 40 s

Lösung

# auf k0s-ctrl
systemctl show -p ActiveEnterTimestamp k0scontroller
ssh k0s-w2 'sudo journalctl -u k0sworker -n 5 --no-pager -o cat'
ssh k0s-w1 'sudo k0s ctr -n k8s.io tasks ls | grep -c RUNNING'
kubectl get --raw /api/v1/nodes/k0s-w2/proxy/configz | python3 -m json.tool \
  | grep -i shutdownGrace

Erwartet (gekürzt):

ActiveEnterTimestamp=Fri 2026-11-20 00:01:15 UTC
time="2026-11-20 00:06:02" level=info msg="I1120 00:06:02.951511    6402 prober.go:1...
...
8
        "shutdownGracePeriod": "1m0s",
        "shutdownGracePeriodCriticalPods": "20s",

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone

Erwartet: drei Nodes Ready, Zonen a, b, a.

# auf k0s-ctrl
for h in k0s-w1 k0s-w2 k0s-w3; do
  ssh $h 'systemd-inhibit --list | grep -c kubelet'
done

Erwartet: dreimal 1.

# auf k0s-ctrl
sudo iptables -S INPUT

Erwartet: nur -P INPUT ACCEPT – die Regel aus Drill 5 ist weg.

# auf k0s-ctrl
kubectl -n kube-system get pods -l k8s-app=konnectivity-agent --no-headers | grep -c 1/1

Erwartet: 3

Challenge

Stopp den Dienst auf k0s-w3 und miss, wie lange Kubernetes braucht, bis der Node NotReady ist. Finde heraus, ob die Container auf k0s-w3 dabei weiterlaufen. Starte den Dienst danach wieder.

Hinweis: Das Journal von k0sworker sagt beim Stoppen, was übrig bleibt.

Lösung

# auf k0s-ctrl
ssh k0s-w3 sudo systemctl stop k0sworker
s=$(date +%s)
until kubectl get node k0s-w3 --no-headers | grep -q NotReady; do sleep 2; done
echo "NotReady nach $(( $(date +%s) - s ))s"
ssh k0s-w3 'sudo journalctl -u k0sworker -n 3 --no-pager -o cat'
ssh k0s-w3 sudo systemctl start k0sworker

Erwartet:

NotReady nach 50s
k0sworker.service: Unit process 3508 (containerd-shim) remains running after unit st...
Stopped k0sworker.service - k0s - Zero Friction Kubernetes.
k0sworker.service: Consumed 8.099s CPU time, 739.7M memory peak, 0B memory swap peak.

Nach 50 Sekunden (node-monitor-grace-period) markiert der Controller den Node als NotReady. Die Container laufen weiter: Die containerd-shim-Prozesse überleben das Stoppen des Dienstes. Für Speicher heißt das: Ein gestoppter Worker hält seine Volumes weiter offen und schreibt womöglich noch. NotReady ist kein Beweis, dass ein Node tot ist – das wird an Tag 10 wichtig. Nach dem Start ist k0s-w3 in wenigen Sekunden wieder Ready.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • kubectl get geht, kubectl logs hängt – woran liegt es? Am Weg vom API-Server zum kubelet. Bei k0s ist das konnectivity: Agents prüfen, Port 8132 am Controller, Journal mit component=konnectivity.
  • Wo ist das kubelet-Verzeichnis bei k0s? /var/lib/k0s/kubelet. CSI-Treiber und Backup-Agents müssen darauf eingestellt werden.
  • Wie änderst du die kubelet-Konfiguration? Über Worker-Profile in k0sctl.yaml und k0sctl apply, bei vielen Nodes mit --concurrency.

Enterprise-Notiz

  • Graceful Node Shutdown auf allen Nodes mit Datenbanken. Prüfe die Sperre mit systemd-inhibit --list – eine stille Fehlkonfiguration wie hier fällt sonst erst beim nächsten Wartungsfenster auf.
  • Journal zentral sammeln (Loki, Elastic), denn ein Dienst bündelt alle Komponenten.
  • Firewalls zwischen Workern und Controllern: 6443 (API), 8132 (konnectivity), 9443 (Join). Fehlt 8132, fallen zuerst logs, exec und Metriken aus.
  • Änderungen an k0sctl.yaml per Pull-Request, --dry-run im Review mitliefern.