Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 20: Tracing und Logs

Ziel: Du filterst Flows mit hubble observe gezielt, 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 observe liest 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 traceparent mit: 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 wide

Erwartet (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 4

Erwartet (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 2

Erwartet (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 l7

Erwartet (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 -4

Erwartet (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 200

Erwartet (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 flowlogs

Erwartet:

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.log

Erwartet (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 -3

Erwartet (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 -l

Erwartet (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 6

Erwartet (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

  1. Zeige alle HTTP-Antworten mit Status 4xx in tag20 der letzten 5 Minuten. Zeitziel: 30 s
  2. Zeige die letzten 3 verworfenen Flows zu tag20/route als JSON mit nur Quelle, Port und Grund. Zeitziel: 60 s
  3. 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 100

Erwartet (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 1

Erwartet: 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 -l

Erwartet: eine Zahl größer 0 (hier 24).

jq -r 'select(.flow.verdict=="DROPPED") | .flow.drop_reason_desc' w2.log | uniq -c

Erwartet: 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 1

Erwartet (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-config

Erwartet: 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 --help ist die beste Doku im Terminal – Filter wie --http-status, --trace-id, --verdict, --to-port stehen dort mit Beispielen.
  • Keine L7-Flows? Dann fehlt eine L7-Regel (http: [{}], dns) – Hubble sieht sonst nur L3/L4. --from-pod filtert 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 fieldMask streng 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.