Mitglied werden – KI-Tutor mit vollen Antworten

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, was IgnoredDuringExecution bedeutet.
  • 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 nodes labeln und mit kubectl get nodes -L verifizieren.
  • Einen Pod per nodeSelector gezielt auf den gelabelten Node schedulen und einen zweiten Pod per podAntiAffinity (requiredDuringSchedulingIgnoredDuringExecution, topologyKey: kubernetes.io/hostname) automatisch auf den jeweils freien Node ausweichen lassen – Platzierung verifiziert per kubectl get pods -o wide.
  • Die drei Taint-Effekte NoSchedule, PreferNoSchedule und NoExecute korrekt benennen und die Taint-Syntax SCHLÜSSEL=WERT:EFFEKT lesen.
  • Den vollständigen Taint-Positivzyklus selbst durchführen: kubectl taint nodes … setzen, einen Pod mit passender tolerations-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

  1. Konzepte: nodeSelector vs. Node Affinity vs. Pod-(Anti-)Affinity (15 min): nodeSelector als starres Matching, harte (requiredDuringSchedulingIgnoredDuringExecution) und weiche (preferredDuringSchedulingIgnoredDuringExecution) Node Affinity, dazu Pod Affinity/Anti-Affinity mit topologyKey.

  2. Hands-on: k3d-Node labeln, nodeSelector & Anti-Affinity anwenden, Platzierung verifizieren (30 min): Worker-Node per kubectl label nodes labeln, Manifest mit einem nodeSelector-Pod und einem podAntiAffinity-Pod anwenden, Platzierung per kubectl get pods -o wide nachvollziehen.

  3. Taint-Effekte NoSchedule/PreferNoSchedule/NoExecute (10 min): die drei Effektstufen und die Taint-Syntax SCHLÜSSEL=WERT:EFFEKT.

  4. Hands-on: Taint setzen → Pod mit Toleration laufen lassen → Untaint → Aufräumen (30 min): kubectl taint auf einen Node setzen, Pod mit passender tolerations-Deklaration erfolgreich dort planen, Taint per Minuszeichen-Suffix entfernen, alle Objekte löschen.

  5. 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=ssd labeln und mit kubectl get nodes -L disktype verifizieren
  • Einen Pod mit nodeSelector: disktype: ssd gezielt dorthin schedulen und einen zweiten Pod mit podAntiAffinity (topologyKey: kubernetes.io/hostname) automatisch auf den freien Node ausweichen lassen, Nachweis per kubectl get pods -o wide

Taint-Zyklus: setzen, tolerieren, entfernen

  • Einen Node per kubectl taint nodes … dedicated=special:NoSchedule sperren und einen Pod mit passender tolerations-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