Training Module

Kubernetes Networking Vertiefung — Service Discovery, DNS und Ingress-Pfadregeln

In diesem 105-Minuten-Modul geht ihr eine Ebene tiefer als beim Service-Grundlagenwissen: Was steckt eigentlich hinter einem Service, und wie steuert Kubernetes das Routing im Detail? Los geht es mit Endpoints und EndpointSlices – warum die alte, monolithische Endpoints-API zugunsten der auf mehrere Objekte verteilten EndpointSlices deprecated ist (Stichwort Skalierung), und wie eng Discovery an die readinessProbe gekoppelt ist: Nur Pods, deren Readiness aktuell erfolgreich ist, landen überhaupt in der Adressliste. Danach folgen SRV-Records für benannte Ports – <port-name>.<protocol>.<service>.<namespace>.svc.cluster.local – mit dem Unterschied zwischen einem regulären und einem Headless Service, sowie die Steuerung des Pod-DNS-Verhaltens über dnsPolicy (die vier Werte ClusterFirst, Default, ClusterFirstWithHostNet und None) und dnsConfig für eigene Nameserver, Search-Domains und Optionen. Der zweite Block vertieft Ingress ausschließlich um Pfad-basiertes Routing, die Kombination aus Host und Pfad in einer Regel, sowie die pathType-Semantik Prefix/Exact/ImplementationSpecific – einfaches Host-Routing wird hier nicht wiederholt, siehe Kursseite Docker & Kubernetes, wo es bereits live ist. Im Hands-on löst ihr eine SRV-Auflösung über einen kurzlebigen Debug-Pod mit nslookup/dig und baut ein zweites Ingress-Beispiel mit reinem Pfad-Routing. Auch dieses Modul läuft komplett lokal über Minikube, ohne Cloud-Account und ohne Kostenwirkung.

Format

105 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Entwickler:innen und Ops, die Service Discovery, DNS-Verhalten und Ingress-Routing im Detail verstehen wollen

Voraussetzungen

Abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” oder gleichwertige Vorkenntnisse (Service-Grundlagen, readinessProbe), lauffähige lokale Docker-Umgebung für Minikube

Warum dieses Training für deine Organisation wirkt

Vom Service zum tatsächlichen Traffic

Ein Service selbst routet nichts – EndpointSlices halten die tatsächlichen Pod-Adressen vor, und nur readiness-geprüfte Pods landen darin. Wer diese Kopplung nicht kennt, sucht bei einem “Pod läuft, bekommt aber keinen Traffic”-Vorfall an der falschen Stelle.

DNS ist mehr als der Servicename

SRV-Records liefern Portnummern mit, ohne sie hart zu verdrahten, und dnsPolicy/dnsConfig entscheiden, wie ein Pod überhaupt auflöst – beides Stellschrauben, die im Grundlagenwissen bewusst ausgespart bleiben.

Ingress-Regeln, die tatsächlich tragen

Pfad-basiertes Routing, die Kombination aus Host und Pfad sowie die korrekte pathType-Wahl entscheiden, ob eine Ingress-Regel im Alltag greift oder überraschend auf den falschen Service zeigt.

Was Teilnehmende mitnehmen

  • Endpoints und EndpointSlices unterscheiden und mit kubectl get endpointslices -l kubernetes.io/service-name=<svc> gezielt abfragen – inklusive dem Skalierungsgrund, warum EndpointSlices das deprecatete, monolithische Endpoints-Objekt ablösen.
  • Die Kopplung von Readiness und Discovery einordnen: Nur Pods mit erfolgreicher readinessProbe landen in der Adressliste, ohne dass der Pod selbst neu gestartet wird.
  • SRV-Records für benannte Ports lesen (<port-name>.<protocol>.<service>.<namespace>.svc.cluster.local) und den Unterschied zwischen regulärem und Headless Service in der Antwort erkennen.
  • Die vier dnsPolicy-Werte ClusterFirst, Default, ClusterFirstWithHostNet und None unterscheiden und mit dnsConfig (nameservers/searches/options) gezielt nachjustieren.
  • Ingress-Vertiefung: Pfad-basiertes Routing, die Kombination aus Host und Pfad in einer Regel, und die pathType-Semantik Prefix/Exact/ImplementationSpecific korrekt anwenden.
  • SRV-Auflösung über einen kurzlebigen Debug-Pod mit nslookup/dig selbst nachvollziehen und ein zweites Ingress-Beispiel mit Pfad-Routing selbst anwenden.

