Mitglied werden – KI-Tutor mit vollen Antworten

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 DaemonSet von einem Deployment abgrenzen: kein replicas-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-ready ausstattet, und diese in kubectl get pod … -o yaml wiederfinden.
  • 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 fieldRef als 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 PriorityClass anlegen, einem Pod per priorityClassName zuweisen und das Preemption-Verhalten bei Ressourcenengpass einordnen.
  • preemptionPolicy: Never korrekt 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

  1. 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 zur PriorityClass. Mit dem Hands-on ein DaemonSet ausrollen, Platzierung auf allen Nodes verifizieren und automatische Tolerations im laufenden Pod prüfen.

  2. 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.

  3. Pod Priority & Preemption (20 min, Hands-on): PriorityClass erstellen, Preemption-Verhalten bei Ressourcenengpass, preemptionPolicy: Never. Mit dem Hands-on eine eigene PriorityClass anlegen und einem Pod zuweisen.

  4. 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 mit kubectl get daemonset sowie kubectl get pods -l app=nginx -o wide nachweisen, dass jeder Node genau eine Pod-Instanz erhält
  • Mit kubectl get pod -l app=nginx -o yaml die 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/fieldPath als 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 mit metadata.name, metadata.namespace und metadata.labels unter /etc/kubeinfo/ einbinden
  • Mit kubectl exec … – cat /etc/kubeinfo/podname und …/labels die automatisch erzeugten Metadaten-Dateien auslesen

PriorityClass erstellen & zuweisen

  • Eine eigene PriorityClass high-prio mit value: 1000000 und globalDefault: false anwenden und mit kubectl get priorityclasses neben den System-Klassen verifizieren
  • Einen Pod per priorityClassName: high-prio an diese Klasse binden und einordnen, was preemptionPolicy: Never daran ä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