> ## Documentation Index
> Fetch the complete documentation index at: https://api-docs.rhombus.community/llms.txt
> Use this file to discover all available pages before exploring further.
# Puerta de enlace RTSP EdgeCaster
> Ejecuta EdgeCaster en una Raspberry Pi 5 o cualquier máquina Ubuntu/Debian para retransmitir los streams de las cámaras Rhombus como RTSP con latencia inferior a un segundo para sistemas VMS, NVR y de video de terceros heredados.
Esta página fue traducida automáticamente. Si encuentra errores o tiene sugerencias, [contáctenos](mailto:support@rhombus.com).
**EdgeCaster** es una puerta de enlace edge local que obtiene los Secure Raw Streams de Rhombus (H.264 sobre HTTPS) y los retransmite como RTSP estándar en tu red local usando [MediaMTX](https://github.com/bluenviron/mediamtx) integrado. Se ejecuta en una Raspberry Pi 5, un mini-PC o cualquier máquina Ubuntu/Debian, de modo que los sistemas VMS, NVR y de IA/video de terceros heredados que requieren RTSP pueden consumir video de las cámaras Rhombus con menos de un segundo de latencia añadida. Se administra desde un panel web sencillo; funciona 24/7 y se recupera solo cuando un stream se cae.
Rhombus no admite RTSP de forma nativa porque no es un protocolo seguro. EdgeCaster cubre esta brecha para los entornos que requieren compatibilidad con RTSP convirtiendo los streams raw cifrados de Rhombus localmente en tu red. Implementa EdgeCaster únicamente en redes de confianza.
## Cómo funciona
```text theme={null}
Rhombus Camera
│
│ Secure Raw Stream (HTTPS H.264)
▼
EdgeCaster (Raspberry Pi 5 / mini-PC / máquina Ubuntu-Debian)
│ FFmpeg stream copy (sin transcodificación)
▼
MediaMTX (servidor RTSP, puerto 8554)
│
▼
Sistemas externos (VMS / NVR / IA)
```
EdgeCaster usa la API de Rhombus para descubrir cámaras, crea streams raw seguros mediante `createRawHttpStream` y los canaliza a través de FFmpeg (stream copy — sin transcodificación) hacia MediaMTX, que los sirve como RTSP estándar.
### Latencia inferior a un segundo, siempre el fotograma más reciente
Como los streams se copian en lugar de transcodificarse (`-c copy`), no hay retraso de decodificación/codificación. EdgeCaster minimiza la latencia eliminando el buffering en cada salto:
* **FFmpeg** se ejecuta sin buffering de entrada, con flags de baja latencia, tiempo de sondeo/análisis reducido para un arranque rápido, y retardo y precarga de multiplexación en cero, de modo que los paquetes se reenvían en cuanto llegan. Los parámetros ajustables (tamaño de sondeo, duración de análisis, umbral de congelamiento) están expuestos en `/etc/edgecaster/config.yaml` por si necesitas ajustarlos en el dispositivo.
* **MediaMTX** está ajustado para baja latencia y detección rápida de fallos: su API de control está habilitada en localhost y un timeout de lectura corto descarta rápidamente a un publicador congelado. Cada lector RTSP tiene su propia cola, así que un consumidor lento no puede añadir latencia al publicador ni a otros lectores.
El resultado: EdgeCaster siempre envía el fotograma más nuevo con menos de un segundo de latencia añadida dentro del dispositivo. La latencia de extremo a extremo ("glass-to-glass") también depende del intervalo GOP/keyframe de la cámara y del búfer propio de tu sistema consumidor, que EdgeCaster no controla.
### Streams concurrentes ilimitados
No hay límite fijo de streams: el dispositivo ejecuta tantos streams como permitan su red y su CPU. Como el stream copy es muy ligero, las pruebas reales en una Raspberry Pi 5 mostraron varios streams 1080p más múltiples lectores RTSP con aproximadamente un 3% de CPU, dejando un amplio margen. `max_streams: 0` (el valor predeterminado) significa ilimitado; establece un valor positivo en `config.yaml` si quieres un techo de seguridad opcional.
### Autorrecuperación 24/7
EdgeCaster monitorea cada stream a **nivel de fotograma** usando la salida de progreso de FFmpeg — no solo "¿el proceso está vivo?" — de modo que un feed congelado pero vivo (sin fotogramas nuevos) se detecta en segundos mediante un watchdog. Todos los desencadenantes de fallo (salida del proceso, feed congelado, proceso muerto) pasan por una única ruta de recuperación que garantiza exactamente un relanzamiento, sin carreras de doble reinicio. La recuperación vuelve a obtener una URL de Secure Raw Stream nueva desde Rhombus (los tokens de stream expiran) y se reanuda, normalmente en segundos.
Si un stream sigue fallando, EdgeCaster reintenta rápido (cada 5 segundos, hasta 10 veces), luego pasa a un intervalo de 5 minutos — y sigue intentando para siempre. Nunca se rinde de forma permanente en un dispositivo 24/7. La recuperación de feeds congelados usa un backoff más ligero y rápido.
## Características
* Latencia añadida inferior a un segundo, retransmisión siempre del último fotograma (stream copy, sin transcodificación)
* Streams concurrentes ilimitados — tantos como permitan la red y la CPU del dispositivo
* Autorrecuperación 24/7 con detección de congelamiento a nivel de fotograma y renovación automática de la URL del stream
* Panel de salud en vivo con métricas en tiempo real por Server-Sent Events
* Alertas por webhook ante caídas de streams y sobrecarga del dispositivo (Slack, Make.com o cualquier listener HTTP)
* Visor de logs en vivo en el panel — sin necesidad de SSH
* Acceso público seguro opcional con un clic mediante un túnel rápido de Cloudflare
* Descubrimiento automático de cámaras a través de la API de Rhombus
* Estado de streams persistente entre reinicios; los streams se restauran automáticamente al arrancar
* Actualizaciones automáticas nocturnas, instalador de una línea e imagen de Raspberry Pi lista para grabar
## Requisitos
| Componente | Requisito |
| ---------------- | ----------------------------------------------------------------------------------------- |
| **Dispositivo** | Raspberry Pi 5 (8 GB de RAM recomendados) o cualquier máquina Ubuntu/Debian (mini-PC, VM) |
| **Arquitectura** | arm64, amd64 o armv7 |
| **Red** | Gigabit Ethernet por cable |
| **SO** | Ubuntu o Debian (la imagen de Pi incluye Ubuntu Server 24.04) |
| **Rhombus** | Org API Key |
## Instalación
En cualquier máquina con **Ubuntu o Debian** (Raspberry Pi, mini-PC o máquina virtual), ejecuta:
```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/RhombusSystems/edgecaster-stream-converter/main/scripts/bootstrap.sh | sudo bash
```
El script descarga e instala todo — FFmpeg, MediaMTX, servicios systemd — y luego imprime la dirección web que debes abrir.
Graba una imagen lista para usar — sin escribir comandos:
Pide a Rhombus la imagen de tarjeta SD de EdgeCaster, o genera una tú mismo (ver la siguiente pestaña).
Escribe el archivo `.img.xz` en una tarjeta SD con el gratuito [Raspberry Pi Imager](https://www.raspberrypi.com/software/).
Coloca la tarjeta en una **Raspberry Pi 5**, conéctala a tu red con un cable Ethernet y enciéndela.
Espera unos minutos y abre `http://edgecaster.local` en un navegador web.
En el primer arranque el dispositivo establece su hostname en `edgecaster`, crea el usuario `edgecaster` (contraseña predeterminada: `edgecaster`) e inicia todos los servicios.
Cambia la contraseña predeterminada inmediatamente después del primer inicio de sesión: `passwd edgecaster`
Instala desde un checkout de git:
```bash theme={null}
git clone https://github.com/RhombusSystems/edgecaster-stream-converter.git
cd edgecaster-stream-converter
sudo bash scripts/install.sh
```
El instalador conserva un checkout de git en el dispositivo, por lo que las instalaciones manuales reciben actualizaciones automáticas nocturnas igual que la imagen de Pi.
Para generar una imagen de tarjeta SD grabable:
```bash theme={null}
# Cloud-init mode (smaller image, needs internet on first boot)
sudo bash image/build-image.sh
# Pre-baked mode (larger image, no internet needed on first boot)
sudo bash image/build-image.sh --prebaked
```
El resultado es un `.img.xz` grabable.
## Configuración inicial (2 minutos)
Abre EdgeCaster en un navegador web: `http://edgecaster.local` o `http://`.
Tus cámaras aparecen automáticamente.
Acciona el interruptor junto a cualquier cámara para iniciar su stream RTSP.
Copia el enlace RTSP de la cámara en tu VMS, NVR o sistema de IA:
```text theme={null}
rtsp://:8554/front_door
rtsp://:8554/warehouse
rtsp://:8554/parking_lot
```
Los nombres de las cámaras se normalizan a slugs seguros para URL y se persisten, de modo que las rutas RTSP sobreviven a los reinicios. Prueba con VLC: `vlc rtsp://:8554/`
## Panel web
El panel es una consola de operador limpia y adaptable que funciona en cualquier dispositivo o navegador — en móvil, la barra lateral se convierte en un cajón deslizante. Un pulso de estado persistente (conteo de streams activos y un indicador de salud) siempre está visible en la barra superior.
### Métricas de salud en vivo
El panel transmite métricas en vivo (aproximadamente una vez por segundo) por Server-Sent Events — sin actualización manual: streams activos, cámaras encontradas, % de CPU, % de memoria, temperatura, estado de energía/throttling (bajo voltaje y throttling), promedio de carga de 1 minuto, tiempo de actividad, y rendimiento y conteo de lectores por stream.
**Las métricas de temperatura y energía/throttling de la Raspberry Pi requieren el kernel de Raspberry Pi** (`linux-raspi`). Con el kernel `-generic`/`virtual` de Ubuntu estas muestran "N/A" porque el SO no expone sensores térmicos. Solución: `sudo apt-get install -y linux-raspi && sudo reboot`. Todo lo demás funciona igualmente.
### Alertas por webhook
EdgeCaster puede enviar una alerta a un webhook genérico — un webhook entrante de Slack, Make.com o cualquier listener HTTP — cuando:
* Un stream se cae o no puede recuperarse
* La Pi informa **bajo voltaje** (alimentación insuficiente)
* La Pi informa **throttling térmico**
* La CPU o el promedio de carga se mantienen altos
Los umbrales son configurables, cada alerta tiene un periodo de enfriamiento y las alertas se limpian al recuperarse, para no saturar el webhook. Configúralo en **Settings → Alerts**, que incluye un botón **Send test alert**. Las alertas activas también se muestran en el panel.
### Logs en vivo
Una pestaña **Logs** (bajo **Cameras**) muestra los logs del dispositivo en vivo en una consola estilo terminal — útil para diagnosticar un problema de cámara o de conexión sin SSH:
* Fuentes: **Application**, **Streams** y **Rhombus API**
* Las líneas nuevas llegan en vivo, con niveles de log codificados por color
* Controles de pausa y limpieza
## Acceso público (opcional)
Para acceder al panel desde fuera de tu red, ve a **Settings → Public Access**, establece un **usuario y contraseña** y haz clic en **Turn on public access**. EdgeCaster crea un enlace público seguro mediante un **túnel rápido de Cloudflare** y lo muestra. No se requiere cuenta, token ni configuración de Cloudflare.
El modelo de acceso: en tu **red local nunca inicias sesión**; el **enlace público siempre requiere** el usuario y la contraseña. Solo el tráfico que llega por el túnel público es desafiado (autenticación HTTP Basic); la contraseña se almacena con hash, nunca en texto plano.
* El enlace público es **efímero** — cambia cada vez que el acceso público se reinicia. Es la contrapartida de no necesitar credenciales de Cloudflare.
* El enlace expone controles de cámara: usa una contraseña fuerte y desactiva el acceso público cuando no lo necesites.
* Solo el panel web se expone públicamente — **RTSP no se tuneliza** y permanece en la LAN.
El acceso público requiere el asistente `cloudflared`, que el instalador incluye.
## Puertos de red
| Puerto | Propósito |
| -------- | ---------------------------------------------------- |
| **80** | Interfaz web |
| **8554** | Streams RTSP (MediaMTX) |
| 8000 | API backend (interna, solo localhost) |
| 9997 | API de control de MediaMTX (interna, solo localhost) |
## Endpoints de la API de Rhombus utilizados
EdgeCaster interactúa automáticamente con 5 endpoints de la API de Rhombus:
| Endpoint | Propósito |
| -------------------------------------------- | -------------------------------------------------- |
| `POST /api/camera/getMinimalCameraStateList` | Descubre las cámaras de tu organización |
| `POST /api/camera/createRawHttpStream` | Crea un stream raw seguro para una cámara |
| `POST /api/camera/deleteRawHttpStream` | Limpia el stream cuando se deshabilita |
| `POST /api/camera/getRawHttpStreams` | Lista los streams raw existentes |
| `POST /api/location/getLocationLabelsForOrg` | Resuelve los nombres de ubicación para la interfaz |
## Gestión de servicios
EdgeCaster se ejecuta como servicios systemd (`edgecaster` y `mediamtx`) con integración de watchdog. Las cámaras habilitadas y sus slugs RTSP persisten entre reinicios, y los streams se restauran automáticamente al arrancar.
```bash theme={null}
# Check status
sudo systemctl status edgecaster mediamtx
# View logs
journalctl -u edgecaster -f
# Restart
sudo systemctl restart edgecaster
# Update now (also runs nightly on its own)
sudo bash /opt/edgecaster/scripts/edgecaster-update.sh
# Uninstall
sudo bash /opt/edgecaster/scripts/uninstall.sh
```
## Actualizaciones automáticas
EdgeCaster busca actualizaciones cada hora y las aplica (git fast-forward) durante una ventana configurable (predeterminada: 2:00–5:00 AM). Todos los métodos de instalación se actualizan automáticamente, incluidas las instalaciones manuales por checkout de git. Configúrala desde la página Settings de la interfaz web o directamente:
```yaml theme={null}
# /etc/edgecaster/config.yaml
auto_update_enabled: true
update_hour_start: 2
update_hour_end: 5
```
## Configuración
La configuración vive en `/etc/edgecaster/config.yaml`; el estado de ejecución (cámaras habilitadas y slugs RTSP) vive en `/var/lib/edgecaster/state.json`; los logs viven en `/var/log/edgecaster/`. Claves destacadas:
```yaml theme={null}
# /etc/edgecaster/config.yaml
max_streams: 0 # 0 = ilimitado (predeterminado); valor positivo = techo máximo
stall_threshold_seconds: 6 # umbral de detección de feed congelado
ffmpeg_probesize: 500000 # menor = arranque más rápido
ffmpeg_analyzeduration: 1000000
alerts_enabled: false
alert_webhook_url: ""
cpu_alert_threshold: 85 # porcentaje, sostenido
temp_alert_threshold_c: 80
load_alert_threshold: 0 # promedio de carga de 1 min; 0 = deshabilitado
```
## Desarrollo local
```bash Backend theme={null}
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
cd backend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
```
```bash Frontend theme={null}
cd frontend
npm install
npm run dev
# Dev server on http://localhost:5173, proxies /api to backend
```
```bash Tests theme={null}
pip install pytest pytest-asyncio
python -m pytest backend/tests/ -v
```
## API de EdgeCaster
El backend de EdgeCaster expone una API REST local:
| Método | Ruta | Descripción |
| ------ | ----------------------------------------- | ----------------------------------------------------- |
| `GET` | `/api/auth/status` | Verifica el estado de configuración |
| `GET` | `/api/settings` | Obtiene la configuración de la app |
| `POST` | `/api/settings/api-key` | Establece la API key de Rhombus |
| `PUT` | `/api/settings/update-schedule` | Configura la ventana de actualización automática |
| `PUT` | `/api/settings/alerts` | Configura las alertas por webhook |
| `POST` | `/api/settings/alerts/test` | Envía una alerta de prueba |
| `GET` | `/api/settings/public-access` | Obtiene el estado del acceso público |
| `POST` | `/api/settings/public-access/credentials` | Establece el usuario/contraseña del acceso público |
| `POST` | `/api/settings/public-access/enable` | Activa el acceso público |
| `POST` | `/api/settings/public-access/disable` | Desactiva el acceso público |
| `POST` | `/api/settings/discovery/refresh` | Actualiza la lista de cámaras desde Rhombus |
| `GET` | `/api/cameras` | Lista las cámaras descubiertas |
| `GET` | `/api/streams` | Lista los streams RTSP activos |
| `POST` | `/api/streams/{uuid}/enable` | Inicia el stream RTSP de una cámara |
| `POST` | `/api/streams/{uuid}/disable` | Detiene el stream RTSP |
| `GET` | `/api/system/status` | Instantánea de salud del sistema |
| `GET` | `/api/system/stream` | Estado del sistema en vivo (Server-Sent Events, \~1s) |
| `GET` | `/api/logs` | Instantánea de logs |
| `GET` | `/api/logs/stream` | Cola de logs en vivo (Server-Sent Events) |
| `GET` | `/api/logs/sources` | Lista las fuentes de logs disponibles |
## Limitaciones
* La autenticación RTSP no está habilitada en v1 — restringe el acceso mediante controles de red (puede añadirse vía configuración de MediaMTX)
* Los sistemas consumidores deben estar en la red local — el acceso público no tuneliza RTSP
* Los tokens de stream raw seguro expiran automáticamente; EdgeCaster los vuelve a obtener durante la recuperación
* Sin inicio de sesión en la interfaz web de la LAN — implementación solo en red de confianza (el acceso público añade un inicio de sesión solo para el túnel público)
## Notas de seguridad
* Tu API key se almacena en `/etc/edgecaster/config.yaml` (propiedad del usuario `edgecaster`, no legible por todos)
* Las API keys nunca se registran ni se exponen en las respuestas de la API
* El servicio systemd se ejecuta con seguridad reforzada: `NoNewPrivileges`, `ProtectSystem=strict`, `ProtectHome`, `PrivateTmp`
* Los streams RTSP no están autenticados — restringe el acceso al puerto 8554 a nivel de red
* Con el acceso público activado, solo el tráfico del túnel es desafiado con autenticación HTTP Basic; la contraseña se almacena con hash (nunca en texto plano) y el tráfico de la LAN nunca es desafiado
## Solución de problemas
Verifica que tu API key de Rhombus sea válida y tenga acceso a las cámaras. Comprueba que el dispositivo pueda alcanzar `api2.rhombussystems.com`. Intenta actualizar el descubrimiento desde la página Settings.
Comprueba que FFmpeg esté instalado (`ffmpeg -version`), que MediaMTX esté en ejecución (`systemctl status mediamtx`) y que la cámara esté en línea. Revisa la pestaña **Logs** bajo Cameras, o consulta los logs con `journalctl -u edgecaster -f`.
Confirma que el stream aparezca como "running" en la interfaz web. Prueba con VLC: `vlc rtsp://:8554/`. Comprueba que el puerto 8554 no esté bloqueado por un firewall.
En una Raspberry Pi con el kernel `-generic` o `virtual` de Ubuntu, el SO no expone sensores térmicos. Instala el kernel de Pi: `sudo apt-get install -y linux-raspi && sudo reboot`. Todas las demás métricas funcionan igualmente.
El enlace público es efímero — cambia cada vez que el acceso público se reinicia (por ejemplo, tras un reinicio del dispositivo). Abre **Settings → Public Access** desde la LAN para ver el enlace actual.
Revisa el timer: `systemctl status edgecaster-update.timer`. Verifica que la instalación sea basada en git (que exista la carpeta `.git`) y que la hora actual esté dentro de la ventana de actualización.
## ¿Necesitas ayuda?
Escribe a [support@rhombus.com](mailto:support@rhombus.com) y te ayudaremos con la configuración. Es útil incluir qué estabas haciendo y cualquier cosa que muestre el panel.
## Recursos
Código fuente, generador de imágenes y rastreador de incidencias
Integración de streaming directo sin conversión RTSP
Incrusta streams de cámara en aplicaciones React
Documentación completa de los endpoints de stream raw y de cámara