Für wen dieses Modul ideal ist

  • • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Workloads & Konfiguration” oder gleichwertigen Vorkenntnissen
  • • Alle, die einen “Pod ist ready, bekommt aber keinen Traffic”-Vorfall künftig selbst über Endpoints/EndpointSlices statt über Zufallstreffer debuggen wollen
  • • Teams, die mehrere Ingress-Regeln pro Domain pflegen und die pathType-Semantik einmal sauber verstehen wollen, statt sie an jeder Stelle neu zu erraten

Rahmendaten

  • • Dauer: 105 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, Hands-on mit Debug-Pod und zweitem Ingress-Beispiel
  • • Voraussetzungen: abgeschlossenes Modul “Kubernetes Workloads & Konfiguration”, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Endpoints, EndpointSlices & Readiness-Kopplung (25 min): das deprecatete Endpoints-Objekt gegen die auf mehrere Objekte verteilten EndpointSlices abgrenzen (Skalierung, Standard-Limit 100 Endpoints pro Slice), kubectl get endpointslices -l kubernetes.io/service-name=<svc>, und warum nur readiness-geprüfte Pods in der Adressliste landen.

  2. SRV-Records & dnsPolicy/dnsConfig (30 min): das SRV-Record-Format für benannte Ports, der Unterschied zwischen regulärem und Headless Service in der Antwort, die vier dnsPolicy-Werte ClusterFirst/Default/ClusterFirstWithHostNet/None, und dnsConfig für eigene Nameserver, Search-Domains und Optionen.

  3. Ingress-Vertiefung: Pfad-Routing & pathType (30 min): Pfad-basiertes Routing, die Kombination aus Host und Pfad in einer Regel, und die pathType-Semantik Prefix/Exact/ImplementationSpecific im Detail.

  4. Hands-on: SRV-Debugging & zweites Ingress-Beispiel (20 min): eine SRV-Auflösung über einen kurzlebigen Debug-Pod mit nslookup/dig selbst durchführen, und ein zweites Ingress-Beispiel mit reinem Pfad-Routing anwenden und prüfen.

Dieses Modul setzt das Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag voraus. Service-Grundlagen (die vier Service-Typen ClusterIP/ NodePort/LoadBalancer/ExternalName) sowie readinessProbe als Konzept werden dort erklärt und hier nicht erneut eingeführt – dieses Vertiefungsmodul beginnt direkt bei dem, was hinter einem Service steckt.

Einfaches Host-basiertes Routing wird hier nicht wiederholt, siehe Kursseite Docker & Kubernetes: Vom Compose-Stack zum lokalen Cluster, wo es bereits live ist. Dieses Modul vertieft ausschließlich Pfad-basiertes Routing, die Kombination aus Host und Pfad sowie die pathType-Semantik.

Wer stattdessen die Betreiber-Perspektive einnehmen will – Namespace/ResourceQuota, RBAC, Cluster-Netzwerk-Grundmodell (CNI/kube-proxy/CoreDNS/NetworkPolicy), Node-Administration und High Availability als Konzept – findet das im gleichrangigen, unabhängigen Schwestermodul Kubernetes Administration — RBAC, Node-Betrieb und Cluster-Netzwerk. Wer stattdessen die Anwendungsdesign-Perspektive einnehmen will – Multi-Container-Pod-Patterns, Job/CronJob für Batch-Workloads sowie securityContext und ServiceAccount – findet das im weiteren Schwestermodul Kubernetes Anwendungsdesign — Multi-Container-Patterns, Jobs & Security Context. Wer stattdessen die Storage-Perspektive einnehmen will – emptyDir und hostPath im Vergleich zu PersistentVolume, PersistentVolumeClaim mit Binding-Regel, AccessModes und StorageClass – findet das im weiteren Schwestermodul Kubernetes Storage — Volumes, PersistentVolumes & Claims. Wer stattdessen wissen will, wie sich eine bereits laufende Anwendung diagnostizieren lässt – Prometheus-Scrape-Annotationen, Ephemeral Containers per kubectl debug und die dreistufige Service-Troubleshooting-Kette Port-Forward → Endpoints → DNS-Test-Pod – findet das im weiteren Schwestermodul Kubernetes: Monitoring & Troubleshooting. Dieses Modul liest kubectl get endpoints dort nur als Diagnose-Schritt, ohne die hier behandelten EndpointSlice-Interna zu vertiefen. Wer stattdessen wissen will, wie viel ein Container verbrauchen darf – requests/limits, die drei QoS-Klassen sowie der HorizontalPodAutoscaler – findet das im weiteren Schwestermodul Kubernetes Ressourcenmanagement & Autoscaling — Requests, Limits und HorizontalPodAutoscaler. Wer stattdessen wissen will, wie sich diese Objekte als wiederverwendbares Paket versionieren und verteilen lassen – Chart-Struktur, values.yaml und Release-Verwaltung – findet das im weiteren Schwestermodul Helm — Paketmanagement für Kubernetes. Alle sieben Vertiefungsmodule setzen nur “Kubernetes Workloads & Konfiguration” voraus, nicht sich gegenseitig.

Wer Headless Services und SRV-Records aus diesem Modul mit einem Workload-Typ kombinieren will, der genau darauf aufbaut – stabile, geordnete Pod-Identität statt austauschbarer Pods, automatisches Pro-Replica-PVC-Provisioning über volumeClaimTemplates und geordnetes Scaling über podManagementPolicy – findet das im Aufbaumodul Kubernetes StatefulSets — Stabile Identität für zustandsbehaftete Workloads, das dieses Modul und “Kubernetes Storage” gemeinsam voraussetzt.

Wer stattdessen wissen will, wie sich Layer-7-Traffic exakt und pod-zahl-unabhängig steuern lässt – ein Service Mesh mit Envoy-Sidecar-Proxy statt kube-proxy-Routing auf Layer 4 – findet das im Aufbaumodul Kubernetes Service Mesh — Traffic-Management mit Istio, das dieses Modul und “Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts” gemeinsam voraussetzt.

Hands-on Inhalte (Auszug)

Endpoints & EndpointSlices live prüfen

  • kubectl get endpoints und kubectl get endpointslices -l kubernetes.io/service-name=<svc> gegenüberstellen und den Unterschied in der Objektanzahl beobachten
  • Eine readinessProbe gezielt fehlschlagen lassen und live beobachten, wie der betroffene Pod aus der Adressliste verschwindet, ohne neu gestartet zu werden

SRV-Debugging über einen Debug-Pod

  • Einen kurzlebigen Debug-Pod starten: kubectl run dns-debug –rm -it –image=busybox:1.36 –restart=Never – sh
  • Im Container per nslookup/dig gegen den SRV-Record eines Service mit benanntem Port auflösen und die Antwort interpretieren

dnsPolicy & dnsConfig anwenden

  • Einen Pod mit dnsPolicy: “None” und eigenem dnsConfig (Nameserver, Search-Domains, ndots-Option) deklarieren und anwenden
  • Den Unterschied zur Standard-Policy ClusterFirst an der tatsächlichen Namensauflösung im Pod nachvollziehen

Zweites Ingress-Beispiel: Pfad-Routing

  • Ein zweites Ingress-Manifest mit zwei Pfadregeln (/api, /) auf demselben Nginx-Ingress-Controller anwenden, den bereits das Modul “Docker & Kubernetes” nutzt
  • Über minikube tunnel beide Pfade gegen die jeweils richtigen Services prüfen und die pathType-Wahl (Prefix vs. Exact) gezielt vergleichen

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zur korrekt gelösten SRV-Abfrage) 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-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen