Zum Hauptinhalt springen
S-EDV news
← Alle Anleitungen
📘 Anleitung Sicherheit & Datenschutz 05.07.2026 · 9 min Lesezeit Geprüft 11.10.2026

Falco mit Docker installieren: CNCF-Runtime-Security für Container

Falco ist das einzige CNCF-graduierte Runtime-Security-Tool für Container: Es überwacht per eBPF jeden Systemaufruf in Echtzeit und erkennt Shell-Spawning oder Privilege-Escalation sofort. Diese Anleitung zeigt den vollständigen Docker-Compose-Stack mit Falcosidekick und Web-UI.

Werbung Mit * markierte Links sind Werbelinks: Bei einem Kauf erhalten wir eine Provision, der Preis bleibt gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

Titelbild: Falco mit Docker einrichten, Laufzeit, Regeln, Alarme

Container werden meist vor dem Start abgesichert: Images scannen, Ports minimieren, Netzwerke trennen. Was zur Laufzeit geschieht, bleibt oft unbeobachtet. Hier setzt Falco an: Das CNCF-graduierte Open-Source-Tool analysiert per eBPF im Linux-Kernel jeden Systemaufruf aller laufenden Container und meldet es, wenn ein Container eine Shell startet, Rechte eskaliert, auf sensible Dateien zugreift oder unerwartete Verbindungen öffnet.

Voraussetzungen

  • Linux-Host (Ubuntu 22.04+, Debian 12, oder beliebige Linux-VM/NAS mit Docker-Support).
  • Linux-Kernel 5.8+ für den Modern-eBPF-Modus (empfohlen, kein Treiber-Kompilieren nötig). Für ältere Kernel bleibt nur das Kernel-Modul; die Legacy-eBPF-Probe hat Falco mit 0.44 entfernt.
  • Docker Engine 20.10+ und Docker Compose v2 (Plugin-Variante, Befehl docker compose) installiert, siehe Docker und Docker Compose auf Linux installieren.
  • Root- oder sudo-Zugriff: Falco braucht zwingend erhöhte Rechte (privileged: true oder CAP_SYS_ADMIN).
  • Internetzugang vom Host zum Laden der Images.
  • Mindestens 512 MB RAM für Falco, weitere 256 MB für Falcosidekick und Redis.
  • Optional: Reverse Proxy mit HTTPS, wenn die UI aus dem Netz erreichbar sein soll. Sie bringt nur eine einfache Anmeldung mit (Standard admin / admin), die Compose-Datei bindet sie deshalb an 127.0.0.1.

Schritt 1: Projektordner und .env anlegen

Legen Sie einen Projektordner an. Anpassbare Einstellungen, etwa der Slack-Webhook oder das UI-Passwort, stehen in der .env, nicht in der compose.yaml.

$ sudo mkdir -p /opt/falco
$ cd /opt/falco

Erstellen Sie die .env-Datei:

# /opt/falco/.env
# Falcosidekick: optionaler Slack-Webhook für Alert-Weiterleitung
# Leer lassen, wenn kein Slack verwendet wird
SLACK_WEBHOOKURL=

# Weitere Ausgabe-Ziele (optional, Falcosidekick unterstützt >50 Ziele)
# TEAMS_WEBHOOKURL=
# PAGERDUTY_ROUTINGKEY=

# Anmeldung an der Falcosidekick-UI (Benutzer:Passwort), unbedingt ändern
FALCOSIDEKICK_UI_USER=admin:BITTE-AENDERN

Die Datei ist vorhanden und lesbar:

$ ls -la /opt/falco/.env
# Erwartete Ausgabe: -rw-r--r-- 1 root root ... .env

Schritt 2: compose.yaml erstellen

Der Stack besteht aus vier Services: Falco (Kernel-Sensor), Falcosidekick (Alert-Router), Falcosidekick-UI (Dashboard) und Redis Stack (Alert-Speicher). Die UI braucht Redis mit dem Modul RediSearch; ein einfaches redis:7-alpine führt zum Fehler unknown command 'FT.CREATE'. Falco selbst braucht privileged: true und Host-Bind-Mounts für Kernel-Tracing, Docker-Socket und Prozessinformationen.

