---
title: "Falco mit Docker installieren: CNCF-Runtime-Security für Container"
date: 2026-07-05T07:14:06+02:00
modified: 2026-11-10T18:14:29+01:00
category: sicherheit
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/falco-docker-runtime-security
reading_time: 9
variables:
  - name: falcosidekick_ui_password
    label: "Passwort (falcosidekick ui password)"
    generated_in_browser: true
---

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

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{falcosidekick_ui_password}}` | Passwort (falcosidekick ui password) | wird im Browser des Lesers zufällig erzeugt |

Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten, statt die Befehle selbst umzuschreiben.

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.

**Kurzfassung:** Falco läuft als privilegierter Container auf einem Linux-Host (Kernel 5.8+ für Modern eBPF) mit Zugriff auf Kernel-Tracing, Docker-Socket, /proc und /etc. Zusammen mit Falcosidekick (Alert-Router) und der Falcosidekick-UI (Dashboard, Port 2802) entsteht per Docker Compose ein vollständiger Runtime-Security-Stack. Einstellungen stehen in der `.env`; nach `docker compose up -d` zeigt `docker compose logs falco` die Alerts. Docker Desktop auf Windows oder macOS wird nicht unterstützt.

## 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](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] **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`.

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

Erstellen Sie die `.env`-Datei:

Datei: `.env`

```ini
# /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:{{falcosidekick_ui_password}}
```

> **Prüfen:** Die Datei ist vorhanden und lesbar:
>
> ```bash
> $ ls -la /opt/falco/.env
> ```
>
> ```bash
> # 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:

| 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`:

Datei: `compose.yaml`

```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:
```

> **Prüfen:** Die YAML-Syntax ist korrekt (kein Fehler bei der Ausgabe):
>
> ```bash
> $ cd /opt/falco && docker compose config --quiet
> ```
>
> ```bash
> # 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.

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

Erwartete Ausgabe (gekürzt):

```bash
✔ 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
```

> **Prüfen:** Alle Container laufen (Status „Up“):
>
> ```bash
> $ docker compose ps
> ```
>
> ```bash
> # 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:

```bash
$ docker compose logs falco | tail -30
```

```bash
# 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.

> **Prüfen:** Die UI antwortet per HTTP:
>
> ```bash
> $ curl -s -u admin:{{falcosidekick_ui_password}} http://localhost:2802/api/v1/healthz
> ```
>
> ```bash
> # Erwartete Ausgabe:
> # {"status":"ok"}
> ```

Falcosidekick selbst ist auf Port 2345 erreichbar:

```bash
$ curl -s http://localhost:2345/ping
```

```bash
# 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:

```bash
# Test-Container mit Shell starten
```

```bash
$ docker run -it --rm alpine sh -c "whoami"
```

```bash
# Falco sollte sofort 'Terminal shell in container' loggen
```

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

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

> **Prüfen:** Alerts erscheinen in den Falco-Logs:
>
> ```bash
> $ docker compose logs falco | grep -i "Warning\|Critical\|Error" | tail -20
> ```
>
> ```bash
> # 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`:

Datei: `/opt/falco/custom_rules.yaml`

```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:

```yaml
    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:

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

> **Prüfen:** Falco lädt die eigene Regel:
>
> ```bash
> $ docker compose logs falco | grep "custom_rules"
> ```
>
> ```bash
> # 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](https://github.com/falcosecurity/falco) an. Für ein Update-Konzept eignen sich [Diun oder WUD als Watchtower-Nachfolger](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud).

```bash
$ 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.

> **Prüfen:** Alle Container laufen mit aktualisierten Images:
>
> ```bash
> $ 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](https://s-edv.com/anleitungen/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](https://s-edv.com/anleitungen/docker-images-scannen-trivy-schwachstellen-sbom).

## 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](https://s-edv.com/anleitungen/beszel-server-monitoring-docker-installieren).

## Weiterführende Anleitungen und Quellen

1. [Docker-Images auf Schwachstellen scannen mit Trivy: CVE-Check, SBOM und automatische Scans](https://s-edv.com/anleitungen/docker-images-scannen-trivy-schwachstellen-sbom)
2. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
3. [Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud)
4. [Docker und Docker Compose auf Linux installieren: die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
5. [Linux-Server absichern: UFW-Firewall und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban)

**Offizielle Quellen:** [Falco Container-Deployment-Dokumentation](https://falco.org/docs/setup/container/) | [Falco Docker Quickstart](https://falco.org/docs/getting-started/falco-docker-quickstart/) | [Falco GitHub-Repository](https://github.com/falcosecurity/falco) | [falcosecurity/falco auf Docker Hub](https://hub.docker.com/r/falcosecurity/falco)

## Passende Anleitungen auf S-EDV

1. [netcup Local Block Storage bestellen, einrichten und unter Linux einbinden](https://s-edv.com/anleitungen/netcup-local-block-storage-bestellen-linux-einbinden)
2. [Linux 7.1-rc6 veröffentlicht: Kernel-Entwicklung stabilisiert sich nach KI-bedin](https://s-edv.com/news/linux-7-1-rc6-stabilitaet-ki-turbulenzen-juni-2026)
3. [Linux-Kernel CVE-2026-23111: Ein-Zeichen-Fehler in nf_tables ermöglicht lokale R](https://s-edv.com/news/linux-kernel-cve-2026-23111-nftables-use-after-free-root-exploit)
