Training Module
Kubernetes Service Mesh — Distributed Tracing mit Jaeger
In diesem 105-Minuten-Modul beantwortet ihr die Frage, die der
Kiali-Kurs bewusst offen gelassen hat: Kiali zeigt euch im
Service-Graph zuverlässig DASS eine Kante gerade
Fehler produziert oder langsamer wird – aber nicht
WARUM ein einzelner Request langsam war und welcher
der beteiligten Sidecar-Hops die Zeit tatsächlich gekostet hat. Genau
diese Lücke füllt Distributed Tracing mit
Jaeger: Statt einer aggregierten Erfolgsrate über
viele Requests hinweg bekommt ihr für einen einzelnen Request eine
Trace – eine Kette von Spans, von
denen jeder einen Zeitstempel für genau einen Sidecar-Hop trägt,
verbunden über einen Span-Kontext, den jeder Envoy
an den nächsten Hop weiterreicht. Im ersten Hands-on installiert ihr
Jaeger über das offizielle Istio-Addon-Manifest
samples/addons/jaeger.yaml – aus demselben
Release-Ordner, aus dem ihr im Kiali-Kurs bereits
prometheus.yaml und kiali.yaml angewendet
habt – und patcht anschließend das Trace-Sampling über
meshConfig.defaultConfig.tracing.sampling auf
100. Dieser Patch ist kein optionaler Feinschliff: Das
Standard-Sampling von Istio ist so niedrig eingestellt, dass ihr ohne
diesen Schritt live praktisch keine Traces seht – nicht weil etwas
kaputt ist, sondern weil eine bewusste Konfigurationsentscheidung
dahintersteckt. Über die bestehende Fault-Injection-Curl-Loop aus dem
Kiali-Kurs erzeugt ihr danach eure ersten Traces. Im zweiten Hands-on
öffnet ihr denselben Trace zweimal: einmal direkt im
Jaeger-UI über istioctl dashboard jaeger
, und einmal über die Kiali-Graph-Verlinkung (“View
traces”), die euch aus dem bereits bekannten Service-Graph
unmittelbar in die passende Jaeger-Trace springen lässt. Ihr lest die
Latenz Hop für Hop entlang der Spans und ordnet sie den einzelnen
Sidecars zu. Ein kurzer Ausblick ohne eigenes Hands-on rundet ab:
produktive Jaeger-Storage-Backends (Elasticsearch/Cassandra statt
des heutigen In-Memory-All-in-One) sowie der
OpenTelemetry-Collector als möglicher Jaeger-Ersatz.
Ausdrücklich Grenzen dieses Kurses, kein eigenes Hands-on:
der Sampling-Trade-off zwischen 100 % (nur für die Demo
vertretbar) und einem deutlich niedrigeren produktiven Wert, sowie
das komplette Fehlen eines produktiven Storage-Backends in diesem
Modul. Voraussetzung ist das Modul “Kubernetes Service Mesh
Observability — Kiali & der Service-Graph” (Pflicht) – dieses Modul
setzt dessen Minikube-Cluster, die Jaeger-Nachbar-Addons Prometheus
und Kiali sowie die Fault-Injection-Curl-Loop direkt fort. Die
Session läuft komplett lokal über Minikube (
–driver=docker), Jaeger läuft rein containerisiert im
Cluster, ohne Cloud-Account und ohne Kostenwirkung.
Format
105 Minuten, live (remote oder vor Ort), Input & zwei Hands-on-Übungen
Teilnehmende
Absolvent:innen von “Kubernetes Service Mesh Observability — Kiali & der Service-Graph”, die WARUM statt nur DASS ein Request langsam war beantworten wollen
Voraussetzungen
Abgeschlossenes Modul “Kubernetes Service Mesh Observability — Kiali & der Service-Graph” (Pflicht) – Service-Graph, Prometheus-Anbindung und Fault-Injection-Curl-Loop gelten als bekannt, lauffähige lokale Docker-Umgebung für Minikube
Warum dieses Training für deine Organisation wirkt
WARUM statt nur DASS
Kiali sagt euch, dass eine Kante gerade eine schlechte Erfolgsrate oder hohe Latenz hat. Jaeger sagt euch, welcher einzelne Sidecar-Hop innerhalb eines konkreten Requests die Zeit tatsächlich gekostet hat.
Ein Konfigurationswert entscheidet über Sichtbarkeit
Ohne den Sampling-Patch auf 100 bleibt euer
Jaeger-Dashboard beim Standard-Sampling praktisch leer – ein
Lehrstück dafür, dass fehlende Observability oft eine
Konfigurationsfrage statt ein Bug ist.
Zwei Werkzeuge, ein Klick verbunden
Die “View traces”-Verlinkung direkt aus dem Kiali-Graph zeigt, dass Graph-Observability und Trace-Observability keine getrennten Welten sind, sondern zusammen ein vollständigeres Bild ergeben.
Was Teilnehmende mitnehmen
- Trace, Span und Span-Kontext-Propagation über mehrere Sidecar-Hops als Konzept sicher erklären können, inklusive Abgrenzung zu Kialis aggregierter Graph-Sicht.
- Jaeger über das offizielle Istio-Addon-Manifest
samples/addons/jaeger.yamlinstallieren, aus demselben Release-Ordner wie die bereits genutzten Prometheus-/Kiali-Addons. - Das Trace-Sampling über
meshConfig.defaultConfig.tracing.samplingauf100patchen und benennen können, warum das Standard-Sampling für eine Live-Demo nicht ausreicht. - Über die bestehende Fault-Injection-Curl-Loop gezielt Traces erzeugen und sie sowohl im Jaeger-UI (
istioctl dashboard jaeger) als auch per Kiali-Graph-Verlinkung (“View traces”) gemeinsam interpretieren. - Latenz Hop für Hop entlang der Spans einer Trace lesen und einem konkreten Sidecar zuordnen, statt nur eine aggregierte Gesamtlatenz zu kennen.
- Den Sampling-Trade-off (100 % Demo vs. niedriger Produktionswert) und produktive Jaeger-Storage-Backends sowie den OpenTelemetry-Collector konzeptionell einordnen – bewusst ohne eigenes Hands-on zu diesen Punkten.
- Benennen, was dieses Modul bewusst nicht behandelt: ein produktives Storage-Backend (Elasticsearch/Cassandra), eine OpenTelemetry-Collector-Migration und Sampling-Strategien jenseits eines einzelnen festen Prozentwerts.
Für wen dieses Modul ideal ist
- • Absolvent:innen von “Kubernetes Service Mesh Observability — Kiali & der Service-Graph” oder gleichwertigen Vorkenntnissen
- • Teams, die einen Kiali-Graph bereits lesen können, aber bei der Frage “welcher Hop war eigentlich langsam?” bislang raten mussten
- • Alle, die vor dem ersten produktiven Mesh-Rollout wissen wollen, wie Request-genaue Latenzanalyse neben Prometheus-Metriken funktioniert
Rahmendaten
- • Dauer: 105 Minuten live (remote oder vor Ort)
- • Format: Input, Live-Demo, zwei Hands-on-Übungen (Jaeger-Installation, Sampling-Patch & Trace erzeugen; Trace in Jaeger-UI & Kiali gemeinsam interpretieren)
- • Voraussetzungen: abgeschlossenes Modul “Kubernetes Service Mesh Observability — Kiali & der Service-Graph” (Pflicht), lauffähige lokale Docker-Umgebung für Minikube, keine Cloud-Kostenwirkung
Modulaufbau & Agenda
Begrüßung & Einordnung (10 min): Anschluss an den Ausblick des Kiali-Kurses – Kiali zeigt DASS eine Kante Fehler hat, nicht WARUM ein einzelner Request langsam war.
Konzept: Trace, Span & Span-Kontext-Propagation (15 min): eine Trace als Kette von Spans, jeder Span ein Zeitstempel-Paar pro Sidecar-Hop, Weitergabe des Span-Kontexts über HTTP-Header von Hop zu Hop.
Hands-on 1: Jaeger installieren, Sampling patchen & ersten Trace erzeugen (30 min, Hands-on):
samples/addons/jaeger.yamlanwenden, Sampling übermeshConfig.defaultConfig.tracing.samplingauf100patchen, Trace über die bestehende Fault-Injection-Curl-Loop erzeugen.Hands-on 2: Trace in Jaeger-UI & Kiali gemeinsam interpretieren (30 min, Hands-on): denselben Trace über
istioctl dashboard jaegerund über die Kiali-Graph-Verlinkung (“View traces”) öffnen, Latenz Hop für Hop den Sidecars zuordnen.Grenzen: Sampling-Trade-off & fehlendes Storage-Backend (10 min): 100 % Sampling nur für die Demo vertretbar, in Produktion deutlich niedriger; heute nur In-Memory All-in-One, kein produktives Storage-Backend (Elasticsearch/Cassandra).
Ausblick ohne Hands-on & Abschluss (10 min): produktive Jaeger-Storage-Backends (Elasticsearch/Cassandra), OpenTelemetry-Collector als möglicher Jaeger-Ersatz – ausdrücklich nur Ausblick, kein eigenes Hands-on.
Dieses Modul setzt das Aufbaumodul
Kubernetes Service Mesh Observability — Kiali & der Service-Graph
zwingend voraus. Der Service-Graph, die Prometheus-Metrik-Anbindung
sowie die dort verwendete Fault-Injection-Curl-Loop gelten als
bekannt und werden hier nicht erneut hergeleitet – Hands-on 1
installiert Jaeger direkt auf dem dort aufgebauten
Minikube-Cluster neben den bereits laufenden Prometheus-/
Kiali-Addons, Hands-on 2 arbeitet unmittelbar mit derselben
Kiali-Oberfläche weiter. Grundlegende Voraussetzung – über den
Kiali-Kurs bereits transitiv vermittelt – bleibt das Modul
Kubernetes Service Mesh — Traffic-Management mit Istio
: Sidecar-Injection, VirtualService-Fault-Injection und
die Control-Plane istiod, aus der auch die
Sampling-Konfiguration stammt, gelten durchgehend als bekannt.
Was dieses Modul bewusst nicht behandelt: ein produktives Jaeger-Storage-Backend (Elasticsearch oder Cassandra statt des heutigen In-Memory-All-in-One), eine Migration auf den OpenTelemetry-Collector als Jaeger-Ersatz, sowie differenzierte Sampling-Strategien (z. B. Tail-based Sampling) jenseits eines einzelnen festen Prozentwerts. Beide Ausblickpunkte werden in Block 5 und 6 nur konzeptionell eingeordnet, nicht vertieft.
Hands-on Inhalte (Auszug)
Jaeger installieren
- Offizielles Addon-Manifest
samples/addons/jaeger.yamlaus dem bereits vorhandenen Istio-Release-Ordner perkubectl applyanwenden - Jaeger-Pod im Namespace
istio-systemaufRunningverifizieren, bevor mit dem Sampling-Patch fortgefahren wird
Sampling auf 100 patchen
meshConfig.defaultConfig.tracing.samplingperistioctl installauf100setzen – der zentrale, nicht optionale Schritt dieses Hands-on- Betroffene Workloads neu ausrollen, damit die Sidecars die neue Sampling-Konfiguration übernehmen
Ersten Trace erzeugen
- Bestehenden Curl-Loop-Job aus dem Kiali-Kurs gegen die Fault-Injection erneut laufen lassen
- Im Jaeger-UI nach dem
curl-loop-Service suchen und die ersten eingegangenen Traces bestätigen
Trace gemeinsam interpretieren
- Eine Trace im Jaeger-UI öffnen, Span-Wasserfall von Hop zu Hop lesen und die längste Einzelspanne identifizieren
- Dieselbe Trace über die “View traces”-Verlinkung im Kiali-Graph erneut öffnen und beide Ansichten gegeneinander abgleichen
Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit vom ersten sichtbaren Trace bis zur korrekt identifizierten langsamsten Span) 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