Respaldo de grabaciones en almacenamiento local - Rhombus Developer Documentation

Esta página fue traducida automáticamente. Si encuentra errores o tiene sugerencias, contáctenos.

Ejemplo de la comunidad - No soportado oficialmenteEsta guía se proporciona como un ejemplo de la comunidad y no está soportada oficialmente por Rhombus Systems. Aunque Rhombus no ofrece soporte oficial para respaldos en las instalaciones, esta guía muestra cómo implementar una solución de respaldo local usando la API de Rhombus.Usa esta implementación a tu discreción y asegúrate de que cumpla con los requisitos de respaldo y cumplimiento de tu organización.

Descripción general

Esta guía muestra cómo respaldar grabaciones de video y audio de cámaras Rhombus en dispositivos de almacenamiento local como almacenamiento conectado a la red (NAS), discos duros externos o servidores locales. La solución usa un script de Python que aprovecha la API de Rhombus para descargar grabaciones en paralelo a través de múltiples cámaras. La implementación admite:

Descargas multicámara con subprocesos (threading) para mejorar el rendimiento
Sincronización de video y audio con fusión automática
Programación flexible usando cron jobs o programadores de tareas
Rangos de tiempo personalizables para respaldar grabaciones históricas
Filtrado por ubicación para respaldar sitios específicos

Cómo funciona

Descubrimiento de cámaras

El script consulta la API de Rhombus para enumerar todas las cámaras de tu organización, filtrando por estado de conexión, ubicación o UUID de cámara específicos.

Autenticación de sesión

Se genera un token de sesión federada para cada cámara, que proporciona credenciales temporales (1 hora) para el acceso a los medios sin exponer tu API key en las URL de descarga.

Descarga de medios

Para cada cámara, el script:

Solicita las URI de la lista de reproducción MPD (MPEG-DASH) para los flujos de video y audio
Descarga el segmento de inicialización (seg_init.mp4)
Descarga segmentos de medios secuenciales de 2 segundos
Escribe los segmentos en el almacenamiento local

Fusión de audio y video

Si hay audio disponible, el script usa FFmpeg para fusionar los flujos de video y audio en un solo archivo, y luego limpia los archivos temporales.

Requisitos previos

Antes de implementar el respaldo local, asegúrate de tener:

Python 3.7 o superior instalado en tu sistema de respaldo
API key de Rhombus de la Consola de Rhombus
Conectividad de red a las cámaras Rhombus (LAN o WAN)
Espacio de almacenamiento suficiente en tu dispositivo de respaldo (estima de 1 a 2 GB por cámara por día)
FFmpeg instalado para la fusión de audio y video

Calcula tus requisitos de almacenamiento según la cantidad de cámaras, el período de retención y la calidad de grabación. Una cámara Rhombus típica genera aproximadamente de 40 a 60 GB de grabaciones por mes.

Instalación

Instalar el software requerido

Ubuntu/Debian
macOS
Windows
Synology NAS

# Actualizar la lista de paquetes
sudo apt update

# Instalar Python 3 y pip
sudo apt install python3 python3-pip

# Instalar FFmpeg
sudo apt install ffmpeg

# Instalar Git (para clonar el repositorio)
sudo apt install git

# Instalar Homebrew si aún no está instalado
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Instalar Python 3
brew install python

# Instalar FFmpeg
brew install ffmpeg

# Instalar Git
brew install git

# Instalar Python desde python.org
# Descargar desde: https://www.python.org/downloads/

# Instalar FFmpeg
# Descargar desde: https://ffmpeg.org/download.html#build-windows
# Agregar FFmpeg a tu variable de entorno PATH

# Instalar Git
# Descargar desde: https://git-scm.com/download/win

# Habilitar SSH en Control Panel > Terminal & SNMP

# Instalar Python a través del Package Center
# Buscar e instalar "Python 3"

# Instalar ffmpeg a través de SynoCommunity
# Agregar la fuente de paquetes SynoCommunity: https://synocommunity.com/
# Instalar ffmpeg desde los paquetes de la comunidad

# Instalar Git a través del Package Center

Descargar el script de respaldo

Clona el repositorio de ejemplos de la API de Rhombus:

# Clonar el repositorio
git clone https://github.com/RhombusSystems/api-examples-python.git

# Navegar al directorio de respaldo NAS
cd api-examples-python/NAS-Backup-v2

# Instalar las dependencias de Python
pip3 install -r requirements.txt

Verificar la instalación

Comprueba que todos los componentes estén instalados correctamente:

# Verificar la versión de Python
python3 --version

# Verificar la instalación de FFmpeg
ffmpeg -version

# Verificar los paquetes de pip
pip3 list | grep -E "(requests|ffmpeg|urllib3|xmltodict)"

Configuración

Parámetros de línea de comandos

El script de respaldo admite los siguientes parámetros:

string

requerido

Tu API key de Rhombus para la autenticación. Requerido a menos que uses autenticación basada en certificados.Ejemplo: --api_key YOUR_API_KEY_HERE

integer

Marca de tiempo Unix epoch para la hora de inicio del respaldo. Por defecto es hace 1 hora si no se especifica.Ejemplo: --start_time 1693526400 (31 de agosto de 2023 a las 16:00:00 UTC)

integer

Duración en segundos a respaldar desde la hora de inicio. Por defecto es 3600 segundos (1 hora).Ejemplo: --duration 7200 (2 horas)

string

Filtra el respaldo a las cámaras de una ubicación específica. Útil para implementaciones de varios sitios.Ejemplo: --location_uuid location-uuid-here

string

Respalda las grabaciones de una sola cámara específica.Ejemplo: --camera_uuid camera-uuid-here

boolean

Usa direcciones WAN en lugar de LAN. Habilítalo cuando el sistema de respaldo esté fuera de tu red local.Ejemplo: --usewan

boolean

Habilita el registro de depuración para la resolución de problemas.Ejemplo: --debug

string

Ruta al certificado de cliente para autenticación mTLS (caso de uso avanzado).Ejemplo: --cert /path/to/cert.pem

string

Ruta a la clave privada para autenticación mTLS (caso de uso avanzado).Ejemplo: --private_key /path/to/key.pem

Ejemplos de uso

Respaldo básico (última hora)

Respalda la última hora de grabaciones de todas las cámaras:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY

Rango de tiempo específico

Respalda grabaciones de una ventana específica de 2 horas:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --start_time 1693526400 \
  --duration 7200

Respaldo de una sola cámara

Respalda las grabaciones de una cámara específica:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --camera_uuid camera-uuid-here \
  --duration 3600

Respaldo por ubicación

Respalda todas las cámaras de una ubicación específica:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --location_uuid location-uuid-here \
  --duration 3600

Acceso WAN (respaldo remoto)

Respalda desde fuera de tu red local:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --usewan \
  --duration 3600

Modo de depuración

Habilita el registro detallado para la resolución de problemas:

python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --debug \
  --duration 3600

Archivos de salida

Los archivos de grabaciones descargados siguen esta convención de nomenclatura:

{CameraName}_{CameraUUID}_{Timestamp}_{Type}.{Extension}

Ejemplos:

FrontDoor_abc123def456_1693526400_video.mp4
Lobby_def789ghi012_1693526400_videoWithAudio.mp4
Warehouse_ghi345jkl678_1693526400_video.mp4

Tipos de archivo:

Archivos solo de video: formato .mp4 (cuando no hay audio disponible)
Archivos fusionados: formato .mp4 (video + audio combinados con FFmpeg)
Archivos temporales: formato .webm (se eliminan automáticamente después de la fusión)

El script limpia automáticamente los archivos temporales después de una fusión exitosa. Solo los archivos .mp4 finales permanecen en tu directorio de respaldo.

Programación de respaldos automatizados

Usando cron (Linux/macOS/NAS)

Crea respaldos automatizados usando cron jobs:

Referencia de horarios de cron:

0 * * * * - Cada hora en el minuto 0
*/30 * * * * - Cada 30 minutos
0 */4 * * * - Cada 4 horas
0 0 * * * - Diariamente a medianoche
0 2 * * 0 - Semanalmente el domingo a las 2 a.m.

Usando el Programador de tareas (Windows)

Endpoints de la API utilizados

El script de respaldo interactúa con los siguientes endpoints de la API de Rhombus:

Enumeración de cámaras

POST https://api2.rhombussystems.com/api/camera/getMinimalCameraStateList

Recupera la lista de cámaras con el estado de conexión y la información de ubicación.

Lista de pasarelas de audio

POST https://api2.rhombussystems.com/api/audiogateway/getMinimalAudioGatewayStateList

Obtiene los dispositivos de audio asociados con las cámaras.

Generación de token de sesión

POST https://api2.rhombussystems.com/api/org/generateFederatedSessionToken

Crea credenciales de sesión temporales (validez de 1 hora) para el acceso seguro a los medios.

URI de medios de video

POST https://api2.rhombussystems.com/api/camera/getMediaUris

Obtiene las plantillas de listas de reproducción MPD (MPEG-DASH) para los flujos de video.

URI de medios de audio

POST https://api2.rhombussystems.com/api/audiogateway/getMediaUris

Obtiene las plantillas MPD para los flujos de audio.

Todas las llamadas a la API requieren autenticación usando el encabezado x-auth-scheme: api-token con tu API key, o autenticación mTLS basada en certificados.

Optimización del rendimiento

Configuración de subprocesos

El script usa el ThreadPoolExecutor de Python con un máximo de 4 workers concurrentes. Esto equilibra la velocidad de descarga con los límites de tasa de la API y los recursos del sistema. Para ajustar la cantidad de subprocesos, modifica el script:

# En copy_footage_script_threading.py
with ThreadPoolExecutor(max_workers=4) as executor:  # Cambia 4 al valor deseado

Recomendaciones:

2-4 workers: NAS estándar o sistemas de gama baja
4-8 workers: NAS o servidores de alto rendimiento
8-16 workers: servidores empresariales con alto ancho de banda

Aumentar la cantidad de subprocesos más allá de los valores recomendados puede activar la limitación de tasa o sobrecargar tu red/almacenamiento.

Consideraciones de almacenamiento

Calcular el espacio requerido:

Storage (GB) = Cameras × Days × 1.5 GB/day

Ejemplo:

10 cámaras × 30 días × 1.5 GB = 450 GB requeridos

Prácticas recomendadas:

Mantén al menos un 20% de espacio libre en el dispositivo de respaldo
Implementa políticas de retención para eliminar grabaciones antiguas
Monitorea el uso del disco con regularidad
Usa compresión si necesitas archivado a largo plazo

Optimización de red

LAN vs WAN:

Modo LAN (predeterminado): descargas más rápidas, usa direcciones de red local
Modo WAN (--usewan): requerido para respaldos remotos, más lento pero accesible desde cualquier lugar

Requisitos de ancho de banda:

Aproximadamente de 2 a 4 Mbps por descarga de cámara concurrente
4 workers = de 8 a 16 Mbps de ancho de banda recomendado

Retención y limpieza

Implementa una política de retención para administrar el uso del almacenamiento:

# Crear el script de limpieza
cat > cleanup_old_footage.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/path/to/backup/directory"
RETENTION_DAYS=30

find "$BACKUP_DIR" -name "*.mp4" -type f -mtime +$RETENTION_DAYS -delete
find "$BACKUP_DIR" -name "*.webm" -type f -mtime +$RETENTION_DAYS -delete

echo "Deleted footage older than $RETENTION_DAYS days"
EOF

chmod +x cleanup_old_footage.sh

# Agregar al crontab (se ejecuta cada domingo a las 3 a.m.)
0 3 * * 0 /path/to/cleanup_old_footage.sh >> /var/log/rhombus_cleanup.log 2>&1

import os
import time
from pathlib import Path

def cleanup_old_files(backup_dir, retention_days):
    """Elimina los archivos de grabaciones más antiguos que el período de retención"""
    cutoff_time = time.time() - (retention_days * 86400)
    removed_count = 0
    freed_space = 0

    for file in Path(backup_dir).glob("**/*.mp4"):
        if file.stat().st_mtime < cutoff_time:
            size = file.stat().st_size
            file.unlink()
            removed_count += 1
            freed_space += size

    print(f"Removed {removed_count} files")
    print(f"Freed {freed_space / (1024**3):.2f} GB")

# Uso
cleanup_old_files("/path/to/backup", retention_days=30)

Resolución de problemas

El script falla con un error de autenticación

Síntomas:

Errores 401 Unauthorized
Mensajes Invalid API key

Soluciones:

Verifica que la API key sea correcta en la Consola de Rhombus
Asegúrate de que la API key tenga permisos de acceso a las cámaras
Comprueba que el encabezado x-auth-scheme esté configurado correctamente
Regenera la API key si está comprometida

# Probar la autenticación de la API
curl -X POST https://api2.rhombussystems.com/api/camera/getMinimalCameraStateList \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY"

Las descargas son muy lentas

Síntomas:

Las descargas tardan más de lo esperado
Errores de tiempo de espera de red

Soluciones:

Usa el modo LAN en lugar de WAN si respaldas localmente
Reduce la cantidad de subprocesos en ThreadPoolExecutor
Verifica el ancho de banda de la red y la conectividad de las cámaras
Verifica la velocidad de escritura del dispositivo de almacenamiento
Considera programar los respaldos durante las horas de menor actividad

# Probar con menos subprocesos y modo de depuración
python3 copy_footage_script_threading.py \
  --api_key YOUR_API_KEY \
  --debug \
  --duration 600  # Comienza con 10 minutos

La fusión de FFmpeg falla

Síntomas:

Permanecen archivos .webm temporales
No hay salida .mp4 fusionada
Mensajes de error de FFmpeg

Soluciones:

Verifica que FFmpeg esté instalado y en el PATH
Comprueba que tanto los archivos de video como los de audio se hayan descargado
Asegúrate de tener suficiente espacio en disco para los archivos temporales
Actualiza FFmpeg a la última versión

# Verificar la instalación de FFmpeg
which ffmpeg
ffmpeg -version

# Prueba de fusión manual
ffmpeg -i video.webm -i audio.webm -c copy output.mp4

No se encuentran cámaras

Síntomas:

El script informa 0 cámaras para respaldar
Lista de cámaras vacía

Soluciones:

Verifica que las cámaras estén en línea en la Consola de Rhombus
Comprueba el filtro de UUID de ubicación si se especificó
Asegúrate de que la API key tenga acceso a las cámaras
Revisa los filtros de estado de conexión de las cámaras en el script

# Listar todas las cámaras a través de la API
curl -X POST https://api2.rhombussystems.com/api/camera/getMinimalCameraStateList \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  | python3 -m json.tool

Problemas de espacio en disco

Síntomas:

El script falla con errores de escritura
Mensajes No space left on device

Soluciones:

Verifica el espacio disponible en disco: df -h
Implementa una política de retención para eliminar grabaciones antiguas
Reduce la duración o la frecuencia del respaldo
Agrega capacidad de almacenamiento adicional
Usa compresión para las grabaciones archivadas

# Verificar el uso del disco
df -h /path/to/backup

