Tag 20: Tracing und Logs
Ziel: Du filterst Flows mit
hubble observegezielt, exportierst sie als Flow-Log in eine Datei, wertest sie mit jq aus und verfolgst eine Anfrage per Trace-ID durch Hubble und Jaeger. · Dauer: ca. 90 min · Voraussetzung: Tag 12
Briefing
- CKNE: Observability – „Troubleshooting End-to-End Network Performance with Tracing“ und „Auditing Traffic with Logs“.
hubble observeliest den Ringpuffer der Agenten (über Relay) – flüchtig. Für Audits schreibt der Flow-Exporter Flows als JSON-Zeilen in eine Datei auf dem Node.- Läuft HTTP durch Envoy (L7-Policy), liest Hubble den W3C-Header
traceparentmit: Jeder L7-Flow trägt dann die Trace-ID, die auch im Tracing-Backend steht. - Testfeld: HotROD (Demo-App von Jaeger, vier Dienste) und Jaeger v2 als All-in-one mit OTLP-Empfang.
client ─> frontend:8080 ─┬─> customer:8081 (HTTP, "MySQL")
├─> driver:8082 (gRPC)
└─> route:8083 (HTTP)
alle Dienste ── OTLP :4318 ──> jaeger (UI :16686)
Drill 1: Das Testfeld
mkdir -p ~/ckne/tag20 && cd ~/ckne/tag20
k create ns tag20
k config set-context --current --namespace=tag20
k create deployment jaeger --image=jaegertracing/jaeger:2.23.0
k set resources deployment jaeger --limits=memory=512Mi
k expose deployment jaeger --port=4318
E=OTEL_EXPORTER_OTLP_ENDPOINT=http://jaeger:4318
I=jaegertracing/example-hotrod:2.23.0
k run customer --image=$I --env=$E -- customer
k run driver --image=$I --env=$E -- driver
k run route --image=$I --env=$E -- route
k expose pod customer --port=8081
k expose pod driver --port=8082
k expose pod route --port=8083
k run frontend --image=$I --env=$E -- frontend --customer-service-hostname=customer \
--driver-service-hostname=driver --route-service-hostname=route
k expose pod frontend --port=8080
k run client --image=nicolaka/netshoot:v0.16 -- sleep infinity
k wait --for=condition=Ready pod --all
k get pods -o wideErwartet (gekürzt):
NAME READY STATUS RESTARTS AGE IP NODE
client 1/1 Running 0 41s 10.0.2.8 worker2
customer 1/1 Running 0 43s 10.0.2.68 worker2
driver 1/1 Running 0 43s 10.0.2.245 worker2
frontend 1/1 Running 0 41s 10.0.2.37 worker2
jaeger-5c4776b9cd-m8bxl 1/1 Running 0 44s 10.0.2.231 worker2
route 1/1 Running 0 43s 10.0.2.164 worker2
Beide Images sind multi-arch (amd64, arm64). Das OpenTelemetry-SDK in
HotROD liest OTEL_EXPORTER_OTLP_ENDPOINT selbst. Ohne
L7-Policy sieht Hubble nur TCP – also eine CNP, die alles erlaubt, den
HTTP-Verkehr aber durch Envoy leitet:
cat > l7.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
name: hotrod-l7
spec:
endpointSelector:
matchExpressions:
- {key: run, operator: In, values: [frontend, customer, route]}
ingress:
- fromEntities:
- cluster
toPorts:
- ports:
- port: "8080"
protocol: TCP
- port: "8081"
protocol: TCP
- port: "8083"
protocol: TCP
rules:
http:
- {}
EOF
k apply -f l7.yaml
k exec client -- curl -s "http://frontend:8080/dispatch?customer=123"; echo
hubble observe -P --port-forward-port 0 -n tag20 --protocol http --last 4Erwartet (gekürzt; die Identitäts-Nummern weichen
bei dir ab – seit Tag 17 mit cluster.id=1 liegen sie ab
65536, auch in den folgenden Ausgaben):
{"Driver":"T719673C","ETA":120000000000}
Nov 19 00:10:41.058: tag20/client:50630 (ID:34308) -> tag20/frontend:8080 (ID:5937)
http-request FORWARDED (HTTP/1.1 GET http://frontend:8080/dispatch?customer=123)
Nov 19 00:10:41.990: tag20/frontend:53580 (ID:5937) -> tag20/route:8083 (ID:47165)
http-request FORWARDED (HTTP/1.1 GET http://route:8083/route?dropoff=115%2C277&...)
Nov 19 00:10:42.018: tag20/frontend:53600 (ID:5937) <- tag20/route:8083 (ID:47165)
http-response FORWARDED (HTTP/1.1 200 71ms (GET http://route:8083/route?...))
Nov 19 00:10:42.079: tag20/client:50630 (ID:34308) <- tag20/frontend:8080 (ID:5937)
http-response FORWARDED (HTTP/1.1 200 1022ms (GET http://frontend:8080/dispatch?...))
driver spricht gRPC auf 8082 und steht bewusst nicht in
der Policy – für ihn gibt es nur L4-Flows. Die Antwortzeile nennt die
Dauer, gemessen von Envoy zwischen Anfrage und Antwort.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Filter, die du in der Prüfung brauchst
Einen 404 und einen Policy-Drop erzeugen, dann gezielt suchen:
k exec client -- curl -s -w ' %{http_code}\n' \
"http://frontend:8080/dispatch?customer=999"
R=$(k get pod route -o jsonpath='{.status.podIP}')
k exec client -- curl -s -m3 http://$R:9999/; echo "exit=$?"
hubble observe -P --port-forward-port 0 -n tag20 --http-status 4+ --last 2
hubble observe -P --port-forward-port 0 --to-pod tag20/route --verdict DROPPED \
--last 2
hubble observe -P --port-forward-port 0 --pod tag20/customer --protocol http \
--http-path '/customer' --last 2Erwartet (gekürzt):
invalid customer ID
404
exit=28
... tag20/frontend:52478 (ID:5937) <- tag20/customer:8081 (ID:49768) http-response
FORWARDED (HTTP/1.1 404 316ms (GET http://customer:8081/customer?customer=999))
... tag20/client:37696 (ID:34308) <- tag20/frontend:8080 (ID:5937) http-response
FORWARDED (HTTP/1.1 404 331ms (GET http://frontend:8080/dispatch?customer=999))
... tag20/client:45796 (ID:34308) <> tag20/route:9999 (ID:47165)
policy-verdict:none INGRESS DENIED (TCP Flags: SYN)
... tag20/client:45796 (ID:34308) <> tag20/route:9999 (ID:47165) Policy denied
DROPPED (TCP Flags: SYN)
Merkliste: --http-status erwartet einen Präfix
(404, 4+, 5+), nicht
5. --from-pod trifft nur eine Richtung –
Antworten haben den anderen Pod als Quelle; für beide Richtungen
--pod. Weitere Filter: --to-port,
--type l7, --traffic-direction,
--since 5m, --not vor einem Filter kehrt ihn
um.
--follow streamt live – in einem zweiten Terminal dazu
eine Anfrage senden:
timeout 15 hubble observe -P --port-forward-port 0 -f --pod tag20/client --type l7Erwartet (gekürzt):
Nov 19 00:18:16.114: tag20/client:58312 (ID:34308) -> tag20/frontend:8080 (ID:5937)
http-request FORWARDED (HTTP/1.1 GET http://frontend:8080/dispatch?customer=731)
Fortschritt speichern? Kostenlos registrieren
Drill 3: JSON und jq
Die Textausgabe ist für Menschen, -o json für Werkzeuge.
Jede Zeile ist ein Objekt mit dem Flow unter .flow:
hubble observe -P --port-forward-port 0 --to-pod tag20/route --verdict DROPPED \
--last 1 -o json | jq -c '{verdict: .flow.verdict, drop: .flow.drop_reason_desc,
src: .flow.source.pod_name, dst: .flow.destination.pod_name,
port: .flow.l4.TCP.destination_port, dir: .flow.traffic_direction}'
hubble observe -P --port-forward-port 0 -n tag20 --since 2m --type l7 -o json \
| jq -r 'select(.flow.l7.type=="RESPONSE")
| [((.flow.l7.latency_ns // "0") | tonumber / 1e6 | floor), .flow.l7.http.code,
.flow.destination.pod_name, (.flow.l7.http.url | split("?")[0])] | @tsv' \
| sort -rn | head -4Erwartet (gekürzt):
{"verdict":"DROPPED","drop":"POLICY_DENIED","src":"client","dst":"route","port":9999,
"dir":"INGRESS"}
604 200 client http://frontend:8080/dispatch
534 200 client http://frontend:8080/dispatch
97 200 frontend http://customer:8081/customer
83 200 frontend http://route:8083/route
Die zweite Abfrage ist eine Latenz-Hitliste in Millisekunden. Bei
Antworten ist destination der ursprüngliche Aufrufer – der
Server steht in der URL.
Einen Mitschnitt kannst du speichern und später offline filtern;
--print-raw-filters zeigt die Filter als JSON, wie sie auch
Exporter verstehen:
hubble observe -P --port-forward-port 0 -n tag20 --last 300 -o jsonpb > mitschnitt.json
hubble observe --input-file mitschnitt.json --pod tag20/customer --protocol http \
| tail -1
hubble observe --input-file mitschnitt.json --print-raw-filters \
--to-pod tag20/customer --http-status 200Erwartet (gekürzt):
... tag20/frontend:52478 (ID:5937) <- tag20/customer:8081 (ID:49768) http-response
FORWARDED (HTTP/1.1 200 328ms (GET http://customer:8081/customer?customer=567))
allowlist:
- '{"destination_pod":["tag20/customer"],"http_status_code":["200"]}'
Fortschritt speichern? Kostenlos registrieren
Drill 4: Flow-Logs in eine Datei exportieren
Cilium kennt zwei Exporter: den statischen
(hubble.export.static.*, eine Datei, Filter per
allowList/denyList, Änderung = Agent-Neustart)
und den dynamischen
(hubble.export.dynamic.*, mehrere Exporter aus einer
ConfigMap, laut Doku ohne Neustart änderbar). Hier der dynamische, nur
für tag20:
cat > flowlog.yaml <<'EOF'
hubble:
export:
dynamic:
enabled: true
config:
content:
- name: tag20
filePath: /var/run/cilium/hubble/tag20.log
fieldMask: [time, node_name, IP, source, destination, l4, l7, Type,
event_type, is_reply, verdict, drop_reason_desc, trace_context]
includeFilters:
- source_pod: ["tag20/"]
- destination_pod: ["tag20/"]
fileMaxSizeMb: 5
fileMaxBackups: 2
EOF
helm get values cilium -n kube-system -o yaml > values-vorher.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
--reuse-values -f flowlog.yaml
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait
cilium config view | grep flowlogsErwartet:
hubble-flowlogs-config-path /flowlog-config/flowlogs.yaml
Den Inhalt legt Helm in die ConfigMap
cilium-flowlog-config, die Agenten lesen sie als Datei.
Zwei Einträge unter includeFilters sind ODER-verknüpft
(Quelle oder Ziel in tag20), Felder
innerhalb eines Eintrags UND. fieldMask schreibt nur die
genannten Felder – spart Platz, die Datei rotiert bei 5 MB. Ein paar
Anfragen und den Drop aus Drill 2 wiederholen, dann die Datei vom Node
holen (/var/run/cilium ist ein hostPath):
k exec client -- curl -s -o /dev/null "http://frontend:8080/dispatch?customer=731"
k exec client -- curl -s -m3 http://$R:9999/
N=$(k get pod client -o jsonpath='{.status.hostIP}'); echo $N
ssh ubuntu@$N "sudo ls -la /var/run/cilium/hubble/"
ssh ubuntu@$N "sudo cat /var/run/cilium/hubble/tag20.log" > w2.log
wc -l < w2.logErwartet (gekürzt):
172.16.0.83
-rw-r--r-- 1 root root 879009 Nov 19 00:18 tag20.log
842
Das Log kommt vom Node, auf dem client läuft (hier
worker2). Jeder Node schreibt nur die Flows, die er selbst sieht – für
ein vollständiges Audit sammelt ein Log-Agent (Fluent Bit, Vector) die
Dateien aller Nodes ein.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Flow-Logs auswerten
jq -r '.flow.verdict' w2.log | sort | uniq -c
jq -r 'select(.flow.verdict=="DROPPED") | [.flow.time[11:19],
.flow.source.pod_name, .flow.destination.pod_name,
.flow.l4.TCP.destination_port, .flow.drop_reason_desc] | @tsv' w2.log | tail -3
jq -r 'select(.flow.l7.type=="RESPONSE") | [.flow.l7.http.code,
((.flow.l7.latency_ns // "0") | tonumber / 1e6 | floor), .flow.l7.http.url]
| @tsv' w2.log | sort -k2 -rn | head -3Erwartet (gekürzt):
6 DROPPED
826 FORWARDED
10 REDIRECTED
... client route 9999 POLICY_DENIED
... client route 9999 POLICY_DENIED
... client route 9999 POLICY_DENIED
200 338 http://customer:8081/customer?customer=731
200 76 http://route:8083/route?dropoff=728%2C326&pickup=118%2C403
200 73 http://route:8083/route?dropoff=728%2C326&pickup=193%2C753
Das ist der Audit-Weg: Wer wollte wann wohin und wurde abgewiesen?
REDIRECTED sind Pakete, die Cilium an den Envoy-Proxy
umgeleitet hat. Die fieldMask lässt Felder weg, die
hubble observe --input-file für seine Textausgabe braucht –
gefilterte Logs wertest du deshalb mit jq aus, volle Mitschnitte
(-o jsonpb) mit Hubble.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Eine Anfrage Ende-zu-Ende verfolgen
Der Client setzt selbst einen traceparent-Header
(Version 00, 32 Hex-Zeichen Trace-ID, 16 Hex-Zeichen Span-ID, Flags 01 =
gesampelt). HotROD übernimmt den Kontext und reicht ihn an alle
Folgeaufrufe weiter:
T=$(openssl rand -hex 16); echo $T
k exec client -- curl -s -H "traceparent: 00-$T-$(openssl rand -hex 8)-01" \
"http://frontend:8080/dispatch?customer=392"; echo
hubble observe -P --port-forward-port 0 --trace-id $T --type l7 --last 50 \
| grep -E 'frontend:8080|customer:8081'
hubble observe -P --port-forward-port 0 --trace-id $T --last 100 | wc -lErwartet (gekürzt):
836320fff67bc710f9a9de0a07f63eb0
{"Driver":"T737132C","ETA":120000000000}
... tag20/client:43504 (ID:34308) -> tag20/frontend:8080 (ID:5937) http-request
FORWARDED (HTTP/1.1 GET http://frontend:8080/dispatch?customer=392)
... tag20/frontend:57668 (ID:5937) -> tag20/customer:8081 (ID:49768) http-request
FORWARDED (HTTP/1.1 GET http://customer:8081/customer?customer=392)
... tag20/frontend:57668 (ID:5937) <- tag20/customer:8081 (ID:49768) http-response
FORWARDED (HTTP/1.1 200 310ms (GET http://customer:8081/customer?customer=392))
... tag20/client:43504 (ID:34308) <- tag20/frontend:8080 (ID:5937) http-response
FORWARDED (HTTP/1.1 200 733ms (GET http://frontend:8080/dispatch?customer=392))
24
24 Flows tragen dieselbe Trace-ID. In JSON steht sie unter
.flow.trace_context.parent.trace_id. Jetzt dieselbe ID in
Jaeger:
k port-forward --address 0.0.0.0 deploy/jaeger 16686 &
curl -s localhost:16686/api/traces/$T | jq -r '.data[0]
| (.spans | length | tostring) + " spans",
([.processes[].serviceName] | unique | join(",")),
(.spans | sort_by(.startTime) | .[0:6][]
| .operationName + " " + ((.duration / 1000) | tostring) + "ms")'Erwartet (gekürzt):
39 spans
customer,driver,frontend,mysql,redis-manual,route
GET /customer 306.978ms
GET /dispatch 728.756ms
HTTP GET 314.03ms
SQL SELECT 305.269ms
driver.DriverService/FindNearest 198.022ms
FindDriverIDs 23.546ms
Im Browser: http://172.16.0.126:16686, Suche nach
Trace-ID. Hubble zeigt, welche Pods miteinander sprachen und was das
Netz sah; Jaeger zeigt, was in den Diensten passierte. Beenden mit
kill %1.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Latenz – Netz oder Anwendung?
Hubble meldet für /customer rund 310 ms. Liegt das am
Netz? Ein direkter Aufruf mit curl-Zeitmessung, danach alle Flows dieser
Verbindung:
k exec client -- curl -s -o /dev/null \
-w 'connect=%{time_connect}s ttfb=%{time_starttransfer}s\n' \
"http://customer:8081/customer?customer=392"
hubble observe -P --port-forward-port 0 --from-pod tag20/client \
--to-pod tag20/customer --last 6Erwartet (gekürzt):
connect=0.036364s ttfb=0.381505s
Nov 19 00:24:39.468: tag20/client:40734 ... policy-verdict:L4-Only INGRESS ALLOWED
(TCP Flags: SYN)
Nov 19 00:24:39.469: tag20/client:40734 ... to-proxy FORWARDED (TCP Flags: SYN)
Nov 19 00:24:39.469: tag20/client:40734 ... to-proxy FORWARDED (TCP Flags: ACK)
Nov 19 00:24:39.471: tag20/client:40734 ... http-request FORWARDED (HTTP/1.1 GET
http://customer:8081/customer?customer=392)
Nov 19 00:24:39.815: tag20/client:40734 ... to-proxy FORWARDED (TCP Flags: ACK, FIN)
Vom SYN (.468) bis zur fertigen HTTP-Anfrage (.471) vergehen 3 ms –
Handshake und Policy-Prüfung. Bis zur Antwort (.815) vergehen dann 340
ms im Dienst (connect enthält bei curl auch die
DNS-Auflösung). Jaeger bestätigt: SQL SELECT 305 ms. Also
kein Netzproblem – HotROD simuliert eine langsame Datenbank. Die
Trace-ID tragen übrigens nur die L7-Flows; TCP-Flows haben keinen
trace_context.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige alle HTTP-Antworten mit Status 4xx in
tag20der letzten 5 Minuten. Zeitziel: 30 s - Zeige die letzten 3 verworfenen Flows zu
tag20/routeals JSON mit nur Quelle, Port und Grund. Zeitziel: 60 s - Zeige alle Flows einer Trace-ID mit Node-Namen. Zeitziel: 30 s
Lösung
hubble observe -P --port-forward-port 0 -n tag20 --since 5m --http-status 4+
hubble observe -P --port-forward-port 0 --to-pod tag20/route --verdict DROPPED \
--last 3 -o json | jq -c '{src: .flow.source.pod_name,
port: .flow.l4.TCP.destination_port, drop: .flow.drop_reason_desc}'
hubble observe -P --port-forward-port 0 --trace-id $T --print-node-name --last 100Erwartet (gekürzt):
... http-response FORWARDED (HTTP/1.1 404 316ms (GET http://customer:8081/...))
{"src":"client","port":9999,"drop":"POLICY_DENIED"}
Nov 19 ... [worker2]: tag20/client:43504 (ID:34308) -> tag20/frontend:8080 ...
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
$T ist die Trace-ID aus Drill 6 – in einer neuen Shell
neu erzeugen (Drill 6).
hubble observe -P --port-forward-port 0 -n tag20 --protocol http --last 1Erwartet: eine Zeile http-request oder
http-response mit URL – L7-Sicht steht.
hubble observe -P --port-forward-port 0 --trace-id $T --last 100 | wc -lErwartet: eine Zahl größer 0 (hier 24).
jq -r 'select(.flow.verdict=="DROPPED") | .flow.drop_reason_desc' w2.log | uniq -cErwartet: eine Zeile mit POLICY_DENIED
– der Drop aus Drill 2 steht im Flow-Log.
Challenge
Starte customer mit einer schnelleren „Datenbank“
(HotROD-Flag --fix-db-query-delay, Standard 300ms) neu und
weise die Verbesserung mit Hubble nach.
Hinweis: Das Flag gehört hinter das Unterkommando
customer; der Service bleibt, weil der neue Pod wieder
run=customer trägt.
Lösung
k delete pod customer
k run customer --image=$I --env=$E -- customer --fix-db-query-delay=50ms
k wait --for=condition=Ready pod/customer
k exec client -- curl -s "http://frontend:8080/dispatch?customer=123"; echo
hubble observe -P --port-forward-port 0 --pod tag20/customer --protocol http --last 1Erwartet (gekürzt):
{"Driver":"T783804C","ETA":120000000000}
... tag20/frontend:54432 (ID:5937) <- tag20/customer:8081 (ID:49768) http-response
FORWARDED (HTTP/1.1 200 97ms (GET http://customer:8081/customer?customer=123))
Von 310 ms auf 97 ms – messbar, ohne die Anwendung selbst zu instrumentieren.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Der Flow-Exporter geht zurück, die Log-Dateien auf den Nodes werden gelöscht:
k delete namespace tag20
k config set-context --current --namespace=default
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reset-values \
-f values-vorher.yaml
helm get values cilium -n kube-system | grep -c export
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait
sudo sh -c 'rm -f /var/run/cilium/hubble/tag20.log*'
ssh [email protected] "sudo sh -c 'rm -f /var/run/cilium/hubble/tag20.log*'"
ssh [email protected] "sudo sh -c 'rm -f /var/run/cilium/hubble/tag20.log*'"
ssh [email protected] "sudo ls /var/run/cilium/hubble/"
k -n kube-system get cm cilium-flowlog-configErwartet: 0 (keine Exporter-Werte mehr
in Helm), keine Ausgabe von sudo ls (Verzeichnis leer) und
Error from server (NotFound): configmaps "cilium-flowlog-config" not found.
Prometheus und Grafana aus Tag 19 bleiben für die Probeprüfung (Anhang
B, Aufgabe 17).
Prüfungstipp
hubble observe --helpist die beste Doku im Terminal – Filter wie--http-status,--trace-id,--verdict,--to-portstehen dort mit Beispielen.- Keine L7-Flows? Dann fehlt eine L7-Regel (
http: [{}],dns) – Hubble sieht sonst nur L3/L4.--from-podfiltert nur eine Richtung. - Doku: docs.cilium.io „Inspecting Network Flows with the CLI“, „Configuring Hubble exporter“, „Layer 7 Protocol Visibility“.
Enterprise-Notiz
- Flow-Logs gehören in ein zentrales System (Loki, Elasticsearch,
SIEM) – per Log-Agent als DaemonSet, Rotation über
fileMaxSizeMb/fileMaxBackups. - Filter und
fieldMaskstreng setzen: alle Flows aller Pods sind schnell Gigabytes pro Tag; für Audits meist DROPPED plus Zugriffe auf sensible Namespaces. - L7-Sicht kostet: Jeder Flow durch Envoy addiert Latenz und CPU – gezielt pro Workload einschalten, nicht clusterweit.
- Trace-Kontext muss die Anwendung weiterreichen (OpenTelemetry-SDK); Hubble liest nur mit, erzeugt aber selbst keine Spans.
- Hubble Timescape (Isovalent Enterprise) speichert Flows dauerhaft und macht sie rückwirkend abfragbar.