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 aufUnknownund einen Taint. Unknownheißt: Das Kubelet schweigt.Falseheiß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-agentaufworker2. 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-agentnimmt den Knoten aus dem Cluster. Nur im Labor.
# auf cp1
ssh -n worker2 sudo systemctl stop rke2-agentSymptom: 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
doneErwartet:
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-88Erwartet:
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-agentNachweis:
# 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
worker2wieder; 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-80Erwartet: 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-80Erwartet:
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-88Erwartet:
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/webErwartet (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=120sErwartet (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.yamlSymptom (nach etwa zwei Minuten):
# auf cp1
sleep 120
kubectl -n tag14 get pods -l app=fuellerErwartet:
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=FailedNachweis (nach einer Minute):
# auf cp1
sleep 60
kubectl -n tag14 get pods -l app=fuellerErwartet:
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/apiSymptom:
# auf cp1
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data --timeout=30s 2>&1 \
| grep -E 'cordoned|api|timeout' | cut -c1-88 | sort | uniq -cErwartet (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 worker1Erwartet:
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 worker1Erwartet (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-80Erwartet:
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
- Zeig für alle Knoten, wann ihr Lease zuletzt erneuert wurde. Zeitziel: 30 s
- Zeig die Taints aller Knoten in einer Tabelle. Zeitziel: 30 s
- Finde alle evicted Pods im ganzen Cluster. Zeitziel: 30 s
- Zeig
maxPodsdes Kubelets aufworker1, 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.maxPodsErwartet:
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 deployErwartet:
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-agentHinweis: 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-120Erwartet (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=120sErwartet:
node/worker2 condition met
Talos: Derselbe Tippfehler über
KubeletConfig, untersucht mittalosctl service kubeletundtalosctl 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.taintsErwartet:
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),Falsemit Meldung → Kubelet läuft und nennt das Problem. - Warum dauert der Ersatz so lange? 50 s
node-monitor-grace-periodplus 300 stolerationSecondsausDefaultTolerationSeconds; der alte Pod hängt inTerminating, bis das Kubelet zurück ist oder das Node-Objekt gelöscht wird. - Drain hängt?
kubectl get pdb, SpalteALLOWED DISRUPTIONS; nach einem Abbruchuncordonnicht vergessen.
Enterprise-Notiz
- Ein dauerhaft verlorener Knoten wird mit
kubectl delete nodeentfernt; 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 Taintnode.kubernetes.io/out-of-service=nodeshutdown:NoExecutesetzen – Pods und Volumes werden sofort freigegeben. - Kürzere
tolerationSecondsnur für zustandslose Dienste; Monitoring alarmiert aufNotReadylange vor den 300 s. - PDBs mit
maxUnavailablestattminAvailable= Replikazahl; vor jeder Wartungkubectl get pdb -AmitALLOWED DISRUPTIONS 0suchen. 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.