Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Knoten

Ziel: Du erkennst, wann ein Fehler im Knoten statt im Pod steckt, untersuchst Kubelet und Runtime auf dem Knoten und kennst die Fristen, nach denen Kubernetes Pods eines ausgefallenen Knotens ersetzt. · Dauer: ca. 75 min · Voraussetzung: Tag 13

Briefing

  • Das Kubelet meldet sich über ein Lease in kube-node-lease. Bleibt es 50 s aus, setzt der Controller-Manager die Conditions auf Unknown und einen Taint.
  • Unknown heißt: Das Kubelet schweigt. False heißt: Es läuft und meldet selbst ein Problem.
  • Pods dulden einen unerreichbaren Knoten 300 s lang, dann werden sie zum Löschen markiert – und hängen in Terminating, bis das Kubelet zurück ist.
Fehlerbild Symptom Wo die Antwort steht
Kubelet läuft nicht Knoten NotReady Lease, Journal, kubelet.log
Knotenausfall Ersatz erst nach ~6 min Taints, Tolerations
Lokaler Speicher voll Evicted, immer neue Pods .status.message
Drain hängt Cannot evict pod ALLOWED DISRUPTIONS

Achtung: Heute stoppst du rke2-agent auf worker2. Die Container laufen weiter, aber der Knoten ist für Kubernetes weg. Jeder Drill, der ihn stoppt, startet ihn am Ende wieder.

Drill 1: Der Werkzeugkasten

Auf einem RKE2-Knoten sind Kubelet und containerd Kindprozesse von rke2-agent (auf cp1: rke2-server). Die vier Fragen an einen Knoten:

# auf cp1
mkdir -p ~/debug/tag14 && cd ~/debug/tag14
ssh -n worker2 systemctl status rke2-agent --no-pager | sed -n '1,3p;8,9p' \
  | cut -c1-80
ssh -n worker2 sudo journalctl -u rke2-agent -b --no-pager | tail -2 | cut -c1-88
ssh -n worker2 sudo grep '^E' /var/lib/rancher/rke2/agent/logs/kubelet.log \
  | tail -1 | cut -c1-88
ssh -n worker2 sudo -i crictl info | jq -c '.status.conditions[] | {type, status}'

Erwartet (gekürzt):

● rke2-agent.service - Rancher Kubernetes Engine v2 (agent)
     Loaded: loaded (/usr/local/lib/systemd/system/rke2-agent.service; enabled;
     Active: active (running) since Fri 2026-11-20 11:07:38 UTC; 3min 1s ago
   Main PID: 156459 (rke2)
      Tasks: 156
Nov 20 11:07:38 worker2 rke2[156459]: time="2026-11-20T11:07:38Z" level=info msg="rke2 a
Nov 20 11:07:38 worker2 systemd[1]: Started rke2-agent.service - Rancher Kubernetes Engi
E1120 11:07:25.187534  156608 remote_runtime.go:657] "ContainerStatus from runtime servi
{"type":"RuntimeReady","status":true}
{"type":"NetworkReady","status":true}
{"type":"ContainerdHasNoDeprecationWarnings","status":true}

Dienst, Journal, Kubelet-Log als Datei und die Runtime. Einzelne E-Zeilen im Kubelet-Log sind normal; zählen tut, was zur Uhrzeit des Problems passt.

Die laufende Kubelet-Konfiguration liefert der API-Server, ganz ohne SSH:

# auf cp1
kubectl get --raw /api/v1/nodes/worker2/proxy/configz \
  | jq -c '.kubeletconfig | {evictionHard, nodeStatusUpdateFrequency, maxPods}'

Erwartet:

{"evictionHard":{"imagefs.available":"5%","nodefs.available":"5%"},
  "nodeStatusUpdateFrequency":"10s","maxPods":110}

RKE2 setzt beide Schwellen auf 5 % – Kubernetes selbst nimmt 10 % (nodefs) und 15 % (imagefs); wer im Internet nachliest, findet andere Zahlen. memory.available (Kubernetes-Standard 100Mi) fehlt ganz: Wer einzelne harte Schwellen setzt, verliert laut Kubernetes-Doku die übrigen Standardwerte. Auf RKE2 räumt das Kubelet deshalb nicht wegen knappen Arbeitsspeichers – das erledigt erst der OOM-Killer.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Knoten wird NotReady

Einbauen:

Achtung: systemctl stop rke2-agent nimmt den Knoten aus dem Cluster. Nur im Labor.

# auf cp1
ssh -n worker2 sudo systemctl stop rke2-agent

Symptom: Zeit und Lease alle 10 Sekunden:

# auf cp1
for i in $(seq 7); do
  echo "$(date +%T) $(kubectl get node worker2 --no-headers | awk '{print $2}')" \
    "$(kubectl -n kube-node-lease get lease worker2 -o jsonpath='{.spec.renewTime}')"
  sleep 10
done

Erwartet:

11:10:54 Ready 2026-11-20T11:10:46.265098Z
11:11:04 Ready 2026-11-20T11:10:46.265098Z
11:11:15 Ready 2026-11-20T11:10:46.265098Z
11:11:26 Ready 2026-11-20T11:10:46.265098Z
11:11:36 Ready 2026-11-20T11:10:46.265098Z
11:11:47 NotReady 2026-11-20T11:10:46.265098Z
11:11:57 NotReady 2026-11-20T11:10:46.265098Z

Das Lease wird nicht mehr erneuert; rund 50 Sekunden später (node-monitor-grace-period) kippt der Status.

Untersuchen:

# auf cp1
kubectl describe node worker2 | grep -A1 '^Taints'
J='{range .status.conditions[*]}{.type} {.status} {.reason}{"\n"}{end}'
kubectl get node worker2 -o jsonpath="$J"
ssh -n worker2 systemctl is-active rke2-agent
ssh -n worker2 sudo journalctl -u rke2-agent -b --no-pager | grep Stopped | tail -1 \
  | cut -c1-88

Erwartet:

Taints:             node.kubernetes.io/unreachable:NoExecute
                    node.kubernetes.io/unreachable:NoSchedule
NetworkUnavailable False FlannelIsUp
MemoryPressure Unknown NodeStatusUnknown
DiskPressure Unknown NodeStatusUnknown
PIDPressure Unknown NodeStatusUnknown
Ready Unknown NodeStatusUnknown
inactive
Nov 20 11:10:51 worker2 systemd[1]: Stopped rke2-agent.service - Rancher Kubernetes Engi

Ursache: Das Kubelet läuft nicht, weil jemand rke2-agent gestoppt hat (Stopped im Journal; ein Absturz hätte einen Exit-Code und Neustarts). Ohne Kubelet erneuert niemand das Lease; der Node-Lifecycle-Controller setzt Unknown und den Taint unreachable. NetworkUnavailable False stammt von Canal, nicht vom Kubelet – es bleibt stehen. kubectl debug node/worker2 hilft hier nicht: Den Debug-Pod müsste genau dieses Kubelet starten.

Fix:

# auf cp1
ssh -n worker2 sudo systemctl start rke2-agent

Nachweis:

# auf cp1
kubectl wait --for=condition=Ready node/worker2 --timeout=120s
kubectl describe node worker2 | grep '^Taints'

Erwartet:

node/worker2 condition met
Taints:             <none>

Fortschritt speichern? Kostenlos registrieren

Drill 3: Pods hängen nach dem Ausfall

Einbauen: Zwei web-Pods, die bevorzugt auf worker2 laufen:

# auf cp1
kubectl create namespace tag14
cat > web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag14}
spec:
  replicas: 2
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            preference:
              matchExpressions:
              - {key: kubernetes.io/hostname, operator: In, values: [worker2]}
      containers:
      - name: web
        image: traefik/whoami:v1.11
