Frigate ist eine selbst gehostete NVR-Software (Network Video Recorder) mit lokaler KI-Objekterkennung in Echtzeit. Statt auf jede Bewegung zu reagieren, erkennt Frigate auf Ihrem Server, ob eine Person, ein Auto oder ein anderes Objekt im Bild ist, ohne Cloud. In dieser Anleitung richten Sie Frigate per Docker Compose ein, binden RTSP-Kameras an, aktivieren Hardware-Beschleunigung (Intel iGPU, Google Coral oder NVIDIA) und sichern die Installation gegen Datenverlust ab.

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 Sie loslegen, sollte Folgendes vorhanden sein:

Linux-Server mit Docker und Docker Compose (Debian 12/13 oder Ubuntu 24.04), x86_64 (amd64) oder arm64. Eine sparsame Basis ist z. B. ein Mini-PC mit Intel N100. Für die GPU-Statistik von Intel-Grafik verlangt Frigate 0.18 einen Host-Kernel ab 6.5.
Mindestens eine IP-Kamera mit RTSP (Pflicht). Idealerweise liefert sie einen Substream (ca. 1280x720 bei 5 fps) für die Erkennung und den Hauptstream für die Aufnahme.
RAM/CPU: mindestens 2 CPU-Kerne und 4 GB RAM, besser 4 Kerne und 8 GB; eine moderne CPU mit integrierter Grafik (Intel iGPU, ab 6. Generation) reicht für mehrere Kameras.
Optional KI-Beschleuniger: Intel iGPU (OpenVINO, im Standard-Image enthalten), Google Coral TPU oder NVIDIA-GPU. Reine CPU-Erkennung funktioniert, erzeugt 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 Sie Frigate über HTTPS von außen erreichbar machen wollen.

Grundkenntnisse zu Compose-Stacks werden vorausgesetzt.

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). Legen Sie die Host-Verzeichnisse an:

mkdir -p /opt/frigate/config /opt/frigate/storage
# config.yml legen Sie gleich in /opt/frigate/config/ ab

Beim Image haben Sie 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 (ONNX mit TensorRT), nur amd64
`...:stable-rocm`	AMD-GPU
`...:stable-tensorrt-jp6`	NVIDIA Jetson
`...:stable-standard-arm64`	ARM64-Systeme

Aktuell ist 0.18.0 (veröffentlicht am 12.09.2026). Legen Sie produktiv die Version fest, z. B. :0.18.0, damit ein pull keine Minor-Version mit geändertem Config-Schema einspielt.

Verifizieren: ls -ld /opt/frigate/config /opt/frigate/storage zeigt beide Verzeichnisse an.

Schritt 2: compose.yaml anlegen

Erstellen Sie /opt/frigate/compose.yaml (Variante für Intel iGPU mit OpenVINO/VAAPI und optional Coral USB). Wichtig sind shm_size (der Default von 64 MB 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 festlegen: :0.18.0
    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 (authentifiziert, HTTPS mit eigenem Zertifikat)
      - "8554:8554"        # RTSP-Restream (go2rtc)
      - "8555:8555/tcp"    # WebRTC
      - "8555:8555/udp"
    environment:
      FRIGATE_RTSP_PASSWORD: "EinSicheresPasswort"

Ports: 8971 ist die authentifizierte HTTPS-Web-UI samt API und der einzige Port nach außen. 5000 ist der interne, unauthentifizierte Zugang und darf nie ins Internet oder in einen öffentlichen Reverse-Proxy. 8554 ist der RTSP-Restream über go2rtc, 8555 dient WebRTC.

Variante NVIDIA-GPU

Für eine NVIDIA-GPU tauschen Sie das Image gegen stable-tensorrt und reservieren die GPU. Voraussetzung: nvidia-container-toolkit und passender Treiber (CUDA 12.x, Driver >= 545, Compute Capability >= 5.0). Die Coral-/iGPU-Device-Zeilen entfallen:

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]

Verifizieren: docker compose config --quiet && echo OK gibt OK aus, und ls -l /dev/dri/renderD128 (Intel) bzw. nvidia-smi (NVIDIA) findet die Grafikeinheit auf dem Host.

Schritt 3: config.yml mit Kamera und Detector

Die Konfiguration steht in /opt/frigate/config/config.yml. Das Minimalbeispiel bindet eine RTSP-Kamera über den go2rtc-Restream ein und nutzt den Intel-OpenVINO-Detector. Ersetzen Sie USER, PASS und die IP; Sonderzeichen im Passwort müssen URL-kodiert sein.

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

detectors:
  ov:
    type: openvino
    device: GPU            # Coral: type: edgetpu / device: usb ; NVIDIA: type: onnx (plus model-Abschnitt laut Doku)

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

Die Rolle detect gehört auf den niedrig aufgelösten Substream, record auf den Hauptstream; beides auf dem Hauptstream treibt die Last unnötig hoch. objects.track bestimmt die verfolgten Objekte, 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: onnx mit einem unterstützten ONNX-Modell (etwa YOLO-NAS oder YOLOv9, model-Abschnitt laut Doku); der Detector tensorrt ist nur noch für Jetson-Geräte vorgesehen. GPU über deploy.resources statt Device-Mapping, Image stable-tensorrt.

Laut Doku wird die Coral TPU für Neuinstallationen nicht mehr primär empfohlen (außer bei extrem niedrigem Stromverbrauch); bevorzugt sind Intel iGPU mit OpenVINO oder NVIDIA-GPU.

Verifizieren: python3 -c "import yaml; yaml.safe_load(open('/opt/frigate/config/config.yml'))" && echo OK meldet OK, und ffprobe rtsp://USER:PASS@192.168.1.50:554/Streaming/Channels/101 zeigt einen Videostream mit Auflösung an.

Schritt 4: Container starten und Admin-Passwort auslesen

Wechseln Sie in das Verzeichnis mit der compose.yaml und starten Sie den Stack:

cd /opt/frigate
docker compose up -d

Beim ersten Start erzeugt Frigate den Benutzer admin mit zufälligem Passwort, das nur ins Container-Log geschrieben wird. Lesen Sie es jetzt aus:

docker logs frigate

Übersehen? Setzen Sie in der config.yml unter auth die Option reset_admin_password: true und starten Sie neu; dann steht ein neues Passwort im Log.

Verifizieren: docker compose ps zeigt frigate mit Status Up (nach etwa einer Minute healthy), und docker logs frigate 2>&1 | grep -i password liefert die Zeile mit dem Passwort.

Schritt 5: Web-UI öffnen und Ersteinrichtung

Öffnen Sie https://SERVER-IP:8971. Die Warnung zum selbstsignierten Zertifikat ist im LAN normal; bestätigen Sie die Ausnahme und melden Sie sich als admin mit dem Passwort aus dem Log an.

Sie sehen das Live-Bild der Kamera front. Bewegt sich eine Person oder ein Auto durchs Bild, erscheint unter „Review“ bzw. „Events“ ein Eintrag mit Snapshot und Clip. Unter Settings zeichnen Sie Masken und Zonen und justieren Schwellwerte. In den Systeminfos prüfen Sie, ob der Detector (OpenVINO/Coral/TensorRT) geladen ist und die Inferenzzeit niedrig bleibt.

Verifizieren: Die Anmeldung als admin klappt, das Live-Bild von front läuft, und in den Systeminfos steht der Detector mit einer Inferenzzeit im niedrigen zweistelligen Millisekundenbereich oder darunter.

Schritt 6: Reverse-Proxy und HTTPS

Für den Zugriff von außen stellen Sie Frigate hinter einen Reverse-Proxy (z. B. Nginx Proxy Manager oder Traefik) mit Let’s-Encrypt-Zertifikat und leiten ausschließlich Port 8971 weiter, niemals 5000. Da das Backend HTTPS spricht, verweist der Proxy auf https:// ohne TLS-Verifikation (selbstsigniertes Backend-Zertifikat). Alternativ schalten Sie TLS in Frigate mit tls: enabled: false ab und verweisen auf http://.

server {
    listen 443 ssl;
    server_name frigate.example.com;

    # 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";
    }
}

Verifizieren: curl -sI https://frigate.example.com antwortet mit HTTP-Status 200 oder einer Weiterleitung auf die Anmeldeseite, und das Zertifikat im Browser stammt von Let’s Encrypt.

Schritt 7: Home-Assistant-Integration (optional)