# Encontrar los archivos más grandes
du -sh /path/to/backup/* | sort -hr | head -10

El cron job no se ejecuta

Síntomas:

Los respaldos programados no se ejecutan
No se crean nuevos archivos de grabaciones

Soluciones:

Verifica el estado del servicio cron: systemctl status cron
Verifica la sintaxis del crontab: crontab -l
Revisa los registros de cron: grep CRON /var/log/syslog
Asegúrate de que las rutas del script sean absolutas
Verifica los permisos del usuario

# Probar el cron job manualmente
cd /path/to/NAS-Backup-v2
/usr/bin/python3 copy_footage_script_threading.py --api_key YOUR_API_KEY

# Revisar los registros de cron
tail -f /var/log/syslog | grep CRON

Prácticas recomendadas

Proteger las API keys

Nunca incluyas API keys directamente en los scripts. Usa variables de entorno o sistemas seguros de administración de claves. Rota las API keys con regularidad.

Monitorear los respaldos

Configura monitoreo y alertas para las fallas de respaldo. Revisa los registros con regularidad para asegurarte de que los respaldos se completen correctamente.

Probar las restauraciones

Prueba con regularidad la restauración de grabaciones desde los respaldos para verificar la integridad y confirmar que tu proceso de recuperación funciona.

Implementar retención

Define y aplica políticas de retención para administrar los costos de almacenamiento y cumplir con las regulaciones de protección de datos.

Usar redundancia

Considera múltiples ubicaciones de respaldo (en el sitio + fuera del sitio) para las grabaciones críticas. Implementa la regla de respaldo 3-2-1.

Documentar los procedimientos

Mantén documentación de tu configuración de respaldo, horarios y procedimientos de recuperación para tu equipo.

Consideraciones de seguridad

Sigue estas prácticas recomendadas de seguridad al implementar el respaldo local:

Protección de la API key

Almacena de forma segura: usa variables de entorno o administradores de credenciales
Restringe el acceso: limita los permisos de los archivos de los scripts que contienen claves
Rota con regularidad: cambia las API keys periódicamente
Audita el uso: monitorea la actividad de la API key en la Consola de Rhombus

# Almacenar la API key en una variable de entorno
export RHOMBUS_API_KEY="your-api-key-here"

# Usar en el script
python3 copy_footage_script_threading.py --api_key "$RHOMBUS_API_KEY"

# Restringir los permisos del script
chmod 600 backup_script.sh

Seguridad de red

Usa el modo LAN cuando sea posible para evitar la exposición a la WAN
Implementa reglas de firewall para restringir el acceso
Considera una VPN para escenarios de respaldo remoto
Habilita la autenticación mTLS para mayor seguridad

Seguridad del almacenamiento

Cifra los dispositivos de almacenamiento de respaldo
Restringe los permisos del sistema de archivos
Implementa controles de acceso en el NAS/servidor
Audita con regularidad quién tiene acceso a los archivos de respaldo

Consideraciones de cumplimiento

Al implementar el respaldo local, considera: Retención de datos:

Sigue las políticas de retención de datos de tu organización
Cumple con las regulaciones de la industria (HIPAA, GDPR, etc.)
Documenta los períodos de retención y los procedimientos de eliminación

Control de acceso:

Mantén registros de auditoría de quién accede a las grabaciones de respaldo
Implementa controles de acceso basados en roles
Documenta al personal autorizado

Protección de datos:

Cifra los datos en reposo y en tránsito
Implementa procedimientos de eliminación segura
Evaluaciones de seguridad periódicas

Configuración avanzada

Directorio de salida personalizado

Modifica el script para guardar los archivos en un directorio específico:

# En copy_footage_script_threading.py
OUTPUT_DIR = "/mnt/nas/rhombus_backups"

# Crear la estructura de directorios por fecha
import datetime
date_dir = datetime.datetime.now().strftime("%Y-%m-%d")
output_path = os.path.join(OUTPUT_DIR, date_dir)
os.makedirs(output_path, exist_ok=True)

Notificaciones por correo electrónico

Agrega alertas por correo electrónico para la finalización o las fallas de los respaldos:

import os
import smtplib
from email.mime.text import MIMEText

def send_notification(status, message):
    msg = MIMEText(message)
    msg['Subject'] = f'Rhombus Backup {status}'
    msg['From'] = 'backup@yourcompany.com'
    msg['To'] = 'admin@yourcompany.com'

    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login(os.environ['SMTP_EMAIL'], os.environ['SMTP_PASSWORD'])
        server.send_message(msg)

# Usar después de que se complete el respaldo
try:
    # ... código de respaldo ...
    send_notification("Success", "All cameras backed up successfully")
except Exception as e:
    send_notification("Failed", f"Backup failed: {str(e)}")

Integración de webhooks

Activa webhooks después de que se complete el respaldo:

import datetime
import requests

def trigger_webhook(status, cameras_backed_up):
    webhook_url = "https://your-webhook-endpoint.com/backup"
    payload = {
        "status": status,
        "timestamp": datetime.datetime.now().isoformat(),
        "cameras": cameras_backed_up
    }
    requests.post(webhook_url, json=payload)

Próximos pasos

Implementación de transmisión de video

Aprende a transmitir grabaciones en vivo desde cámaras Rhombus

Integración de webhooks

Configura webhooks para recibir eventos en tiempo real

Repositorio de GitHub

Accede al código fuente completo del script de respaldo

Comunidad de desarrolladores

Haz preguntas y comparte tu implementación

Recursos adicionales

Documentación de la API de Rhombus: referencia completa de la API para todos los endpoints
Documentación de Python Requests: docs.python-requests.org
Documentación de FFmpeg: ffmpeg.org/documentation
Documentación de Cron: man7.org/linux/man-pages/man5/crontab.5.html

Para preguntas, problemas o para compartir tu implementación de respaldo, visita la Comunidad de desarrolladores de Rhombus y publica en la sección Guides & Resources.

​Descripción general

​Cómo funciona

​Requisitos previos

​Instalación

​Instalar el software requerido

​Descargar el script de respaldo

​Verificar la instalación

​Configuración

​Parámetros de línea de comandos

​Ejemplos de uso

​Respaldo básico (última hora)

​Rango de tiempo específico

​Respaldo de una sola cámara

​Respaldo por ubicación

​Acceso WAN (respaldo remoto)

​Modo de depuración

​Archivos de salida

​Programación de respaldos automatizados

​Usando cron (Linux/macOS/NAS)

​Usando el Programador de tareas (Windows)

​Endpoints de la API utilizados

​Enumeración de cámaras

​Lista de pasarelas de audio

​Generación de token de sesión

​URI de medios de video

​URI de medios de audio

​Optimización del rendimiento

​Configuración de subprocesos

​Consideraciones de almacenamiento

​Optimización de red

​Retención y limpieza

​Resolución de problemas

​Prácticas recomendadas

Proteger las API keys

Monitorear los respaldos

Probar las restauraciones

Implementar retención

Usar redundancia

Documentar los procedimientos

​Consideraciones de seguridad

​Protección de la API key

​Seguridad de red

​Seguridad del almacenamiento

​Consideraciones de cumplimiento

​Configuración avanzada

​Directorio de salida personalizado

​Notificaciones por correo electrónico

​Integración de webhooks

​Próximos pasos

Implementación de transmisión de video

Integración de webhooks

Repositorio de GitHub

Comunidad de desarrolladores

​Recursos adicionales

Descripción general

Cómo funciona

Requisitos previos

Instalación

Instalar el software requerido

Descargar el script de respaldo

Verificar la instalación

Configuración

Parámetros de línea de comandos

Ejemplos de uso

Respaldo básico (última hora)

Rango de tiempo específico

Respaldo de una sola cámara

Respaldo por ubicación

Acceso WAN (respaldo remoto)

Modo de depuración

Archivos de salida

Programación de respaldos automatizados

Usando cron (Linux/macOS/NAS)

Usando el Programador de tareas (Windows)

Endpoints de la API utilizados

Enumeración de cámaras

Lista de pasarelas de audio

Generación de token de sesión

URI de medios de video

URI de medios de audio

Optimización del rendimiento

Configuración de subprocesos

Consideraciones de almacenamiento

Optimización de red

Retención y limpieza

Resolución de problemas

Prácticas recomendadas

Consideraciones de seguridad

Protección de la API key

Seguridad de red

Seguridad del almacenamiento

Consideraciones de cumplimiento

Configuración avanzada

Directorio de salida personalizado

Notificaciones por correo electrónico

Integración de webhooks

Próximos pasos

Recursos adicionales