Frigate ist eine selbst gehostete NVR-Software (Network Video Recorder) mit lokaler KI-Objekterkennung in Echtzeit. Statt Bewegungsmelder, die bei jedem Blatt im Wind auslösen, erkennt Frigate direkt auf deinem Server, ob eine Person, ein Auto oder ein anderes Objekt im Bild ist – und das komplett ohne Cloud. Aufnahmen, Snapshots und die komplette Auswertung bleiben auf deiner eigenen Hardware. In dieser Anleitung richtest du Frigate per Docker Compose ein, bindest deine RTSP-Kameras an, aktivierst Hardware-Beschleunigung (Intel iGPU, Google Coral oder NVIDIA) und sicherst die Installation gegen Datenverlust ab. Zielgruppe sind Admins im Mittelstand und ambitionierte Heimserver-Nutzer.

Kurzfassung: Verzeichnisse anlegen, compose.yaml mit Image ghcr.io/blakeblackshear/frigate:stable und shm_size: "512mb" erstellen, config/config.yml mit RTSP-Kamera und Detector befüllen, dann starten und das erzeugte Admin-Passwort aus dem Log lesen:

mkdir -p /opt/frigate/config /opt/frigate/storage
docker compose up -d
docker logs frigate    # admin-Passwort steht im Log

Danach die Web-UI unter https://SERVER-IP:8971 öffnen und mit dem Benutzer admin anmelden.

Voraussetzungen

Bevor du loslegst, sollte folgendes vorhanden sein:

Linux-Server mit Docker und Docker Compose (Debian 12 oder Ubuntu 24.04). Eine gute, sparsame Basis ist z. B. ein Mini-PC mit Intel N100.
Mindestens eine IP-Kamera mit RTSP. Das ist Pflicht – ohne RTSP-Stream läuft Frigate nicht. Idealerweise liefert die Kamera einen Substream (niedrige Auflösung, ca. 1280x720 bei 5 fps) für die Erkennung und den Hauptstream für die Aufnahme.
RAM/CPU: mindestens 4 GB RAM, besser 8 GB; eine moderne CPU mit integrierter Grafik (Intel iGPU) reicht für mehrere Kameras.
Optional KI-Beschleuniger: Intel iGPU (OpenVINO, im Standard-Image enthalten), Google Coral TPU oder eine NVIDIA-GPU. Reine CPU-Erkennung funktioniert, kostet aber spürbar Last.
Schneller Speicher: Aufnahmen gehören auf eine SSD oder ein NAS, nicht auf eine SD-Karte oder einen Consumer-USB-Stick.
Optional: ein Reverse-Proxy und eine Domain, falls du Frigate sauber über HTTPS von außen erreichbar machen willst.

Die Grundlagen zu Compose-Stacks setze ich hier voraus. Falls du Docker Compose noch nicht kennst, lies dich vorab kurz ein.

Schritt 1: Verzeichnisse und Image verstehen

Frigate arbeitet mit zwei dauerhaften Volumes: /config (enthält config.yml und die SQLite-Datenbank frigate.db) sowie /media/frigate (Aufnahmen, Snapshots, Exporte). Lege die Host-Verzeichnisse an:

mkdir -p /opt/frigate/config /opt/frigate/storage
# config.yml legst du gleich in /opt/frigate/config/ ab

Beim Image hast du je nach Hardware die Wahl. Das Standard-Image deckt CPU, Intel und Coral ab; für GPUs gibt es eigene Varianten:

Image-Tag	Einsatzzweck
`ghcr.io/blakeblackshear/frigate:stable`	Standard inkl. Intel OpenVINO, CPU, Coral
`...:stable-tensorrt`	NVIDIA-GPU (TensorRT/ONNX)
`...:stable-rocm`	AMD-GPU
`...:stable-tensorrt-jp6`	NVIDIA Jetson
`...:stable-standard-arm64`	ARM64-Systeme

Der aktuelle Release-Tag ist v0.17.1 (veröffentlicht am 22.03.2026, Serie 0.17). Für produktive Systeme empfiehlt es sich, die Version zu pinnen, z. B. :0.17.1, damit ein pull dir nicht unerwartet eine neue Minor-Version mit geändertem Config-Schema einspielt.

Schritt 2: compose.yaml anlegen

Erstelle die Datei /opt/frigate/compose.yaml. Diese Variante ist auf Intel iGPU (OpenVINO/VAAPI) und optional Coral USB ausgelegt. Wichtig sind shm_size (der Default von 64 MB reicht nicht und führt zu Abstürzen) und der tmpfs-Cache, der den Datenträger schont.

