Training Module

Kubernetes Service Mesh — Traffic-Management mit Istio

In diesem 115-Minuten-Modul verlasst ihr die Kubernetes-Bordmittel für Traffic-Steuerung und lernt ein Service Mesh als eigene Infrastruktur-Schicht kennen. Istio setzt neben jeden Pod einen Envoy-Sidecar-Proxy: die Control-Plane istiod konfiguriert diese Proxies zentral, während die eigentliche Datenweiterleitung – die Data-Plane – vollständig dezentral in den Sidecars passiert, ohne dass ein einziger Request-Pfad durch den kube-proxy führt. Genau diese Abgrenzung steht am Anfang: kube-proxy routet auf Layer 4 grob über iptables/IPVS-Regeln zwischen Pod-IPs, ein Envoy-Sidecar entscheidet auf Layer 7 pro Request – mit Wissen über HTTP-Header, Pfade und exakte Prozentsätze, unabhängig von der Pod-Anzahl. Im ersten Hands-on installiert ihr Istio lokal per istioctl in eurem Minikube-Cluster und aktiviert die automatische Sidecar-Injection für einen Namespace – jeder neu erstellte Pod bekommt ab diesem Moment automatisch seinen Envoy-Sidecar, sichtbar an 2/2 statt 1/1 Containern. Im zweiten Hands-on baut ihr mit VirtualService und DestinationRule ein gewichtetes Traffic-Splitting zwischen zwei Versionen auf und vergleicht es direkt mit der pod-basierten setWeight -Steuerung aus dem Modul Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts: Wo Argo Rollouts Prozentsätze nur in Schritten von 1/replicas erreicht, setzt eine VirtualService-Route exakte Prozentsätze unabhängig von der Pod-Zahl. Als Sicherheitsaspekt ordnet ihr anschließend mTLS zwischen Services ein – eine PeerAuthentication-Ressource erzwingt verschlüsselte, gegenseitig authentifizierte Verbindungen zwischen allen Sidecars, als Ergänzung zu Pod Security Admission aus dem Modul Kubernetes Security Vertiefung — Pod Security Admission & Secrets-Härtung. Ein kurzer Ausblick ohne eigenes Hands-on rundet ab: Kiali als Observability-Dashboard für den Service-Graph – die Installation samt Prometheus-Anbindung und ein Hands-on zur Fehlerdiagnose im Graph liefert das eigenständige Aufbaumodul Kubernetes Service Mesh Observability — Kiali & der Service-Graph –, sowie Multi-Cluster-Mesh als Aufbaustufe über mehrere Cluster hinweg. Ausdrücklich NICHT Teil dieses Kurses: Kiali-Installation (eigenes Aufbaumodul, siehe oben), Multi-Cluster-Mesh-Aufbau, Circuit-Breaking als eigene Übung und CI/Image-Build – eine gezielte Fault-Injection-Übung liefert erst das Kiali-Aufbaumodul. Voraussetzung sind die Module “Kubernetes Networking Vertiefung” (Service-/DNS-Grundlagen) und “Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts” (pod-basierte Traffic-Steuerung als Vergleichsbasis) – beide werden hier vorausgesetzt und nicht wiederholt. Die Session läuft komplett lokal über Minikube (–driver=docker), Istio selbst läuft rein containerisiert im Cluster, ohne Cloud-Account und ohne Kostenwirkung.

Format

115 Minuten, live (remote oder vor Ort), Input & zwei Hands-on-Übungen

Teilnehmende

Entwickler:innen und Ops, die exaktes, pod-zahl-unabhängiges Traffic-Management statt grober Service-Routing-Bordmittel brauchen

Voraussetzungen

Abgeschlossene Module “Kubernetes Networking Vertiefung” UND “Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts” (beide Pflicht), lauffähige lokale Docker-Umgebung für Minikube

Warum dieses Training für deine Organisation wirkt

kube-proxy routet blind, ein Sidecar kennt den Request

kube-proxy verteilt auf Layer 4 gleichmäßig über iptables/IPVS-Regeln zwischen Pod-IPs – ohne Wissen über HTTP-Header, Pfade oder gewünschte Prozentsätze. Ein Envoy-Sidecar entscheidet pro Request auf Layer 7.

Traffic-Prozentsätze ohne Pod-Zahl-Zwang

Argo Rollouts erreicht setWeight nur in Schritten von 1/replicas. Eine VirtualService -Route setzt exakte Prozentsätze – auch 1 % Live-Traffic bei nur einem einzigen Pod dahinter.

mTLS ohne Anwendungscode-Änderung

Eine PeerAuthentication-Ressource erzwingt gegenseitig authentifizierte Verschlüsselung zwischen allen Sidecars – transparent für jede Anwendung, ohne ein einziges TLS-Zertifikat im eigenen Code zu verwalten.

Was Teilnehmende mitnehmen

  • Das Sidecar-Proxy-Modell (Envoy) und die Trennung Control-Plane (istiod) / Data-Plane benennen und von kube-proxy/Service-Routing auf Layer 4 abgrenzen.
  • Istio per istioctl in einem lokalen Minikube-Cluster installieren und automatische Sidecar-Injection für einen Namespace aktivieren.
  • VirtualService und DestinationRule einsetzen, um gewichtetes Traffic-Splitting zwischen zwei Versionen unabhängig von der Pod-Anzahl umzusetzen.
  • Diese Layer-7-Traffic-Steuerung gegen die pod-basierte setWeight-Steuerung aus Argo Rollouts abgrenzen und begründen, wann welcher Ansatz greift.
  • mTLS zwischen Services über eine PeerAuthentication-Ressource einordnen und als Ergänzung – nicht Ersatz – zu Pod Security Admission/NetworkPolicy verstehen.
  • Kiali als Observability-Werkzeug für den Service-Graph und Multi-Cluster-Mesh als Aufbaustufe konzeptionell einordnen – bewusst ohne eigenes Hands-on zu diesen Punkten, vertieft im Aufbaumodul “Kubernetes Service Mesh Observability — Kiali & der Service-Graph”.
  • Benennen, was dieses Modul bewusst nicht behandelt: Kiali-Installation (eigenes Aufbaumodul), Multi-Cluster-Mesh-Aufbau, Circuit-Breaking als eigene Übung und CI/Image-Build.

Für wen dieses Modul ideal ist

  • • Entwickler:innen und Ops mit abgeschlossenen Modulen “Kubernetes Networking Vertiefung” und “Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts” oder gleichwertigen Vorkenntnissen
  • • Teams, die exaktes, pod-zahl-unabhängiges Traffic-Splitting brauchen und bisher an der Grobkörnigkeit reiner ReplicaSet-Gewichtung gescheitert sind
  • • Alle, die mTLS zwischen Services einführen wollen, ohne Anwendungscode anzufassen

Rahmendaten

  • • Dauer: 115 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, zwei Hands-on-Übungen (Installation & Sidecar-Injection, gewichtetes Traffic-Splitting im Vergleich zu Argo Rollouts)
  • • Voraussetzungen: abgeschlossene Module “Kubernetes Networking Vertiefung” UND “Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts” (beide Pflicht), lauffähige lokale Docker-Umgebung für Minikube, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Sidecar-Proxy-Modell & Control-Plane/Data-Plane (15 min): Envoy als Sidecar-Proxy, istiod als Control-Plane, Abgrenzung zu kube-proxy/Service-Routing auf Layer 4.

  2. Istio-Architektur & Sidecar-Injection-Mechanismus (15 min): der Mutating-Webhook hinter der automatischen Sidecar-Injection, VirtualService/DestinationRule als Vorschau auf Hands-on 2.

  3. Hands-on 1: Istio-Installation & Sidecar-Injection (30 min, Hands-on): Istio per istioctl in Minikube installieren, Sidecar-Injection an einem Namespace aktivieren, 2/2-Container live verifizieren.

  4. Hands-on 2: Gewichtetes Traffic-Splitting mit VirtualService/DestinationRule (30 min, Hands-on): zwei Versionen per DestinationRule-Subsets und gewichteter VirtualService-Route live gegeneinander ausspielen, direkter Vergleich zur pod-basierten Steuerung aus Argo Rollouts.

  5. mTLS zwischen Services (15 min): PeerAuthentication im STRICT-Modus, Abgrenzung zu Pod Security Admission und NetworkPolicy.

  6. Ausblick ohne Hands-on & Abschluss (10 min): Kiali als Observability-Dashboard (vertieft im Aufbaumodul Kubernetes Service Mesh Observability — Kiali & der Service-Graph), Multi-Cluster-Mesh als Aufbaustufe.

Dieses Modul setzt die Aufbaumodule Kubernetes Networking Vertiefung UND Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts zwingend gleichzeitig voraus. Service-/DNS-Grundlagen aus dem einen und die pod-basierte setWeight-Steuerung aus dem anderen Modul gelten als bekannt und werden hier nicht neu erklärt – Hands-on 2 lebt gerade vom direkten Vergleich zu Letzterem, statt bei null zu beginnen.

Was dieses Modul bewusst nicht behandelt: die Installation von Kiali oder einem anderen Observability-Stack als eigenständiges Hands-on – das übernimmt vollständig das Aufbaumodul Kubernetes Service Mesh Observability — Kiali & der Service-Graph , inklusive Prometheus-Anbindung und einer eigenen Fault-Injection-Übung –, den Aufbau eines echten Multi-Cluster-Mesh, Circuit-Breaking als eigene Übung, sowie der Build eines Container-Images oder eine CI-Pipeline davor. Die Vertiefung zu Pod Security Admission und Secrets-Härtung, gegen die mTLS in Block 5 abgegrenzt wird, leistet das Aufbaumodul Kubernetes Security Vertiefung — Pod Security Admission & Secrets-Härtung, hier wird dessen Inhalt vorausgesetzt, nicht wiederholt.

Hands-on Inhalte (Auszug)

Istio installieren

  • istioctl lokal einrichten, istioctl install –set profile=demo gegen den Minikube-Cluster fahren, Control-Plane-Pods in istio-system verifizieren
  • Grundlegende istioctl-Diagnosebefehle kennenlernen, bevor der erste Sidecar überhaupt läuft

Sidecar-Injection

  • Namespace-Label istio-injection=enabled setzen, bestehendes Deployment neu ausrollen
  • 2/2-Container pro Pod live in kubectl get pods nachweisen – app-Container plus Envoy-Sidecar

VirtualService/DestinationRule

  • Zwei Versionen über Pod-Labels als DestinationRule-Subsets definieren
  • Gewichtete Route (z. B. 90/10) in einem VirtualService anlegen, unabhängig von der jeweiligen Pod-Anzahl je Version

Traffic-Splitting live vergleichen

  • Wiederholte Requests gegen den Ingress schicken, tatsächliche Split-Verteilung live auszählen
  • Denselben Prozentsatz gedanklich gegen eine Argo-Rollouts-setWeight-Steuerung mit identischer Replica-Zahl gegenrechnen

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit von der Sidecar-Injection bis zum ersten live bestätigten, gewichteten Traffic-Split) 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