Training Module
Kubernetes Node-Placement & Taints — nodeSelector, Pod Anti-Affinity und Toleration auf dem Multi-Node-Cluster
In diesem 90-Minuten-Modul verlasst ihr den Single-Node-Minikube-Kreis
der bisherigen Module und schedult zum ersten Mal gezielt auf einem
echten Multi-Node-Cluster. Los geht es mit der Einordnung, welches der
drei Werkzeuge zu welchem Anwendungsfall passt:
nodeSelector als starres “Alles-oder-Nichts”-Matching auf
Node-Labels, Node Affinity mit einer harten
Bedingung (requiredDuringSchedulingIgnoredDuringExecution,
Must-Have) und einer weichen Präferenz (
preferredDuringSchedulingIgnoredDuringExecution,
Nice-to-Have), und Pod-(Anti-)Affinity, die sich nicht
an Node-Eigenschaften, sondern an anderen Pods orientiert. Im ersten
Hands-on vergebt ihr per kubectl label nodes ein Label an
einen Worker-Node eures k3d-Clusters, schedult einen Pod per
nodeSelector exakt dorthin und lasst einen zweiten Pod
per podAntiAffinity mit
topologyKey: kubernetes.io/hostname automatisch auf den
Node ausweichen, auf dem noch kein Pod mit demselben Label läuft –
verifiziert live per kubectl get pods -o wide. Danach
wechselt die Perspektive von Anziehung zu Abweisung: die drei
Taint-Effekte NoSchedule, PreferNoSchedule
und NoExecute. Im zweiten Hands-on durchlauft ihr den
vollständigen Positivzyklus, den viele Teams nur aus der Theorie
kennen: einen Node per kubectl taint versehen, einen Pod
mit passender Toleration trotzdem erfolgreich dort
laufen lassen, den Taint anschließend wieder entfernen und alle
angelegten Objekte aufräumen. Voraussetzung ist das abgeschlossene
Modul “Kubernetes Pod-Fundamentals” (Labels sind bereits bekannt)
sowie k3d-Grundvertrautheit aus “Kubernetes Fortgeschritten — k3d
Multi-Node, OpenLens & Ingress” – ausdrücklich
nicht die Module “Kubernetes Administration” oder
“Kubernetes Hochverfügbarkeit”. Die komplette Session läuft
vollständig lokal über k3d, ohne Cloud-Account und ohne
Kostenwirkung.
Format
90 Minuten, live (remote oder vor Ort), Input & zwei eigenständige Hands-on-Blöcke
Teilnehmende
Entwickler:innen und Ops, die Pods erstmals gezielt auf einem echten Multi-Node-Cluster platzieren und Nodes gezielt sperren wollen
Voraussetzungen
Abgeschlossenes Modul “Kubernetes Pod-Fundamentals”, k3d-Grundvertrautheit aus “Kubernetes Fortgeschritten — k3d Multi-Node, OpenLens & Ingress”, lauffähige lokale Docker-Umgebung
Warum dieses Training für deine Organisation wirkt
Echter Multi-Node-Beweis statt Single-Node-Theorie
nodeSelector und Pod Anti-Affinity ergeben auf einem
einzelnen Minikube-Node keinen beobachtbaren Unterschied. Hier
läuft jede Übung auf einem echten k3d-Cluster mit zwei
Worker-Nodes – die Platzierung ist sichtbar, nicht nur behauptet.
Der vollständige Taint-Zyklus, nicht nur die Abweisung
Viele Teams kennen Taints nur aus dem Negativfall (“Pod bleibt Pending”). Hier wird der komplette Zyklus durchlaufen: Taint setzen, mit passender Toleration erfolgreich planen, wieder entfernen – der Fall, der in der Praxis tatsächlich gebraucht wird.
Ohne zwei fortgeschrittene Vorbedingungen
Node-Placement und Taints sind bislang nur verstreut über fortgeschrittene Module verfügbar. Dieses Modul baut ausschließlich auf Pod-Fundamentals und k3d-Grundwissen auf – ohne Administration oder Hochverfügbarkeit vorauszusetzen.
Was Teilnehmende mitnehmen
nodeSelector, harte Node Affinity (requiredDuringSchedulingIgnoredDuringExecution) und weiche Node Affinity (preferredDuringSchedulingIgnoredDuringExecution) korrekt gegeneinander abgrenzen und benennen, wasIgnoredDuringExecutionbedeutet.- Pod Affinity von Pod Anti-Affinity unterscheiden und den Schlüsselbegriff
topologyKey(z. B.kubernetes.io/hostname) als Grenze der Nachbarschaft erklären. - Einen Worker-Node des eigenen k3d-Clusters per
kubectl label nodeslabeln und mitkubectl get nodes -Lverifizieren. - Einen Pod per
nodeSelectorgezielt auf den gelabelten Node schedulen und einen zweiten Pod perpodAntiAffinity(requiredDuringSchedulingIgnoredDuringExecution,topologyKey: kubernetes.io/hostname) automatisch auf den jeweils freien Node ausweichen lassen – Platzierung verifiziert perkubectl get pods -o wide. - Die drei Taint-Effekte
NoSchedule,PreferNoScheduleundNoExecutekorrekt benennen und die Taint-SyntaxSCHLÜSSEL=WERT:EFFEKTlesen. - Den vollständigen Taint-Positivzyklus selbst durchführen:
kubectl taint nodes …setzen, einen Pod mit passendertolerations-Deklaration trotzdem erfolgreich dort platzieren, den Taint per Minuszeichen-Suffix wieder entfernen und alle angelegten Objekte aufräumen.
Für wen dieses Modul ideal ist
- • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Pod-Fundamentals” und k3d-Grundvertrautheit aus “Kubernetes Fortgeschritten — k3d Multi-Node, OpenLens & Ingress”
- • Alle, die Pods erstmals bewusst auf bestimmte Worker-Nodes verteilen oder gezielt von Nodes fernhalten wollen, statt sich auf den Zufall des Schedulers zu verlassen
- • Teams, die Taints bislang nur als Fehlerquelle (“Pod bleibt Pending”) kennen und den kompletten Zyklus inklusive erfolgreicher Toleration einmal selbst durchlaufen wollen
Rahmendaten
- • Dauer: 90 Minuten live (remote oder vor Ort)
- • Format: Input, Live-Demo, zwei eigenständige Hands-on-Blöcke (nodeSelector & Pod Anti-Affinity, Taint-Zyklus)
- • Voraussetzungen: abgeschlossenes Modul “Kubernetes Pod-Fundamentals”, k3d-Grundvertrautheit, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung
Modulaufbau & Agenda
Konzepte: nodeSelector vs. Node Affinity vs. Pod-(Anti-)Affinity (15 min):
nodeSelectorals starres Matching, harte (requiredDuringSchedulingIgnoredDuringExecution) und weiche (preferredDuringSchedulingIgnoredDuringExecution) Node Affinity, dazu Pod Affinity/Anti-Affinity mittopologyKey.Hands-on: k3d-Node labeln, nodeSelector & Anti-Affinity anwenden, Platzierung verifizieren (30 min): Worker-Node per
kubectl label nodeslabeln, Manifest mit einemnodeSelector-Pod und einempodAntiAffinity-Pod anwenden, Platzierung perkubectl get pods -o widenachvollziehen.Taint-Effekte NoSchedule/PreferNoSchedule/NoExecute (10 min): die drei Effektstufen und die Taint-Syntax
SCHLÜSSEL=WERT:EFFEKT.Hands-on: Taint setzen → Pod mit Toleration laufen lassen → Untaint → Aufräumen (30 min):
kubectl taintauf einen Node setzen, Pod mit passendertolerations-Deklaration erfolgreich dort planen, Taint per Minuszeichen-Suffix entfernen, alle Objekte löschen.Puffer/Q&A (5 min): offene Fragen, individuelle Szenarien aus dem eigenen Cluster-Alltag.
Dieses Modul setzt das Modul
Kubernetes Pod-Fundamentals — Pause-Container, Multi-Container-Muster & Labels
voraus – Labels und Annotations gelten als bekannt und werden hier
direkt für Node-Placement eingesetzt, nicht erneut eingeführt.
Ebenso vorausgesetzt wird k3d-Grundvertrautheit aus
Kubernetes Fortgeschritten — k3d Multi-Node, OpenLens & Ingress
– den Umstieg von Minikube auf einen Multi-Node-Cluster mit
k3d cluster create … –agents 2 wiederholt dieses
Modul nicht.
Ausdrücklich nicht vorausgesetzt sind “Kubernetes
Administration” oder “Kubernetes Hochverfügbarkeit — Multi-Master
Control-Plane”. nodeSelector läuft in
Kubernetes Anwendungsdesign — Multi-Container-Patterns, Jobs & Security Context
bislang nur auf einem Single-Node-Minikube-Cluster, und
Kubernetes Administration — RBAC, Node-Betrieb und Cluster-Netzwerk
zeigt Taints bislang nur im Negativfall (Pod ohne Toleration bleibt
Pending). Dieses Modul liefert beides erstmals auf
einem echten Multi-Node-Cluster nach – als eigenständiges,
niedrigschwelliges Modul, nicht als Ersatz für diese beiden Kurse.
Wer die feingranulare Skew-Steuerung über mehrere Nodes hinweg (statt binärer Anti-Affinity) und echte Failure-Domain-Zonen vertiefen will, findet das im Vertiefungsmodul Kubernetes Failure-Domain-Scheduling — Topology Spread Constraints & Pod Anti-Affinity – das allerdings zusätzlich die Module “Kubernetes Administration” UND “Kubernetes Hochverfügbarkeit” gleichzeitig voraussetzt. Dieses Modul hier ist der niedrigschwelligere Einstieg in dieselbe Pod-Anti-Affinity-Mechanik.
Aufbauend ist außerdem
Kubernetes DaemonSets, Downward API & Pod Priority: Knotenweite Dienste, Metadaten-Injektion und Preemption:
Der dortige DaemonSet-Controller setzt die hier gelernte
Toleration-Mechanik automatisch für System-Pods ein. Die
Taint/Toleration-Grundlagen dieses Moduls gelten dort als bekannt
und werden nicht erneut erklärt. Dazu kommen die Downward API
(Pod-Metadaten per Env-Var oder Volume, ohne API-Server-Zugriff)
und Pod Priority & Preemption (PriorityClass,
preemptionPolicy: Never) als zwei eigenständige,
neue Themen.
Hands-on Inhalte (Auszug)
nodeSelector & Pod Anti-Affinity
- Einen Worker-Node des k3d-Clusters per
kubectl label nodes k3d-mycluster-agent-0 disktype=ssdlabeln und mitkubectl get nodes -L disktypeverifizieren - Einen Pod mit
nodeSelector: disktype: ssdgezielt dorthin schedulen und einen zweiten Pod mitpodAntiAffinity(topologyKey: kubernetes.io/hostname) automatisch auf den freien Node ausweichen lassen, Nachweis perkubectl get pods -o wide
Taint-Zyklus: setzen, tolerieren, entfernen
- Einen Node per
kubectl taint nodes … dedicated=special:NoSchedulesperren und einen Pod mit passendertolerations-Deklaration trotzdem erfolgreich dort platzieren - Den Taint per
kubectl taint nodes … dedicated=special:NoSchedule-(Minuszeichen-Suffix) wieder entfernen und alle im Modul angelegten Pods aufräumen
Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum ersten erfolgreich verifizierten Anti-Affinity-Placement) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.
Bereit, das Modul zu buchen?
Wir passen die Hands-on-Übungen auf euren Erfahrungsstand an.
Academy Briefing anfragen