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

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: trueoder 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 an127.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/falcoErstellen 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-AENDERNDie Datei ist vorhanden und lesbar:
$ ls -la /opt/falco/.env# Erwartete Ausgabe: -rw-r--r-- 1 root root ... .envSchritt 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:
| Parameter | Wert | Hinweis |
|---|---|---|
| Image Falco | falcosecurity/falco:0.45.0 | Stabiles Tag pinnen, nicht :latest |
| Image Falcosidekick | falcosecurity/falcosidekick:2.35.0 | Alert-Router, >50 Ausgabe-Ziele |
| Image Falcosidekick-UI | falcosecurity/falcosidekick-ui:2.3.1 | Web-Dashboard Port 2802 |
| Image Redis | redis/redis-stack-server:7.2.0-v11 | Redis mit RediSearch, Pflicht für die UI |
| Port Falcosidekick | 2345:2345 | Alert-Eingang von Falco |
| Port Falcosidekick-UI | 127.0.0.1:2802:2802 | Browser-Zugriff auf Dashboard (lokal oder per Reverse Proxy) |
| Architektur | amd64, arm64 | Offiziell unterstützt (z. B. AWS Graviton) |
| Volume / Mount | Zweck | Pflicht |
|---|---|---|
| /sys/kernel/tracing:ro | Kernel-Tracing für Modern eBPF | Ja (Kernel 5.8+) |
| /var/run/docker.sock | Container-Metadaten | Ja |
| /proc:/host/proc:ro | Prozess-Informationen | Ja |
| /etc:/host/etc:ro | Host-Konfiguration für Enrichment | Ja |
| redis_data | Alert-Historie für Falcosidekick-UI | Empfohlen |
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 SyntaxfehlerSchritt 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 -dErwartete 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 StartedAlle 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 secondsPrü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: syscallSchritt 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: pongSchritt 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' loggenVariante B, offizieller Event-Generator (triggert mehrere Regeln):
$ docker run -it --rm falcosecurity/event-generator run syscall --loopAlerts 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:roDanach den Falco-Service neu starten:
$ cd /opt/falco && docker compose up -d falcoFalco lädt die eigene Regel:
$ docker compose logs falco | grep "custom_rules"# Erwartete Ausgabe:
# Loading rules from file /etc/falco/rules.d/custom_rules.yamlSchritt 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 psUmstieg für Bestandsinstallationen (0.44.x auf 0.45.0)
Wer den Stack nach der früheren Fassung betreibt, ändert vier Punkte:
- Falco-Tag in der
compose.yamlvon0.44.1auf0.45.0setzen. 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; mitdocker compose run --rm --entrypoint falco falco -V /etc/falco/rules.d/custom_rules.yamlvalidieren Sie eine eingebundene Regeldatei. Eine noch gesetzte Optioncontainer_engineserzeugt seit 0.45 nur eine Warnung beim Start. - Redis von
redis:7-alpineaufredis/redis-stack-server:7.2.0-v11umstellen. Ohne RediSearch startet die UI nicht (FehlerFT.CREATE). - UI-Port auf
127.0.0.1:2802:2802undWEBUI_URL=http://falcosidekick-ui:2802ändern; Port 2346 war falsch, die UI lauscht standardmäßig auf 2802. - UI-Anmeldung über
FALCOSIDEKICK_UI_USERin der.envsetzen und die ZeileSKIP_DRIVER_LOADER=falseentfernen, 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 falcoTroubleshooting / Typische Fehler
- „Failed to load the driver“ / „permission denied“ beim Treiberstart
Ursache:
privileged: truefehlt oder der Kernel ist älter als 5.8. Lösung:privileged: trueergänzen oder für ältere Kernel das Kernel-Modul nutzen: Treiber mitfalcosecurity/falco-driver-loaderauf dem Host installieren und-o engine.kind=kmodin 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.socklauten, 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
commanddie 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: -1beimfalco-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
- Docker-Images auf Schwachstellen scannen mit Trivy: CVE-Check, SBOM und automatische Scans
- Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
- Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate
- Docker und Docker Compose auf Linux installieren: die Self-Hosting-Grundlage
- Linux-Server absichern: UFW-Firewall und Fail2ban
Offizielle Quellen: Falco Container-Deployment-Dokumentation | Falco Docker Quickstart | Falco GitHub-Repository | falcosecurity/falco auf Docker Hub


