Tutoriales Docker / enero 21, 2026

Instalación de Frigate en Portainer

Configura cámaras en Frigate usando streams de distinta calidad para detección y grabación, optimizando rendimiento y consumo de recursos.

Don T3rr0rZ0n3

5 minutos

Frigate es un NVR (Network Video Recorder) de código abierto diseñado específicamente para trabajar con cámaras IP y detección de objetos en tiempo real mediante aceleración por hardware y modelos de inteligencia artificial. A diferencia de otros sistemas de videovigilancia tradicionales, Frigate está orientado a ser eficiente, ligero y totalmente local, priorizando la privacidad y el control del usuario.

Frigate se utiliza principalmente para monitorizar cámaras, detectar movimiento u objetos (personas, vehículos, animales, etc.), generar eventos, snapshots y grabaciones, y hacerlo todo sin depender de servicios externos en la nube. Esto lo convierte en una solución ideal para entornos domésticos y autoalojados.

Además, Frigate cuenta con una integración nativa con Home Assistant, lo que permite visualizar cámaras, recibir notificaciones inteligentes, usar snapshots en automatizaciones y combinar la videovigilancia con el resto de tu hogar inteligente de forma totalmente integrada y segura.

Creación de Stack en Portainer

Accedemos a Portainer y, dentro de la sección Stacks, hacemos clic en el botón + Add Stack para crear una nueva pila.

Primero añadimos un nombre a nuestro stack y seleccionamos Web Editor y añadimos el siguiente contenido:

name: frigate

services:
  frigate:
    container_name: frigate
    privileged: true # this may not be necessary for all setups
    restart: unless-stopped
    stop_grace_period: 30s # allow enough time to shut down the various services
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "512mb" # Bus error? recalculate shm size
    devices:
      - /dev/dri/card0:/dev/dri/card0
      - /dev/dri/renderD128:/dev/dri/renderD128 # For intel hwaccel, needs to be updated for your hardware
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /volume1/docker/frigate/config:/config
      - /volume1/docker/frigate/storage:/media/frigate
      - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"
      - "5000:5000" # Internal unauthenticated access. Expose carefully.
      - "8554:8554" # RTSP feeds
      - "8555:8555/tcp" # WebRTC over tcp
      - "8555:8555/udp" # WebRTC over udp
    environment:
      FRIGATE_RTSP_PASSWORD: "XXXXX"

Configura los volúmenes según tu estructura y necesidades. En mi caso, utilizo el volumen1 de mi NAS, donde tengo un directorio llamado docker que uso para centralizar todos mis servicios en contenedores.

Dentro de ese directorio he creado una carpeta llamada frigate y, en su interior, dos subdirectorios:

  • config, para los archivos de configuración.
  • storage, para el almacenamiento de datos y grabaciones.

Esta organización facilita el mantenimiento, las copias de seguridad y la gestión de permisos de Frigate dentro del NAS.

Además, es necesario modificar la variable de entorno FRIGATE_RTSP_PASSWORD, estableciendo la contraseña que utilizará Frigate para acceder a los streams RTSP de las cámaras. Asegúrate de definir una contraseña segura y coherente con la configuración de tus cámaras, ya que este valor se utilizará para la autenticación y es clave para que el servicio funcione correctamente.

Con esta configuración ya lo tenemos todo listo para desplegar el contenedor y levantar el stack, dejando el servicio operativo y preparado para empezar a funcionar sin necesidad de ajustes adicionales.

Acceso a la interfaz web

Una vez el contenedor esté levantado y en ejecución, podremos acceder a la interfaz del servicio a través del puerto 5000, utilizando el navegador web.

🚨
Frigate nunca debe exponerse directamente a Internet. Si publicas este servicio hacia el exterior, cualquier persona podría acceder a tus cámaras, ver los streams en tiempo real y comprometer gravemente tu privacidad y seguridad.

Frigate está pensado para funcionar exclusivamente en red local. Si necesitas acceder desde fuera de casa, hazlo siempre a través de una VPN (por ejemplo, WireGuard u OpenVPN), de modo que solo los dispositivos autenticados puedan entrar en tu red de forma segura.

Configuración de cámaras

A continuación vamos a ver cómo configurar las cámaras en Frigate siguiendo una base segura, eficiente y recomendada, teniendo siempre en cuenta que Frigate debe funcionar únicamente en red local y, si se accede desde fuera, hacerlo exclusivamente mediante VPN.