Für Home Assistant aktivieren Sie in der config.yml MQTT und tragen Ihren Broker ein:

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

Dann installieren Sie in Home Assistant die offizielle Frigate-Integration (über HACS). Sie liefert Kamera-Entitäten, Binärsensoren pro Objekt und Snapshots, etwa für „Licht an, wenn nach Sonnenuntergang eine Person im Garten erkannt wird“.

Verifizieren: In Home Assistant erscheint das Frigate-Gerät mit einer Kamera-Entität camera.front, und docker logs frigate 2>&1 | grep -i mqtt zeigt keine Verbindungsfehler.

Schritt 8: Update-Workflow und Backup

Vor jedem Update: erst sichern, dann aktualisieren. Kritisch sind config.yml und frigate.db im /config-Volume. Container stoppen, Verzeichnis sichern, wieder starten:

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

Das Update läuft über pull und Neustart. Prüfen Sie vorher die Release-Notes auf Breaking Changes; das Config-Schema kann sich zwischen Minor-Versionen ändern (0.18 migriert etwa Zonen, Masken und Snapshot-Optionen automatisch):

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

Bei fester Version erhöhen Sie vor dem pull den Tag (z. B. von :0.18.0 auf die nächste geprüfte Version). Die oft sehr großen Aufnahmen in /media/frigate sichern Sie je nach Wichtigkeit separat, etwa auf ein NAS.

Verifizieren: tar tzf frigate-config-backup-$(date +%F).tar.gz listet config/config.yml und config/frigate.db, und nach dem Update zeigt die Web-UI unter den Systeminfos die neue Version.

Troubleshooting

Container stürzt ab, Bus-Error: shm_size zu klein; mindestens 256 bis 512 MB je nach Kameraanzahl und Auflösung setzen.
Kamera-Stream startet nicht: Prüfen Sie, 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 nvidia-container-toolkit und passenden Treiber (CUDA 12.x, Driver >= 545) läuft stable-tensorrt nicht bzw. fällt auf CPU zurück. NVIDIA braucht das stable-tensorrt-, AMD das stable-rocm-Image; das Standard-Image nutzt diese GPUs nicht für die Detection.
Hohe CPU/GPU-Last: Der detect-Stream läuft vermutlich auf dem Hauptstream. Legen Sie ihn auf einen Substream mit ca. 1280x720 und 5 fps.
Datenträger verschleißt schnell: Keine Aufnahmen auf SD-Karte oder Consumer-USB. tmpfs-Cache unter /tmp/cache nutzen, /media/frigate auf SSD oder NAS.

Häufige Fragen

Brauche ich zwingend eine GPU oder Coral?

Nein. CPU-Erkennung funktioniert, erzeugt aber Last und skaliert schlecht über mehrere Kameras. Die Intel iGPU mit OpenVINO ist im Standard-Image enthalten und für die meisten Setups die einfachste Lösung.

Welche Kameras funktionieren mit Frigate?

Jede IP-Kamera mit RTSP-Stream. Ideal ist ein zusätzlicher Substream für die Erkennung (siehe Schritt 3).

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

Frigate nutzt ab Werk ein selbstsigniertes Zertifikat auf Port 8971. Im LAN bestätigen Sie die Warnung; von außen setzen Sie einen Reverse-Proxy mit Let’s-Encrypt-Zertifikat davor (Schritt 6).

Wo finde ich das erste Admin-Passwort?

Nur im Container-Log des ersten Starts: docker logs frigate. Verpasst? auth: reset_admin_password: true erzeugt beim nächsten Start ein neues.

Wie viel Speicherplatz brauchen die Aufnahmen?

Das hängt von Auflösung, Bildrate, Kameraanzahl und Aufbewahrungsdauer ab. Planen Sie großzügig, legen Sie /media/frigate auf SSD oder NAS und begrenzen Sie die Aufbewahrung über die Record-Einstellungen.

Kann ich Frigate in Home Assistant einbinden?

Ja, über MQTT und die Frigate-Integration (Schritt 7).

Fazit

Die wichtigsten Stellschrauben: ausreichend großer shm_size, passender Detector für Ihre Hardware und die Trennung von Detect-Substream und Record-Hauptstream. Sichern Sie vor jedem Update config.yml und frigate.db.

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: