Ausgehenden Container-Traffic mit Tetragon überwachen (ohne Kubernetes)

TL;DR

Wie ich Cilium Tetragon, einen kleinen Docker-Container-Mapper und Fluent Bit nutze, um ausgehende TCP/UDP-Verbindungen meiner Container auf einem reinen Docker-Host zu überwachen – ganz ohne Kubernetes.

Wenn Du mehrere Docker-Container auf einem VPS oder Homeserver betreibst, weißt Du meistens sehr genau, welche Ports eingehend offen sind. Aber weißt Du auch, wohin Deine Container ausgehend Verbindungen aufbauen?

Ich wollte genau diese Sichtbarkeit für ausgehenden Netzwerk-Traffic auf meinem Docker-Host – und zwar mit Cilium Tetragon (eBPF-basierte Security-Observability). Die meisten Tutorials gehen allerdings von Kubernetes aus, wo Tetragon Events automatisch mit Pod- und Namespace-Namen anreichert. Auf einem reinen Docker-Host bekommst Du erstmal nur rohe Container-IDs.

Hier ist mein schlankes Setup mit drei Containern in einer docker-compose.yml.

Die Architektur

Mein Stack in /docker/tetragon besteht aus drei Services:

  1. tetragon (quay.io/cilium/tetragon:v1.3.0): Hängt sich per eBPF im Kernel an tcp_connect und udp_sendmsg und schreibt PROCESS_KPROBE-Events in eine rotierende Logdatei.
  2. container-mapper (docker:cli): Eine kleine Schleife, die alle 10 Sekunden ID -> Name aus docker ps -a --no-trunc in containers.map schreibt.
  3. fluent-bit (fluent/fluent-bit:latest): Liest tetragon.log, reichert die Events per Lua-Skript (enrich_container.lua) mit dem Container-Namen aus containers.map an und schickt das JSON weiter an meinen Log-Collector.

Rauschen rausfiltern mit einer TracingPolicy

Wenn Du einfach jedes tcp_connect und udp_sendmsg auf dem Host mitschneidest, bekommst Du extrem viel Rauschen (Localhost, Docker-Bridges, WireGuard usw.). In tetragon.tp.d/external-network.yaml nutze ich deshalb eine TracingPolicy mit NotDAddr-Selektoren, um private, Loopback- und Link-Local-Netze sowie die eigene öffentliche IP zu ignorieren:

apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: external-network-tracing
spec:
  kprobes:
    - call: "tcp_connect"
      syscall: false
      args:
        - index: 0
          type: "sock"
      selectors:
        - matchArgs:
            - index: 0
              operator: "NotDAddr"
              values:
                - "0.0.0.0/8"
                - "127.0.0.0/8"
                - "10.0.0.0/8"
                - "172.16.0.0/12"
                - "192.168.0.0/16"
                - "169.254.0.0/16"
                - "::/128"
                - "::1/128"
                - "fc00::/7"
                - "fe80::/10"

Außerdem schränke ich den Export in Tetragon auf PROCESS_KPROBE-Events ein (--export-allowlist={"event_set":["PROCESS_KPROBE"]}) und aktiviere Log-Rotation (50 MB, 5 Backups, komprimiert).

Das Docker-Compose-Setup

services:
  tetragon:
    image: quay.io/cilium/tetragon:v1.3.0
    container_name: tetragon
    restart: unless-stopped
    privileged: true
    pid: host
    network_mode: host
    command:
      - --tracing-policy-dir=/etc/tetragon/tetragon.tp.d
      - --export-filename=/var/run/tetragon/tetragon.log
      - --export-file-max-size-mb=50
      - --export-file-max-backups=5
      - --export-file-compress=true
      - --export-allowlist={"event_set":["PROCESS_KPROBE"]}
      - --metrics-server=
      - --health-server-address=127.0.0.1:6789
    volumes:
      - /sys/kernel/btf/vmlinux:/var/lib/tetragon/btf:ro
      - /docker/tetragon/tetragon.tp.d:/etc/tetragon/tetragon.tp.d:ro
      - /docker/tetragon/log:/var/run/tetragon

  container-mapper:
    image: docker:cli
    container_name: tetragon-container-mapper
    restart: unless-stopped
    entrypoint: ["/bin/sh", "-c"]
    command:
      - "while true; do docker ps -a --no-trunc --format '\t' > /out/containers.map.tmp && mv /out/containers.map.tmp /out/containers.map; sleep 10; done"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /docker/tetragon:/out

  fluent-bit:
    image: fluent/fluent-bit:latest
    container_name: tetragon-fluent-bit
    restart: unless-stopped
    network_mode: host
    depends_on:
      - tetragon
      - container-mapper
    volumes:
      - /docker/tetragon/log:/var/run/tetragon:ro
      - /docker/tetragon/fluent-bit.conf:/fluent-bit/etc/fluent-bit.conf:ro
      - /docker/tetragon/fluent-bit-db:/var/run/fluent-bit
      - /docker/tetragon/enrich_container.lua:/fluent-bit/etc/enrich_container.lua:ro
      - /docker/tetragon/containers.map:/fluent-bit/etc/containers.map:ro

Was mir gefällt (und worauf Du achten solltest)

  • Keine Änderungen an Apps nötig: eBPF läuft direkt im Kernel – meine anderen Container brauchen weder Sidecars noch spezielle Flags.
  • Lesbare Logs: Der Trick mit container-mapper + enrich_container.lua ist super simpel und liefert echte Container-Namen statt 64-stelliger Hex-IDs.
  • Privilegierter Modus: Tetragon braucht privileged: true, pid: host und /sys/kernel/btf/vmlinux (read-only). Das ist bei eBPF-Tools normal, sollte man aber im Hinterkopf behalten.

Insgesamt läuft das Setup völlig unauffällig im Hintergrund und liefert mir einen sauberen Feed über jede ausgehende Verbindung vom Server.

Share this post: