Training Module
Kubernetes DaemonSets, Downward API & Pod Priority: Knotenweite Dienste, Metadaten-Injektion und Preemption
In diesem 90-Minuten-Modul verlasst ihr die einzelne Anwendung und
blickt erstmals auf drei Mechanismen, die den Cluster als Ganzes
betreffen. Los geht es mit dem DaemonSet, der
Ressource, die dafür sorgt, dass ein Infrastruktur-Pod (Log-Sammler,
Monitoring-Agent, Security-Scanner) auf jedem Worker-Node
läuft, statt wie ein Deployment nach Auslastung verteilt zu werden.
Ihr rollt ein eigenes DaemonSet auf eurem k3d-Cluster aus, beobachtet
live, dass der DaemonSet-Controller System-Pods automatisch mit
passenden Tolerations ausstattet (die
Taint/Toleration-Grundmechanik selbst gilt dabei als bekannt aus dem
Modul “Kubernetes Node-Placement & Taints”), und lernt die vier
Kommunikationsmuster für knotenweit verteilte Pods kennen: Push,
NodeIP+HostPort, Standard-Service und
Headless-Service. Danach folgt die Downward API: Pod-
und Node-Metadaten (Node-Name, Pod-Name, Namespace, Labels) landen per
Umgebungsvariable oder per eingebundenem Volume direkt im Container,
ohne dass die Anwendung selbst jemals mit dem Kubernetes-API-Server
spricht oder eigene Cluster-Rechte braucht. Zum Abschluss geht es um
Pod Priority & Preemption: Ihr legt eine eigene
PriorityClass an, weist sie einem Pod zu und ordnet ein,
wie der Scheduler bei Ressourcenengpass niedriger priorisierte Pods
verdrängt, und wo preemptionPolicy: Never genau diese
Verdrängung durch den eigenen Pod verhindert, ohne dessen
Warteschlangen-Vorrang aufzugeben. Voraussetzung ist das abgeschlossene
Modul “Kubernetes Node-Placement & Taints”. Ausdrücklich
nicht Teil dieses Moduls sind Kubernetes-Jobs/CronJob
und Custom Resource Definitions. 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 & drei eigenständige Hands-on-Blöcke
Teilnehmende
Entwickler:innen und Ops, die knotenweite Hintergrunddienste betreiben, Pod-Metadaten sauber in eigene Anwendungen injizieren und kritische Workloads vor Verdrängung schützen wollen
Voraussetzungen
Abgeschlossenes Modul “Kubernetes Node-Placement & Taints” (Taint-/Toleration-Grundmechanik gilt als bekannt), lauffähige lokale Docker-Umgebung für k3d
Warum dieses Training für deine Organisation wirkt
Infrastruktur-Pods statt Deployment-Zweckentfremdung
Ein Log-Sammler oder Monitoring-Agent als Deployment mit hoher Replica-Zahl nachzubauen, deckt weder neue Nodes automatisch ab noch bindet er sich zuverlässig an jeden einzelnen Host. Das DaemonSet modelliert “auf jedem Node genau einer” als das, was es ist.
Metadaten ohne API-Zugriff und ohne Cluster-Rechte
Viele Anwendungen brauchen nur den eigenen Pod-Namen oder Node-Namen für Logs und Metriken. Eigene RBAC-Rechte und einen API-Client dafür einzubauen ist unnötiges Risiko. Die Downward API liefert dieselben Daten ohne jede Cluster-Berechtigung.
Kritische Workloads aktiv vor Verdrängung schützen
Ohne PriorityClass entscheidet bei Ressourcenengpass
der Zufall der Ankunftsreihenfolge. Mit einer eigenen
Prioritätsklasse legt ihr fest, welche Pods bei Engpass zuerst
weichen müssen, und welche nie verdrängt werden dürfen.
Was Teilnehmende mitnehmen
- Ein
DaemonSetvon einem Deployment abgrenzen: keinreplicas-Feld, automatische Kopplung an die Node-Anzahl, dynamische Aufnahme neuer Nodes. - Erklären, warum der DaemonSet-Controller System-Pods automatisch mit Tolerations wie
node.kubernetes.io/not-readyausstattet, und diese inkubectl get pod … -o yamlwiederfinden. - Die vier Kommunikationsmuster für DaemonSet-Pods benennen und unterscheiden: Push,
NodeIP+HostPort, Standard-Service (Load-Balancing, kein gezielter Node) und Headless-Service (direkte Einzel-IP-Auflösung per DNS). - Pod-Metadaten wie Node-Name, Pod-Name und Namespace per
fieldRefals Umgebungsvariable injizieren, ohne dass der Container mit dem API-Server spricht. - Dynamische Metadaten wie Labels per
downwardAPI-Volume als Datei einbinden und benennen, warum sich diese Dateien bei einer Label-Änderung automatisch aktualisieren, ohne dass der Pod neu startet. - Eine eigene
PriorityClassanlegen, einem Pod perpriorityClassNamezuweisen und das Preemption-Verhalten bei Ressourcenengpass einordnen. preemptionPolicy: Neverkorrekt abgrenzen: bevorzugte Einplanung in der Warteschlange, aber kein Verdrängen bereits laufender Pods.
Für wen dieses Modul ideal ist
- • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Node-Placement & Taints”
- • Alle, die demnächst einen eigenen Logging- oder Monitoring-Agenten knotenweit ausrollen und dafür das richtige Kommunikationsmuster wählen wollen
- • Teams, die Pod-Metadaten bislang über einen selbstgebauten API-Client statt über die Downward API auslesen
- • Alle, die kritische Produktions-Pods bislang keiner eigenen Prioritätsklasse zugewiesen haben
Rahmendaten
- • Dauer: 90 Minuten live (remote oder vor Ort)
- • Format: Input, Live-Demo, drei eigenständige Hands-on-Blöcke (DaemonSet, Downward API, PriorityClass)
- • Voraussetzungen: abgeschlossenes Modul “Kubernetes Node-Placement & Taints”, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung
Modulaufbau & Agenda
DaemonSets: Funktionsweise, Toleration-Injektion & Kommunikationsmuster (30 min, Hands-on): DaemonSet vs. Deployment, automatische Toleration-Injektion bei System-Pods, die vier Kommunikationsmuster Push,
NodeIP+HostPort, Service und Headless-Service, Überleitung zurPriorityClass. Mit dem Hands-on ein DaemonSet ausrollen, Platzierung auf allen Nodes verifizieren und automatische Tolerations im laufenden Pod prüfen.Downward API: Pod-Metadaten ohne API-Server-Zugriff (30 min, Hands-on): Env-Var vs. Volume-Einbindung. Mit zwei Hands-on-Übungen: Node-/Pod-/Namespace-Metadaten als Umgebungsvariablen injizieren, danach Labels dynamisch über ein
downwardAPI-Volume einbinden.Pod Priority & Preemption (20 min, Hands-on):
PriorityClasserstellen, Preemption-Verhalten bei Ressourcenengpass,preemptionPolicy: Never. Mit dem Hands-on eine eigenePriorityClassanlegen und einem Pod zuweisen.Abgrenzung & Q&A (10 min): was dieses Modul bewusst nicht behandelt (Kubernetes-Jobs/CronJob, Custom Resource Definitions) und offene Fragen.
Dieses Modul setzt das Modul
Kubernetes Node-Placement & Taints: nodeSelector, Pod Anti-Affinity und Toleration auf dem Multi-Node-Cluster
voraus. Die dortige Taint/Toleration-Grundmechanik (Schloss-und-
Schlüssel-Bild, die drei Effekte NoSchedule/
PreferNoSchedule/NoExecute) gilt als
bekannt und wird hier nicht erneut erklärt. Dieses Modul zeigt
nur, dass der DaemonSet-Controller passende Tolerations
automatisch selbst setzt.
Ausdrücklich nicht Teil dieses Moduls sind Kubernetes-Jobs und CronJobs (vollständig Stoff des Moduls Kubernetes Anwendungsdesign: Multi-Container-Patterns, Jobs & Security Context ) sowie Custom Resource Definitions, die stattdessen die Module Kubernetes CRDs & Operator Pattern, Kubernetes Operator entwickeln mit Kubebuilder (Go) und Kubernetes Operator härten: Admission- & Conversion-Webhooks mit Kubebuilder abdecken. Dieses Modul dupliziert keinen dieser Inhalte, sondern bleibt bei DaemonSets, Downward API und Pod Priority/Preemption.
Hands-on Inhalte (Auszug)
DaemonSet ausrollen & Tolerations prüfen
- Ein DaemonSet ohne
replicas-Feld anwenden und mitkubectl get daemonsetsowiekubectl get pods -l app=nginx -o widenachweisen, dass jeder Node genau eine Pod-Instanz erhält - Mit
kubectl get pod -l app=nginx -o yamldie vom Controller automatisch ergänzten Tolerations (z. B.node.kubernetes.io/not-ready) im laufenden Pod finden
Downward API als Umgebungsvariable
- Node-Name, Pod-Name und Namespace per
fieldRef/fieldPathals drei Umgebungsvariablen in einen Nginx-Container injizieren - Mit
kubectl exec … – env | grep -E ‘NODENAME|PODNAME|NAMESPACE’live bestätigen, dass die echten Cluster-Werte ankommen
Downward API als Volume
- Ein
downwardAPI-Volume mitmetadata.name,metadata.namespaceundmetadata.labelsunter/etc/kubeinfo/einbinden - Mit
kubectl exec … – cat /etc/kubeinfo/podnameund…/labelsdie automatisch erzeugten Metadaten-Dateien auslesen
PriorityClass erstellen & zuweisen
- Eine eigene
PriorityClass high-priomitvalue: 1000000undglobalDefault: falseanwenden und mitkubectl get priorityclassesneben den System-Klassen verifizieren - Einen Pod per
priorityClassName: high-prioan diese Klasse binden und einordnen, waspreemptionPolicy: Neverdaran ändern würde
Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum ersten erfolgreich verifizierten DaemonSet-Rollout) 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