services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable   # optional pinnen: :0.17.1
    restart: unless-stopped
    stop_grace_period: 30s
    shm_size: "512mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb               # Coral USB (sonst entfernen)
      - /dev/apex_0:/dev/apex_0                 # Coral M.2/PCIe (sonst entfernen)
      - /dev/dri/renderD128:/dev/dri/renderD128 # Intel iGPU (OpenVINO/VAAPI)
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /opt/frigate/config:/config
      - /opt/frigate/storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"        # Web-UI/API (HTTPS, authentifiziert)
      - "8554:8554"        # RTSP-Restream (go2rtc)
      - "8555:8555/tcp"    # WebRTC
      - "8555:8555/udp"
    environment:
      FRIGATE_RTSP_PASSWORD: "EinSicheresPasswort"

Zu den Ports kurz die wichtigsten Fakten: 8971 ist die authentifizierte HTTPS-Web-UI samt API – das ist der einzige Port, den du nach außen gibst. Port 5000 ist die alte, unauthentifizierte UI und darf niemals ins Internet oder in einen öffentlichen Reverse-Proxy. 8554 ist der RTSP-Restream über go2rtc, 8555 dient WebRTC für latenzarmes Live-Bild.

Variante NVIDIA-GPU

Nutzt du eine NVIDIA-GPU für die Erkennung, tausche das Image gegen stable-tensorrt und reserviere die GPU. Voraussetzung ist das installierte nvidia-container-toolkit samt passendem Treiber (CUDA 12.x, Driver >= 545, Compute Capability >= 5.0). Die Coral-/iGPU-Device-Zeilen entfällst du in dem Fall:

services:
  frigate:
    image: ghcr.io/blakeblackshear/frigate:stable-tensorrt
    # ... restliche Config wie oben (ohne /dev/dri und Coral-Devices) ...
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Schritt 3: config.yml mit Kamera und Detector

Die eigentliche Konfiguration steckt in /opt/frigate/config/config.yml. Das folgende Minimalbeispiel bindet eine RTSP-Kamera über den go2rtc-Restream ein und nutzt den Intel-OpenVINO-Detector. Ersetze USER, PASS und die IP durch deine Kameradaten. Sonderzeichen im Passwort musst du URL-kodieren, sonst schlägt der Stream fehl.

mqtt:
  enabled: false           # optional; fuer Home Assistant: enabled: true + host

detectors:
  ov:
    type: openvino
    device: GPU            # Coral: type: edgetpu / device: usb ; NVIDIA: type: tensorrt / device: 0

go2rtc:
  streams:
    front:
      - rtsp://USER:PASS@192.168.1.50:554/Streaming/Channels/101

ffmpeg:
  hwaccel_args: preset-vaapi   # Intel; NVIDIA: preset-nvidia ; RPi: preset-rpi-64-h264

cameras:
  front:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/front
          input_args: preset-rtsp-restream
          roles: [detect, record]
    detect:
      width: 1280
      height: 720
      fps: 5
    objects:
      track: [person, car]
    record:
      enabled: true
    snapshots:
      enabled: true

Wichtig fürs Verständnis: Die Rolle detect sollte auf einem niedrig aufgelösten Substream liegen, die Rolle record auf dem Hauptstream. Legst du beides auf den hochauflösenden Hauptstream, treibt das CPU- und GPU-Last unnötig hoch. Über objects.track bestimmst du, welche Objekte überhaupt verfolgt werden – hier person und car.

Detector je nach Hardware

Intel iGPU (OpenVINO): type: openvino, device: GPU (alternativ NPU oder CPU); Device-Mapping /dev/dri/renderD128.
Google Coral USB: type: edgetpu, device: usb; Device /dev/bus/usb. Coral M.2/PCIe: device: pci, Device /dev/apex_0.
NVIDIA: type: tensorrt, device: 0 (oder type: onnx); GPU über deploy.resources statt Device-Mapping, Image stable-tensorrt.

Hinweis aus der Doku: Für Neuinstallationen wird die Coral TPU nicht mehr primär empfohlen (außer bei extrem niedrigem Stromverbrauch). Eine Intel iGPU mit OpenVINO oder eine NVIDIA-GPU sind die bevorzugten Wege.

Schritt 4: Container starten und Admin-Passwort auslesen

Wechsle in das Verzeichnis mit der compose.yaml und starte den Stack:

cd /opt/frigate
docker compose up -d

Beim ersten Start erzeugt Frigate automatisch den Benutzer admin und ein zufälliges Passwort. Dieses Passwort wird nur ins Container-Log geschrieben – lies es jetzt aus, bevor es im Log untergeht:

docker logs frigate

Suche im Log nach der Zeile mit dem generierten Passwort. Übersiehst du es, musst du das Passwort später über die Web-UI bzw. einen Reset neu setzen.

Schritt 5: Web-UI öffnen und Ersteinrichtung

Öffne im Browser https://SERVER-IP:8971. Da Frigate standardmäßig ein selbstsigniertes HTTPS-Zertifikat nutzt, zeigt der Browser eine Sicherheitswarnung – das ist im LAN normal, bestätige die Ausnahme. Melde dich mit Benutzer admin und dem Passwort aus dem Log an.

In der Oberfläche solltest du nun das Live-Bild deiner Kamera front sehen. Bewegt sich eine Person oder ein Auto durchs Bild, erscheint im Bereich „Review“ bzw. „Events“ ein Eintrag mit Snapshot und Clip. Über das Menü Settings kannst du Masken und Zonen zeichnen, um nur bestimmte Bildbereiche auswerten zu lassen, und die Erkennungs-Schwellwerte feinjustieren. Prüfe außerdem unter dem Menüpunkt für Systeminfos, ob dein Detector (OpenVINO/Coral/TensorRT) korrekt geladen wurde und die Inferenzzeit niedrig ist.

Schritt 6: Reverse-Proxy und HTTPS

Für den Zugriff von außen stellst du Frigate hinter einen Reverse-Proxy (z. B. Nginx Proxy Manager oder Traefik) und vergibst ein echtes Zertifikat über Let’s Encrypt. Proxye dabei ausschließlich Port 8971 – niemals Port 5000. Da das Backend selbst HTTPS spricht, musst du im Proxy meist auf das Upstream-Ziel https:// verweisen und die TLS-Verifikation deaktivieren (selbstsigniertes Backend-Zertifikat) oder ein eigenes Zertifikat hinterlegen.

server {
    listen 443 ssl;
    server_name frigate.DEINE-DOMAIN.de;

    # ssl_certificate / ssl_certificate_key vom Proxy verwaltet

    location / {
        proxy_pass https://127.0.0.1:8971;
        proxy_ssl_verify off;          # Backend nutzt selbstsigniertes Zertifikat
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Schritt 7: Home-Assistant-Integration (optional)

Frigate spielt eng mit Home Assistant zusammen. Dafür aktivierst du in der config.yml MQTT und trägst deinen Broker ein:

mqtt:
  enabled: true
  host: 192.168.1.10
  user: mqtt-user
  password: mqtt-passwort

Anschließend installierst du in Home Assistant die offizielle Frigate-Integration (über HACS). Sie bringt dir Kamera-Entitäten, Binärsensoren pro erkanntem Objekt und Snapshots direkt ins Dashboard. So lassen sich Automationen bauen, etwa „Licht an, wenn nach Sonnenuntergang eine Person im Garten erkannt wird“.

Schritt 8: Update-Workflow und Backup

Vor jedem Update gilt: erst sichern, dann aktualisieren. Die kritischen Dateien sind config.yml und die Datenbank frigate.db im /config-Volume. Stoppe den Container, sichere das Verzeichnis und starte wieder:

docker compose stop frigate
tar czf frigate-config-backup-$(date +%F).tar.gz -C /opt/frigate config
docker compose start frigate

Das eigentliche Update läuft über pull und einen Neustart des Stacks. Prüfe vorher die GitHub-Release-Notes auf Breaking Changes, da sich das Config-Schema zwischen Minor-Versionen ändern kann:

docker compose pull
docker compose up -d
docker image prune -f

Wenn du in compose.yaml eine feste Version gepinnt hast, erhöhe vor dem pull einfach den Tag (z. B. von :0.17.1 auf die nächste geprüfte Version). Die Aufnahmen im /media/frigate-Volume musst du je nach Wichtigkeit separat sichern – sie können sehr groß werden, daher reicht hier oft ein NAS-Ziel.

Troubleshooting

Container stürzt ab, Bus-Error: shm_size ist zu klein. Der Default von 64 MB reicht nicht – setze mindestens 256 bis 512 MB, abhängig von Kameraanzahl und Auflösung.
Kamera-Stream startet nicht: Prüfe, ob die RTSP-URL erreichbar und korrekt authentifiziert ist. Sonderzeichen im Passwort müssen URL-kodiert werden, sonst scheitert go2rtc/FFmpeg.
Coral wird nicht erkannt: Korrektes Device-Mapping nötig (USB /dev/bus/usb, M.2 /dev/apex_0), notfalls privileged. Ein USB-Coral landet nach einem Reboot manchmal auf einem anderen Bus.
NVIDIA-Image startet nicht oder rechnet auf der CPU: Ohne installiertes nvidia-container-toolkit und passenden Treiber (CUDA 12.x, Driver >= 545) läuft stable-tensorrt nicht bzw. fällt auf CPU zurück. Außerdem braucht NVIDIA zwingend das stable-tensorrt-Image, AMD das stable-rocm-Image – das Standard-Image kann diese GPUs nicht für die Detection nutzen.
Hohe CPU/GPU-Last: Der detect-Stream läuft vermutlich auf dem Hauptstream. Lege ihn auf einen Substream mit ca. 1280x720 und 5 fps.
Datenträger verschleißt schnell: Aufnahmen nicht auf SD-Karte oder Consumer-USB schreiben. Nutze den tmpfs-Cache unter /tmp/cache und lege /media/frigate auf SSD oder NAS.

Häufige Fragen

Brauche ich zwingend eine GPU oder Coral?

Nein. Frigate kann die Erkennung auf der CPU rechnen, das kostet aber spürbar Last und skaliert schlecht über mehrere Kameras. Eine Intel iGPU mit OpenVINO ist im Standard-Image bereits enthalten und für die meisten KMU- und Heim-Setups die einfachste, effizienteste Lösung.

Welche Kameras funktionieren mit Frigate?

Jede IP-Kamera, die einen RTSP-Stream liefert. RTSP ist Pflicht. Ideal sind Kameras mit einem zusätzlichen Substream, damit du die Erkennung auf einer niedrigen Auflösung laufen lassen kannst und die Aufnahme in voller Qualität erfolgt.

Warum sehe ich eine Browser-Warnung beim Aufruf der Web-UI?

Frigate nutzt ab Werk ein selbstsigniertes HTTPS-Zertifikat auf Port 8971. Im LAN kannst du die Warnung bestätigen. Für den Zugriff von außen setzt du einen Reverse-Proxy mit gültigem Let’s-Encrypt-Zertifikat davor.

Wo finde ich das erste Admin-Passwort?

Es wird beim allerersten Start automatisch erzeugt und ausschließlich ins Container-Log geschrieben. Lies es mit docker logs frigate aus. Hast du es verpasst, lässt es sich über die UI bzw. einen Reset neu setzen.

Wie viel Speicherplatz brauchen die Aufnahmen?

Das hängt stark von Auflösung, Bildrate, Kameraanzahl und Aufbewahrungsdauer ab. Plane großzügig und lege /media/frigate auf eine SSD oder ein NAS. Über die Record-Einstellungen kannst du Aufbewahrungszeiten begrenzen.

Kann ich Frigate in Home Assistant einbinden?

Ja. Aktiviere MQTT in der config.yml und installiere die Frigate-Integration in Home Assistant. Du bekommst dann Kamera-Entitäten, Objektsensoren und Snapshots für deine Automationen.

Fazit

Mit Frigate baust du dir in unter einer halben Stunde einen vollwertigen, lokalen NVR mit echter KI-Objekterkennung – ohne Abo, ohne Cloud, ohne Datenabfluss. Die wichtigsten Stellschrauben sind ein ausreichend großer shm_size, ein passender Detector für deine Hardware und die saubere Trennung von Detect-Substream und Record-Hauptstream. Wer den Update-Workflow mit vorherigem Backup von config.yml und frigate.db diszipliniert einhält, hat ein zuverlässiges, wartbares System, das sich nahtlos in Home Assistant integrieren lässt.

Weiterführende Anleitungen und Quellen

Docker Compose Grundlagen: Stacks sauber aufbauen und betreiben – die Basis für jede Compose-Datei in dieser Anleitung.
Home Assistant per Docker einrichten – ideal, um Frigate-Ereignisse in Automationen zu nutzen.
LibreChat self-hosted per Docker – ein weiteres KI-Projekt zum Selbsthosten.
Weitere Anleitungen aus der Kategorie Künstliche Intelligenz

Offizielle Quellen: