Frigate con Docker Compose para tus cámaras

Mon, 31 Aug 2026 00:00:00 +0000

En corto

1
2
3
4
5


mkdir -p /opt/frigate/config /opt/frigate/media
cd /opt/frigate
# escribe docker-compose.yml y config/config.yml (abajo)
docker compose up -d
docker compose logs -f frigate

UI con autenticación en https://:8971. La primera vez genera la contraseña del usuario admin en el log.

Frigate es un NVR con detección de objetos en tiempo real (persona, coche, animal…) para cámaras IP. Corre bien en un contenedor: le das un docker-compose.yml, un config.yml y las URLs RTSP de tus cámaras. Lo demás es afinar memoria compartida y aceleración por hardware.

docker-compose.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    restart: unless-stopped
    stop_grace_period: 30s
    shm_size: "256mb"            # súbelo según nº de cámaras y resolución
    devices:
      - /dev/dri/renderD128      # iGPU (VAAPI) para decodificar; opcional
      # - /dev/bus/usb:/dev/bus/usb   # Coral USB
      # - /dev/apex_0:/dev/apex_0     # Coral PCIe
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./config:/config
      - ./media:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"     # UI con autenticación (úsala)
      - "8554:8554"     # restream RTSP (go2rtc)
      - "8555:8555/tcp" # WebRTC
      - "8555:8555/udp"
    environment:
      FRIGATE_RTSP_USER: "${FRIGATE_RTSP_USER}"
      FRIGATE_RTSP_PASSWORD: "${FRIGATE_RTSP_PASSWORD}"

Las credenciales de las cámaras van en un .env al lado del compose (nunca en git):

1
2
3


# /opt/frigate/.env
FRIGATE_RTSP_USER=viewer
FRIGATE_RTSP_PASSWORD=change-me

config/config.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


mqtt:
  enabled: false        # o apunta a un broker mosquitto para Home Assistant

detectors:
  cpu1:
    type: cpu           # cámbialo a edgetpu (Coral) o tensorrt (NVIDIA)

ffmpeg:
  hwaccel_args: preset-vaapi   # iGPU Intel/AMD; NVIDIA: preset-nvidia

go2rtc:
  streams:
    door1:
      - "rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@camera-ip:554/stream1"

cameras:
  door1:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/door1   # una sola conexión vía go2rtc
          roles: [detect, record]
    detect:
      width: 1280
      height: 720
      fps: 5
    objects:
      track: [person, car, dog]
    record:
      enabled: true
      retain:
        days: 7
    snapshots:
      enabled: true

Añade más cámaras repitiendo el bloque go2rtc.streams + cameras. Recarga con docker compose restart frigate.

Qué hace cada pieza

Pieza	Para qué
`shm_size`	Buffers de frames en `/dev/shm`. Insuficiente = las cámaras crashean.
`go2rtc`	Reempaqueta el RTSP de la cámara y lo sirve en `:8554`. Frigate consume de ahí para detectar y grabar con una sola conexión a la cámara.
`hwaccel_args`	Descarga el decode de vídeo a la GPU/iGPU. Sin esto la CPU se derrite.
`detectors`	Dónde corre la inferencia: `cpu` (lento), `edgetpu` (Coral) o `tensorrt` (NVIDIA).
Puerto `8971`	UI con login. Es la que expones.
`record` / `snapshots`	Escriben en `./media`. La retención define cuánto disco comes.

Trampas

shm_size corto → cámaras que se reinician solas. Regla aproximada por cámara: (ancho*alto*1.5*9 + 270480) / 1048576 MB; suma todas y deja base. Con varias cámaras 1080p te quedas corto en 64–128 MB.
No expongas el puerto 5000. Es la API interna sin autenticación. La UI pública es 8971 (con login). Deja 5000 solo en loopback / red interna.
Usa el restream de go2rtc. Si pones el RTSP de la cámara directo en detect y record, abres dos conexiones al sensor; muchas cámaras baratas no lo aguantan. Detecta y graba desde rtsp://127.0.0.1:8554/.
Detecta en baja resolución. detect a 1280×720 y 5 fps basta; graba en el stream alto aparte si tu cámara tiene dos.
Aceleración por hardware o CPU al 100%. preset-vaapi (Intel/AMD) o preset-nvidia; el device /dev/dri (o el runtime de NVIDIA) tiene que estar mapeado.
Un detector no es opcional en la práctica. El detector cpu sirve para probar, pero con más de una o dos cámaras quieres Coral o TensorRT.

Ver también

Documentación oficial: https://docs.frigate.video/