EOF
kubectl apply -f web.yaml
kubectl -n tag14 rollout status deploy/web
kubectl -n tag14 get pod -l app=web -o jsonpath='{.items[0].spec.tolerations}' \
  | jq -c '.[]'

Erwartet (Zeilen umbrochen):

namespace/tag14 created
deployment.apps/web created
deployment "web" successfully rolled out
{"effect":"NoExecute","key":"node.kubernetes.io/not-ready","operator":"Exists",
  "tolerationSeconds":300}
{"effect":"NoExecute","key":"node.kubernetes.io/unreachable","operator":"Exists",
  "tolerationSeconds":300}

Im Manifest steht keine Toleration – beide ergänzt das Admission-Plugin DefaultTolerationSeconds.

Symptom: Der Knoten fällt aus, du schaust nach zwei Minuten nach.

Achtung: Der nächste Block stoppt worker2 wieder; der Drill dauert insgesamt sechs Minuten.

# auf cp1
ssh -n worker2 sudo systemctl stop rke2-agent
sleep 120
kubectl -n tag14 get pods -o wide | cut -c1-80

Erwartet: worker2 ist längst NotReady, die Pods sind angeblich gesund:

NAME                   READY   STATUS    RESTARTS   AGE    IP            NODE
web-57764fdd87-2l7mv   1/1     Running   0          2m7s   10.42.2.120   worker2
web-57764fdd87-9fms4   1/1     Running   0          2m7s   10.42.2.119   worker2

Vier Minuten später:

# auf cp1
sleep 240
kubectl -n tag14 get pods -o wide | cut -c1-80

Erwartet:

NAME                   READY   STATUS        RESTARTS   AGE     IP            NODE
web-57764fdd87-2l7mv   1/1     Terminating   0          6m10s   10.42.2.120   worker2
web-57764fdd87-9fms4   1/1     Terminating   0          6m10s   10.42.2.119   worker2
web-57764fdd87-f8v7n   1/1     Running       0          9s      10.42.0.157   cp1
web-57764fdd87-z8whd   1/1     Running       0          9s      10.42.1.120   worker1

Untersuchen: Pod-Namen aus deiner Ausgabe übernehmen:

# auf cp1
kubectl -n tag14 events --for pod/web-57764fdd87-2l7mv | tail -2 | tr -s ' ' \
  | cut -c1-88

Erwartet:

5m13s Warning NodeNotReady Pod/web-57764fdd87-2l7mv Node is not ready
13s Normal TaintManagerEviction Pod/web-57764fdd87-2l7mv Marking for deletion Pod tag14/

Ursache: 50 s bis NotReady, dann 300 s Toleration: Erst nach knapp sechs Minuten markiert der Taint-Eviction-Controller die Pods zum Löschen. Bestätigen kann das nur das Kubelet von worker2 – also hängen sie in Terminating. Den Ersatz startet der ReplicaSet-Controller trotzdem, weil er Pods mit deletionTimestamp nicht mehr mitzählt. Die Wartezeit ist Absicht: Kubernetes kann einen toten Knoten nicht von einer Netzstörung unterscheiden; bei einem StatefulSet entsteht deshalb gar kein Ersatz, bis der alte Pod wirklich weg ist.

Fix: Knoten zurückholen; danach bekommt der zustandslose web eine kürzere Frist:

# auf cp1
ssh -n worker2 sudo systemctl start rke2-agent
kubectl wait --for=condition=Ready node/worker2 --timeout=120s
sleep 15
kubectl -n tag14 get pods -l app=web | grep -c Terminating
cat >> web.yaml <<'EOF'
      tolerations:
      - {key: node.kubernetes.io/unreachable, operator: Exists, effect: NoExecute,
         tolerationSeconds: 30}
      - {key: node.kubernetes.io/not-ready, operator: Exists, effect: NoExecute,
         tolerationSeconds: 30}
EOF
kubectl apply -f web.yaml
kubectl -n tag14 rollout status deploy/web

Erwartet (gekürzt):

node/worker2 condition met
0
deployment.apps/web configured
deployment "web" successfully rolled out

Nachweis: Derselbe Ausfall, jetzt mit Stoppuhr:

# auf cp1
sleep 10
kubectl -n tag14 get pods -l app=web -o wide | cut -c1-80
ssh -n worker2 sudo systemctl stop rke2-agent
T0=$(date +%s)
until kubectl -n tag14 get pods -l app=web | grep -q Terminating; do sleep 2; done
echo "Ersatz nach $(( $(date +%s) - T0 )) s"
ssh -n worker2 sudo systemctl start rke2-agent
kubectl wait --for=condition=Ready node/worker2 --timeout=120s

Erwartet (gekürzt):

NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
web-846654ffcc-h6fhz   1/1     Running   0          17s   10.42.2.121   worker2
web-846654ffcc-nm4r9   1/1     Running   0          15s   10.42.2.122   worker2
Ersatz nach 94 s
node/worker2 condition met

50 s ab der letzten Lease-Erneuerung (bis zu 10 s vor dem Stopp) plus 30 s Toleration plus der Takt der Controller – je nach Lauf 75 bis 95 Sekunden statt sechs Minuten. Steht die Toleration schon im Manifest, ergänzt der API-Server keine eigene.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Pods werden evicted

Einbauen: Ein Pod schreibt 200 MiB in ein emptyDir, erlaubt sind 100 MiB lokaler Speicher (ephemeral-storage) – ohne dass der Knoten selbst voll wäre:

# auf cp1
cat > fueller.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: fueller, namespace: tag14}
spec:
  replicas: 1
  selector: {matchLabels: {app: fueller}}
  template:
    metadata: {labels: {app: fueller}}
    spec:
      nodeSelector: {kubernetes.io/hostname: worker1}
      containers:
      - name: fueller
        image: busybox:1.37
        command:
        - sh
        - -c
        - dd if=/dev/zero of=/daten/block bs=1M count=200; sleep infinity
        resources: {limits: {ephemeral-storage: 100Mi}}
        volumeMounts: [{name: daten, mountPath: /daten}]
      volumes:
      - {name: daten, emptyDir: {}}
EOF
kubectl apply -f fueller.yaml

Symptom (nach etwa zwei Minuten):

# auf cp1
sleep 120
kubectl -n tag14 get pods -l app=fueller

Erwartet:

NAME                       READY   STATUS    RESTARTS   AGE
fueller-6cd6db4c95-475sz   1/1     Running   0          25s
fueller-6cd6db4c95-pfvdp   0/1     Error     0          90s
fueller-6cd6db4c95-vqjmq   0/1     Error     0          2m3s

Immer neue Pods, die alten bleiben liegen. Je nach Zeitpunkt steht dort auch ContainerStatusUnknown.

Untersuchen: STATUS zeigt den Container. Der Grund steht im Pod-Status:

# auf cp1
kubectl -n tag14 get pods -l app=fueller \
  -o custom-columns=NAME:.metadata.name,PHASE:.status.phase,REASON:.status.reason
kubectl -n tag14 get pods -l app=fueller --field-selector=status.phase=Failed \
  -o jsonpath='{.items[0].status.message}{"\n"}'

Erwartet:

NAME                       PHASE     REASON
fueller-6cd6db4c95-475sz   Running   <none>
fueller-6cd6db4c95-pfvdp   Failed    Evicted
fueller-6cd6db4c95-vqjmq   Failed    Evicted
Pod ephemeral local storage usage exceeds the total limit of containers 100Mi.

Ursache: Das emptyDir liegt auf der Platte des Knotens und zählt zum lokalen Speicher des Pods. Der Eviction-Manager des Kubelets beendet den Pod ohne Schonfrist; ein evicted Pod startet nicht neu, er bleibt Failed stehen, und das Deployment legt einen neuen an, der dasselbe tut. Bei echter Knotennot lautete die Meldung The node was low on resource: ephemeral-storage., und am Knoten stünde DiskPressure=True. Den Fall mit sizeLimit am Volume kennst du aus Tag 10.

Fix: Limit auf den Bedarf, das Volume zusätzlich begrenzen, Reste wegräumen:

# auf cp1
sed -i 's/ephemeral-storage: 100Mi/ephemeral-storage: 300Mi/' fueller.yaml
sed -i 's/emptyDir: {}/emptyDir: {sizeLimit: 250Mi}/' fueller.yaml
kubectl apply -f fueller.yaml
kubectl -n tag14 rollout status deploy/fueller
kubectl -n tag14 delete pods --field-selector=status.phase=Failed

Nachweis (nach einer Minute):

# auf cp1
sleep 60
kubectl -n tag14 get pods -l app=fueller

Erwartet:

NAME                       READY   STATUS    RESTARTS   AGE
fueller-795b88576b-6gqr8   1/1     Running   0          65s

Evicted Pods räumt sonst erst der Pod-Garbage-Collector weg – ab 1000 beendeten Pods (RKE2-Wert von terminated-pod-gc-threshold im Controller-Manager, Kubernetes-Standard 12 500).

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Drain hängt

Einbauen: Zwei api-Pods bevorzugt auf worker1 und ein PodDisruptionBudget, das „sicherheitshalber“ beide verlangt:

# auf cp1
kubectl -n tag14 delete deploy fueller
cat > api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: api, namespace: tag14}
spec:
  replicas: 2
  selector: {matchLabels: {app: api}}
  template:
    metadata: {labels: {app: api}}
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            preference:
              matchExpressions:
              - {key: kubernetes.io/hostname, operator: In, values: [worker1]}
      containers:
      - name: api
        image: traefik/whoami:v1.11
---
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata: {name: api, namespace: tag14}
spec:
  minAvailable: 2
  selector: {matchLabels: {app: api}}
EOF
kubectl apply -f api.yaml
kubectl -n tag14 rollout status deploy/api

Symptom:

# auf cp1
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data --timeout=30s 2>&1 \
  | grep -E 'cordoned|api|timeout' | cut -c1-88 | sort | uniq -c

Erwartet (gekürzt):

      6 error when evicting pods/"api-599cf68b74-dznbc" -n "tag14" (will retry after 5s
      1 error when evicting pods/"api-599cf68b74-dznbc" -n "tag14": global timeout reach
      6 error when evicting pods/"api-599cf68b74-qgknb" -n "tag14" (will retry after 5s
      1 error when evicting pods/"api-599cf68b74-qgknb" -n "tag14": global timeout reach
      7 evicting pod tag14/api-599cf68b74-dznbc
      7 evicting pod tag14/api-599cf68b74-qgknb
      1 node/worker1 cordoned

Alle fünf Sekunden derselbe Versuch, bis der Timeout greift; die vollständige Meldung endet mit Cannot evict pod as it would violate the pod's disruption budget.

Untersuchen:

# auf cp1
kubectl -n tag14 get pdb api
kubectl get node worker1

Erwartet:

NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
api    2               N/A               0                     39s
NAME      STATUS                     ROLES    AGE     VERSION
worker1   Ready,SchedulingDisabled   <none>   4h52m   v1.37.2+rke2r1

Ursache: minAvailable: 2 bei zwei Replikas erlaubt null freiwillige Unterbrechungen; die Eviction-API antwortet mit 429, kubectl drain versucht es endlos weiter. Und der abgebrochene Drain hat den Knoten gecordont zurückgelassen – neue Pods landen dort nie, ohne dass ein Fehler erscheint.

Fix:

# auf cp1
sed -i 's/minAvailable: 2/maxUnavailable: 1/' api.yaml
kubectl apply -f api.yaml
kubectl -n tag14 get pdb api
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data --timeout=120s 2>&1 \
  | grep -E 'drained|evicted'
kubectl uncordon worker1

Erwartet (gekürzt):

deployment.apps/api unchanged
poddisruptionbudget.policy/api configured
NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
api    N/A             1                 1                     44s
pod/api-599cf68b74-qgknb evicted
pod/api-599cf68b74-dznbc evicted
node/worker1 drained
node/worker1 uncordoned

Nachweis:

# auf cp1
kubectl get nodes
kubectl -n tag14 get pods -l app=api -o wide | cut -c1-80

Erwartet:

NAME      STATUS   ROLES                AGE     VERSION
cp1       Ready    control-plane,etcd   4h55m   v1.37.2+rke2r1
worker1   Ready    <none>               4h52m   v1.37.2+rke2r1
worker2   Ready    <none>               4h51m   v1.37.2+rke2r1
NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE
api-599cf68b74-mbxm5   1/1     Running   0          11s   10.42.2.126   worker2
api-599cf68b74-q5hxq   1/1     Running   0          5s    10.42.0.159   cp1

Der Drain wirft auch andere Pods von worker1 – im Labor etwa CoreDNS oder Kyverno-Controller. Sie ziehen um; nach uncordon kommen sie nicht von selbst zurück.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig für alle Knoten, wann ihr Lease zuletzt erneuert wurde. Zeitziel: 30 s
  2. Zeig die Taints aller Knoten in einer Tabelle. Zeitziel: 30 s
  3. Finde alle evicted Pods im ganzen Cluster. Zeitziel: 30 s
  4. Zeig maxPods des Kubelets auf worker1, ohne dich anzumelden. Zeitziel: 30 s

Lösung

# auf cp1
kubectl -n kube-node-lease get lease \
  -o custom-columns=NAME:.metadata.name,RENEW:.spec.renewTime
kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
kubectl get pods -A --field-selector=status.phase=Failed \
  -o custom-columns=NS:.metadata.namespace,NAME:.metadata.name,REASON:.status.reason
kubectl get --raw /api/v1/nodes/worker1/proxy/configz | jq .kubeletconfig.maxPods

Erwartet:

NAME      RENEW
cp1       2026-11-20T11:26:35.670313Z
worker1   2026-11-20T11:26:31.395700Z
worker2   2026-11-20T11:26:32.608976Z
NAME      TAINTS
cp1       <none>
worker1   <none>
worker2   <none>
NS    NAME   REASON
110

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf cp1
kubectl get nodes
kubectl -n tag14 get pdb
kubectl -n tag14 get deploy

Erwartet:

NAME      STATUS   ROLES                AGE     VERSION
cp1       Ready    control-plane,etcd   4h55m   v1.37.2+rke2r1
worker1   Ready    <none>               4h52m   v1.37.2+rke2r1
worker2   Ready    <none>               4h51m   v1.37.2+rke2r1
NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
api    N/A             1                 1                     63s
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
api    2/2     2            2           63s
web    2/2     2            2           13m

Challenge

Ein Kollege hat auf worker2 das Pod-Limit des Kubelets erhöht und den Agenten neu gestartet. Seitdem ist der Knoten NotReady, obwohl systemctl den Dienst als active (running) meldet. Finde die Ursache und repariere sie.

# auf cp1
ssh -n worker2 sudo mkdir -p /etc/rancher/rke2/config.yaml.d
echo 'kubelet-arg: [max-pod=150]' \
  | ssh worker2 sudo tee /etc/rancher/rke2/config.yaml.d/90-kaputt.yaml
ssh -n worker2 sudo systemctl restart rke2-agent

Hinweis: Der Dienst ist rke2-agent – das Kubelet ist nur ein Kindprozess.

Lösung

Nach etwa einer Minute:

# auf cp1
sleep 60
kubectl get node worker2
ssh -n worker2 systemctl is-active rke2-agent
ssh -n worker2 sudo journalctl -u rke2-agent -b --since -2min --no-pager \
  | grep 'Kubelet exited' | tail -1 | cut -c1-88
L=/var/lib/rancher/rke2/agent/logs/kubelet.log
ssh -n worker2 "sudo grep 'command failed' $L" | tail -1 | cut -c1-120

Erwartet (Zeile umbrochen):

NAME      STATUS     ROLES    AGE     VERSION
worker2   NotReady   <none>   4h56m   v1.37.2+rke2r1
active
Nov 20 11:32:08 worker2 rke2[170810]: time="2026-11-20T11:32:08Z" level=error msg="Kubel
E1120 11:32:13.611217  171561 run.go:72] "command failed" err="failed to parse kubelet
  flag: unknown flag: --max-pod"

rke2-agent läuft und startet das Kubelet alle fünf Sekunden neu (Kubelet exited: exit status 1), das Kubelet bricht beim Parsen ab: Gemeint war max-pods. RKE2 reicht kubelet-arg ungeprüft durch – dasselbe passiert mit Flags, die ein Upgrade entfernt hat.

# auf cp1
ssh -n worker2 sudo rm /etc/rancher/rke2/config.yaml.d/90-kaputt.yaml
ssh -n worker2 sudo systemctl restart rke2-agent
kubectl wait --for=condition=Ready node/worker2 --timeout=120s

Erwartet:

node/worker2 condition met

Talos: Derselbe Tippfehler über KubeletConfig, untersucht mit talosctl service kubelet und talosctl logs kubelet (Tag 19).

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf cp1
kubectl delete namespace tag14
ssh -n worker2 sudo rmdir /etc/rancher/rke2/config.yaml.d
kubectl get nodes
kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints

Erwartet:

namespace "tag14" deleted
NAME      STATUS   ROLES                AGE     VERSION
cp1       Ready    control-plane,etcd   4h56m   v1.37.2+rke2r1
worker1   Ready    <none>               4h54m   v1.37.2+rke2r1
worker2   Ready    <none>               4h52m   v1.37.2+rke2r1
NAME      TAINTS
cp1       <none>
worker1   <none>
worker2   <none>

Interview-Notiz

  • Knoten NotReady – was zuerst? Conditions lesen: Unknown → Kubelet schweigt (Dienst, Netz, Knoten weg), False mit Meldung → Kubelet läuft und nennt das Problem.
  • Warum dauert der Ersatz so lange? 50 s node-monitor-grace-period plus 300 s tolerationSeconds aus DefaultTolerationSeconds; der alte Pod hängt in Terminating, bis das Kubelet zurück ist oder das Node-Objekt gelöscht wird.
  • Drain hängt? kubectl get pdb, Spalte ALLOWED DISRUPTIONS; nach einem Abbruch uncordon nicht vergessen.

Enterprise-Notiz

  • Ein dauerhaft verlorener Knoten wird mit kubectl delete node entfernt; erst dann räumt der Garbage Collector seine Pods ab. Bei StatefulSets nur, wenn sicher ist, dass der Knoten wirklich aus ist (Fencing). Seit Kubernetes 1.28 geht es auch ohne Löschen: nach dem Fencing den Taint node.kubernetes.io/out-of-service=nodeshutdown:NoExecute setzen – Pods und Volumes werden sofort freigegeben.
  • Kürzere tolerationSeconds nur für zustandslose Dienste; Monitoring alarmiert auf NotReady lange vor den 300 s.
  • PDBs mit maxUnavailable statt minAvailable = Replikazahl; vor jeder Wartung kubectl get pdb -A mit ALLOWED DISRUPTIONS 0 suchen.
  • ephemeral-storage-Requests und -Limits für alle Pods, sonst evicted das Kubelet bei Plattennot nach seiner eigenen Reihenfolge.
  • Kubelet-Argumente in RKE2 zentral über config.yaml (Ansible, Rancher) pflegen, vor dem Ausrollen auf einem Knoten testen.