Die Tabellen fassen Image-Parameter und Mounts vor der compose.yaml zusammen:

ParameterWertHinweis
Image Falcofalcosecurity/falco:0.45.0Stabiles Tag pinnen, nicht :latest
Image Falcosidekickfalcosecurity/falcosidekick:2.35.0Alert-Router, >50 Ausgabe-Ziele
Image Falcosidekick-UIfalcosecurity/falcosidekick-ui:2.3.1Web-Dashboard Port 2802
Image Redisredis/redis-stack-server:7.2.0-v11Redis mit RediSearch, Pflicht für die UI
Port Falcosidekick2345:2345Alert-Eingang von Falco
Port Falcosidekick-UI127.0.0.1:2802:2802Browser-Zugriff auf Dashboard (lokal oder per Reverse Proxy)
Architekturamd64, arm64Offiziell unterstützt (z. B. AWS Graviton)
Volume / MountZweckPflicht
/sys/kernel/tracing:roKernel-Tracing für Modern eBPFJa (Kernel 5.8+)
/var/run/docker.sockContainer-MetadatenJa
/proc:/host/proc:roProzess-InformationenJa
/etc:/host/etc:roHost-Konfiguration für EnrichmentJa
redis_dataAlert-Historie für Falcosidekick-UIEmpfohlen

Erstellen Sie jetzt die vollständige compose.yaml:

# /opt/falco/compose.yaml
services:
  falco:
    image: falcosecurity/falco:0.45.0
    restart: unless-stopped
    # Falco benötigt privilegierten Zugriff für Kernel-Tracing.
    # In Produktion stattdessen: cap_add + cap_drop all (siehe Häufige Fragen).
    privileged: true
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      # Kernel-Tracing für Modern eBPF (Kernel 5.8+ pflicht)
      - /sys/kernel/tracing:/sys/kernel/tracing:ro
      # Docker-Socket für Container-Metadaten
      - /var/run/docker.sock:/host/var/run/docker.sock
      # Prozess-Informationen vom Host
      - /proc:/host/proc:ro
      # Host-Konfiguration für Kontext-Anreicherung
      - /etc:/host/etc:ro
    # Falcosidekick-Verbindung: Falco sendet Alerts per HTTP an Port 2345
    command: >
      falco
      -o "json_output=true"
      -o "http_output.enabled=true"
      -o "http_output.url=http://falcosidekick:2345"
    depends_on:
      - falcosidekick

  falcosidekick:
    image: falcosecurity/falcosidekick:2.35.0
    restart: unless-stopped
    ports:
      - "2345:2345"
    environment:
      - LISTENADDRESS=0.0.0.0
      - LISTENPORT=2345
      # Slack-Webhook aus .env (leer = deaktiviert)
      - SLACK_WEBHOOKURL=${SLACK_WEBHOOKURL:-}
      # Webui aktivieren und Adresse angeben
      - WEBUI_URL=http://falcosidekick-ui:2802
    depends_on:
      - falcosidekick-ui

  falcosidekick-ui:
    image: falcosecurity/falcosidekick-ui:2.3.1
    restart: unless-stopped
    ports:
      # nur lokal erreichbar, von außen über Reverse Proxy oder SSH-Tunnel
      - "127.0.0.1:2802:2802"
    environment:
      # Redis mit RediSearch-Modul ist Pflicht für die UI
      - FALCOSIDEKICK_UI_REDIS_URL=redis:6379
      # Anmeldung aus .env (ohne Angabe gilt admin:admin)
      - FALCOSIDEKICK_UI_USER=${FALCOSIDEKICK_UI_USER}
    depends_on:
      - redis

  redis:
    image: redis/redis-stack-server:7.2.0-v11
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  redis_data:

Die YAML-Syntax ist korrekt (kein Fehler bei der Ausgabe):

$ cd /opt/falco && docker compose config --quiet
# Keine Ausgabe = kein Syntaxfehler

Schritt 3: Stack starten

Starten Sie alle vier Services. Beim ersten Start lädt Docker die Images, das dauert bis zu zwei Minuten. Die Standard-Regeln bringt das Falco-Image mit.

$ cd /opt/falco
$ docker compose up -d

Erwartete Ausgabe (gekürzt):

✔ Network falco_default              Created
✔ Container falco-redis-1            Started
✔ Container falco-falcosidekick-ui-1 Started
✔ Container falco-falcosidekick-1    Started
✔ Container falco-falco-1            Started

Alle Container laufen (Status „Up“):

$ docker compose ps
# NAME                        STATUS
# falco-falco-1               Up X seconds
# falco-falcosidekick-1       Up X seconds
# falco-falcosidekick-ui-1    Up X seconds
# falco-redis-1               Up X seconds

Prüfen Sie außerdem die Falco-Logs auf den geladenen Treiber und die Regelsets:

$ docker compose logs falco | tail -30
# Gesuchte Zeilen (Beispiel):
# Falco version: 0.45.0
# Loading rules from file /etc/falco/falco_rules.yaml
# Starting health webserver with threadiness 4
# Enabled event sources: syscall

Schritt 4: Falcosidekick-UI im Browser öffnen

Die UI lauscht nur auf 127.0.0.1:2802. Öffnen Sie http://localhost:2802 auf dem Server oder per SSH-Tunnel (ssh -L 2802:127.0.0.1:2802 benutzer@server) und melden Sie sich mit den Zugangsdaten aus FALCOSIDEKICK_UI_USER an. Die UI zeigt alle Alerts nach Priorität, Regelname und Container; zu Beginn ist sie leer.

Die UI antwortet per HTTP:

$ curl -s -u admin:BITTE-AENDERN http://localhost:2802/api/v1/healthz
# Erwartete Ausgabe:
# {"status":"ok"}

Falcosidekick selbst ist auf Port 2345 erreichbar:

$ curl -s http://localhost:2345/ping
# Erwartete Ausgabe: pong

Schritt 5: Falco-Erkennung testen

Falco schlägt an, wenn ein Container eine Shell startet, ein häufiges Anzeichen eines Angriffs. Der offizielle event-generator löst gezielt bekannte Regeln aus.

Variante A, einfacher Shell-Test in einem Container:

# Test-Container mit Shell starten
$ docker run -it --rm alpine sh -c "whoami"
# Falco sollte sofort 'Terminal shell in container' loggen

Variante B, offizieller Event-Generator (triggert mehrere Regeln):

$ docker run -it --rm falcosecurity/event-generator run syscall --loop

Alerts erscheinen in den Falco-Logs:

$ docker compose logs falco | grep -i "Warning\|Critical\|Error" | tail -20
# Beispiel-Alert:
# Warning Symlinks created over sensitive files
#   (user=root command=ln -s /etc/shadow /tmp/shadow ...)

In der Falcosidekick-UI unter http://localhost:2802 tauchen die Alerts jetzt ebenfalls auf, mit Zeitstempel, Regelname, Container-ID und Host-Kontext.

Schritt 6: Eigene Regeln einbinden (optional)

Falco liest Regeln aus /etc/falco/falco_rules.yaml und /etc/falco/rules.d/. Eigene Regeln ergänzen die Defaults, ohne sie zu überschreiben. Binden Sie eine Regeldatei per Volume ein:

Beispiel-Regelfile /opt/falco/custom_rules.yaml:

- rule: Curl in Container detected
  desc: Jemand führt curl in einem Container aus
  condition: spawned_process and proc.name = "curl" and container
  output: "curl-Aufruf in Container (user=%user.name cmd=%proc.cmdline container=%container.name)"
  priority: WARNING
  tags: [network, custom]

Ergänzen Sie das Volume in der compose.yaml unter dem falco-Service:

    volumes:
      - /sys/kernel/tracing:/sys/kernel/tracing:ro
      - /var/run/docker.sock:/host/var/run/docker.sock
      - /proc:/host/proc:ro
      - /etc:/host/etc:ro
      # Eigene Regeln:
      - /opt/falco/custom_rules.yaml:/etc/falco/rules.d/custom_rules.yaml:ro

Danach den Falco-Service neu starten:

$ cd /opt/falco && docker compose up -d falco

Falco lädt die eigene Regel:

$ docker compose logs falco | grep "custom_rules"
# Erwartete Ausgabe:
# Loading rules from file /etc/falco/rules.d/custom_rules.yaml

Schritt 7: Updates durchführen

Für Updates passen Sie die festgeschriebenen Tags (Falco 0.45.0, Falcosidekick 2.35.0, UI 2.3.1) nach Prüfung der Release Notes im Falco GitHub-Repository an. Für ein Update-Konzept eignen sich Diun oder WUD als Watchtower-Nachfolger.

$ cd /opt/falco
$ docker compose pull
$ docker compose up -d
$ docker compose ps

Umstieg für Bestandsinstallationen (0.44.x auf 0.45.0)

Wer den Stack nach der früheren Fassung betreibt, ändert vier Punkte:

  1. Falco-Tag in der compose.yaml von 0.44.1 auf 0.45.0 setzen. Breaking Change laut Release Notes: Regelbedingungen werten jetzt die Rohbytes der Felder aus, ungültige UTF-8-Folgen werden erst bei der Ausgabe ersetzt. Prüfen Sie eigene Regeln, die mit Nicht-Regex-Operatoren auf das Ersatzzeichen prüfen; mit docker compose run --rm --entrypoint falco falco -V /etc/falco/rules.d/custom_rules.yaml validieren Sie eine eingebundene Regeldatei. Eine noch gesetzte Option container_engines erzeugt seit 0.45 nur eine Warnung beim Start.
  2. Redis von redis:7-alpine auf redis/redis-stack-server:7.2.0-v11 umstellen. Ohne RediSearch startet die UI nicht (Fehler FT.CREATE).
  3. UI-Port auf 127.0.0.1:2802:2802 und WEBUI_URL=http://falcosidekick-ui:2802 ändern; Port 2346 war falsch, die UI lauscht standardmäßig auf 2802.
  4. UI-Anmeldung über FALCOSIDEKICK_UI_USER in der .env setzen und die Zeile SKIP_DRIVER_LOADER=false entfernen, sie hat im aktuellen Image keine Wirkung.

Danach docker compose pull und docker compose up -d ausführen.

Alle Container laufen mit aktualisierten Images:

$ docker compose ps
$ docker images | grep falco

Troubleshooting / Typische Fehler

„Failed to load the driver“ / „permission denied“ beim Treiberstart

Ursache: privileged: true fehlt oder der Kernel ist älter als 5.8. Lösung: privileged: true ergänzen oder für ältere Kernel das Kernel-Modul nutzen: Treiber mit falcosecurity/falco-driver-loader auf dem Host installieren und -o engine.kind=kmod in den Falco-Startparametern setzen.

„/sys/kernel/tracing: No such file or directory“

Ursache: Ältere Kernels mounten tracefs unter /sys/kernel/debug/tracing. Lösung: Volume-Mount ändern auf /sys/kernel/debug/tracing:/sys/kernel/tracing:ro (so die offizielle Doku).

Falco startet, aber keine Alerts erscheinen

Ursache: Der Treiber ist nicht geladen oder keine Regel passt. Lösung: Prüfen Sie mit docker compose logs falco, ob die Regeln geladen wurden, und lösen Sie mit Variante A aus Schritt 5 einen Alert aus.

„docker.sock: permission denied“

Ursache: Falscher Volume-Pfad. Das Mapping muss exakt /var/run/docker.sock:/host/var/run/docker.sock lauten, nicht /var/run/docker.sock:/var/run/docker.sock.

Falcosidekick zeigt „connection refused“ zu Falco

Ursache: Falco sendet nicht per HTTP an Falcosidekick. Prüfen Sie, ob der command die Flags -o "http_output.enabled=true" und -o "http_output.url=http://falcosidekick:2345" enthält.

„mmap: Operation not permitted“ beim Laden des eBPF-Treibers

Ursache: RLIMIT_MEMLOCK zu niedrig. Lösung: ulimits: memlock: soft: -1 hard: -1 beim falco-Service setzen (im Beispiel enthalten).

ARM64-Host: Kernel-Modul-Treiber steht nicht bereit

Empfehlung: Modern eBPF verwenden (engine.kind=modern_ebpf), das erfordert keine Kompilierung.

