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
readinessProbelanden 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 mitdnsConfig(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/digselbst 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
Endpoints, EndpointSlices & Readiness-Kopplung (25 min): das deprecatete
Endpoints-Objekt gegen die auf mehrere Objekte verteiltenEndpointSlicesabgrenzen (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.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, unddnsConfigfür eigene Nameserver, Search-Domains und Optionen.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.Hands-on: SRV-Debugging & zweites Ingress-Beispiel (20 min): eine SRV-Auflösung über einen kurzlebigen Debug-Pod mit
nslookup/digselbst 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 endpointsundkubectl get endpointslices -l kubernetes.io/service-name=<svc>gegenüberstellen und den Unterschied in der Objektanzahl beobachten- Eine
readinessProbegezielt 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/diggegen den SRV-Record eines Service mit benanntem Port auflösen und die Antwort interpretieren
dnsPolicy & dnsConfig anwenden
- Einen Pod mit
dnsPolicy: “None”und eigenemdnsConfig(Nameserver, Search-Domains,ndots-Option) deklarieren und anwenden - Den Unterschied zur Standard-Policy
ClusterFirstan 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 tunnelbeide Pfade gegen die jeweils richtigen Services prüfen und diepathType-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