Partimos de una configuración mínima donde no usamos MQTT y activamos aceleración por hardware con VAAPI (ideal en equipos Intel):

mqtt:
  enabled: false

ffmpeg:
  hwaccel_args: preset-vaapi
  • MQTT desactivado: si no lo necesitas para integraciones externas, reduces complejidad y superficie de ataque.
  • VAAPI: descarga trabajo de la CPU usando la GPU integrada para decodificación de vídeo.

Vamos a usar go2rtc como intermediario de los streams RTSP. Esto tiene varias ventajas clave:

  • Evita múltiples conexiones directas a la cámara.
  • Reduce carga en las cámaras.
  • Permite reutilizar un mismo stream para detección y grabación.
  • Mejora estabilidad y rendimiento.

Ejemplo de configuración:

go2rtc:
  streams:
    camara1:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/H.264
    camara2_low:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/stream2
    camara2_high:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/stream1

Aquí definimos los streams de las cámaras que vamos a utilizar en Frigate. Por un lado, tenemos una cámara con un único stream RTSP, llamada camara1, donde se especifican su usuario, contraseña, IP, puerto y ruta del stream.

Por otro lado, definimos la misma cámara con dos calidades diferentes de vídeo (y audio):

  • camara2_low: un stream de baja calidad, pensado para tareas ligeras como la detección.
  • camara2_high: un stream de mayor calidad, destinado a grabaciones o visualización.

Esta separación es intencionada y una buena práctica en Frigate, ya que nos permite utilizar cada stream para un propósito distinto, optimizando tanto el rendimiento del sistema como el consumo de recursos.

Una vez definidos los streams en go2rtc, las cámaras no apuntan directamente a las IPs, sino al proxy local de Frigate (127.0.0.1:8554).

Por ejemplo, para camara1 podemos usar esta configuración para una detección simple:

cameras:
  camera1:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/camera1
          roles:
            - detect
    detect:
      width: 1280
      height: 720
      fps: 7

Si por lo contrario queremos que haya detección y grabación, podemos usar esta otra configuración que combina los dos streams de camara2:

  camera2:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/camera2_low
          roles:
            - detect
        - path: rtsp://127.0.0.1:8554/camera2_high
          roles:
            - record
    detect:
      width: 1280
      height: 720
      fps: 7

Esta es la mejor práctica recomendada para Frigate, usamos el stream de calidad más baja para la detección y el stream de alta calidad para la grabación.

Por último, definimos cómo se comportan las grabaciones y las capturas:

record:
  enabled: false
  retain:
    days: 7
    mode: motion   # all = siempre, motion = solo detección

snapshots:
  enabled: true
  timestamp: false
  bounding_box: true
  retain:
    default: 7

En este caso tenemos las grabaciones desactivadas (se puede activar si problemas) y hemos configurado que tanto para las grabaciones como para los snapshots hay una retención de 7 días.

Al final la configuración completa quedaría de la siguiente forma:

mqtt:
  enabled: false

ffmpeg:
  hwaccel_args: preset-vaapi

go2rtc:
  streams:
    camara1:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/H.264
    camara2_low:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/stream2
    camara2_high:
      - rtsp://usuario:contraseña@IP_CAMARA:PUERTO/stream1

cameras:
  camera1:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/camera1
          roles:
            - detect
    detect:
      width: 1280
      height: 720
      fps: 7

  camera2:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/camera2_low
          roles:
            - detect
        - path: rtsp://127.0.0.1:8554/camera2_high
          roles:
            - record
    detect:
      width: 1280
      height: 720
      fps: 7

record:
  enabled: false
  retain:
    days: 7
    mode: motion   # all = siempre, motion = solo detección

snapshots:
  enabled: true
  timestamp: false
  bounding_box: true
  retain:
    default: 7

Conclusión

Separar los streams por calidad es una buena práctica en Frigate, ya que permite optimizar recursos sin renunciar a una buena calidad de grabación. Usando un stream ligero para la detección y otro de mayor calidad para grabar o visualizar, el sistema gana en rendimiento, estabilidad y eficiencia, manteniendo siempre el control y la privacidad en red local.

Más sobre ./voidNull

Haz que cada palabra cuente: tu donación nos inspira a seguir creando contenido. Accede al apartado de Donación para hacer tu aportación