„rule file not found“ für eigene Regeln

Ursache: Regelfiles außerhalb von /etc/falco/rules.d/ gemountet.

Häufige Fragen

Braucht Falco eine Datenbank?

Nein. Falco ist zustandslos. Redis dient nur der Falcosidekick-UI, damit die Alert-Historie Neustarts übersteht.

Welcher Treiber-Modus ist empfohlen?

Empfohlen ist Modern eBPF: Es ist im Falco-Binary eingebettet, braucht keine Kompilierung und läuft ab Kernel 5.8. Ubuntu 22.04 und Debian 12 erfüllen das. Für ältere Kernel bleibt das Kernel-Modul (engine.kind=kmod), vorher per falcosecurity/falco-driver-loader auf dem Host installiert.

Kann Falco auf Windows oder macOS laufen?

Nein. Falco greift auf Linux-Kernel-Systemaufrufe zu; das geht unter Windows oder macOS nicht, auch nicht mit Docker Desktop. Sie brauchen einen Linux-Host oder eine Linux-VM.

Wie hoch ist der Performance-Impact?

Laut Falco-Projekt-Benchmarks liegt der CPU-Overhead des Modern-eBPF-Treibers auf einem typischen Produktionssystem unter 3 %, deutlich weniger als klassische Kernel-Module oder User-Space-Agenten.

Kann ich Alerts an Slack, Teams oder PagerDuty weiterleiten?

Ja, dafür ist Falcosidekick da (über 50 Ausgabe-Ziele). Für Slack setzen Sie SLACK_WEBHOOKURL in der .env; Teams (TEAMS_WEBHOOKURL) und PagerDuty (PAGERDUTY_ROUTINGKEY) funktionieren analog.

Sollte ich in Produktion wirklich --privileged verwenden?

Die Anleitung nutzt privileged: true, das dem Container nahezu uneingeschränkten Host-Zugriff gibt. Für Produktion empfiehlt die Falco-Dokumentation Least-Privilege: cap_add: [SYS_ADMIN, SYS_RESOURCE, SYS_PTRACE] mit cap_drop: [ALL]. Mehr dazu in der Anleitung Docker Compose absichern: Secrets, Healthchecks, Non-Root.

Wie überprüfe ich, ob Falco-Images legitim sind?

Alle offiziellen Falco-Container-Images ab Version 0.35.0 sind mit cosign signiert. Sie können die Signatur prüfen mit: cosign verify falcosecurity/falco:0.45.0 --certificate-oidc-issuer=https://token.actions.githubusercontent.com. Sinnvoll ist das in CI/CD-Pipelines vor dem Einspielen eines Images. Mehr dazu in der Anleitung Docker-Images auf Schwachstellen scannen mit Trivy.

Fazit

Falco ergänzt Image-Scanner um die Sicht auf die Laufzeit. Der Stack aus Falco, Falcosidekick und Web-UI ist ein pragmatischer Einstieg für KMU und DevOps-Teams und läuft wartungsarm. Für mehr Tiefe binden Sie Falcosidekick an Elasticsearch oder Grafana Loki an und integrieren die Alerts in bestehendes Monitoring, etwa zusammen mit dem Beszel Server Monitoring.

Weiterführende Anleitungen und Quellen

  1. Docker-Images auf Schwachstellen scannen mit Trivy: CVE-Check, SBOM und automatische Scans
  2. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
  3. Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate
  4. Docker und Docker Compose auf Linux installieren: die Self-Hosting-Grundlage
  5. Linux-Server absichern: UFW-Firewall und Fail2ban

Offizielle Quellen: Falco Container-Deployment-Dokumentation | Falco Docker Quickstart | Falco GitHub-Repository | falcosecurity/falco auf Docker Hub

Passende Anleitungen auf S-EDV

  1. netcup Local Block Storage bestellen, einrichten und unter Linux einbinden
  2. Linux 7.1-rc6 veröffentlicht: Kernel-Entwicklung stabilisiert sich nach KI-bedin
  3. Linux-Kernel CVE-2026-23111: Ein-Zeichen-Fehler in nf_tables ermöglicht lokale R