Respaldo de grabaciones en almacenamiento local

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 usa 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

1. 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.

2. 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 clave de API en las URL de descarga. Las cámaras de tu LAN solo aceptan tokens federados, por diseño, así que el modo LAN siempre usa uno.

3. Descarga de medios

   Para cada cámara, el script:

   1. Solicita las URI de la lista de reproducción MPD (MPEG-DASH) para los flujos de video y audio
   2. Descarga el segmento de inicialización (seg_init.mp4)
   3. Descarga segmentos de medios secuenciales de 2 segundos
   4. Escribe los segmentos en el almacenamiento local
4. 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
• Clave de API 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

Instalación

Instalar el software requerido

# 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:

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)

Programación de respaldos automatizados

Usando cron (Linux/macOS/NAS)

Crea respaldos automatizados usando cron jobs:

1. Editar el crontab

   Abre tu configuración de crontab:

   bash

   crontab -e

2. Agregar el horario de respaldo

   Agrega uno de los siguientes ejemplos según tus necesidades:

   Hourly BackupDaily Backup (Midnight)Every 4 HoursBusiness Hours Only

   bash

   # Respaldar cada hora en el minuto 0
   0 * * * * cd /path/to/api-examples-python/NAS-Backup-v2 && /usr/bin/python3 copy_footage_script_threading.py --api_key YOUR_API_KEY --duration 3600 >> /var/log/rhombus_backup.log 2>&1

3. Guardar y verificar

   Guarda el crontab y verifica que esté programado:

   bash

   # Listar los cron jobs actuales
   crontab -l
   
   # Verificar el estado del servicio cron
   sudo systemctl status cron

Usando el Programador de tareas (Windows)

1. Abrir el Programador de tareas

   Presiona Win + R, escribe taskschd.msc y presiona Enter.

2. Crear una nueva tarea
   1. Haz clic en "Create Task" en el panel derecho
   2. Nómbrala "Rhombus Footage Backup"
   3. Selecciona "Run whether user is logged on or not"
3. Configurar el desencadenador
   1. Ve a la pestaña Triggers
   2. Haz clic en New
   3. Elige la frecuencia (Daily, Weekly, etc.)
   4. Establece la hora de inicio y la recurrencia
4. Configurar la acción
   1. Ve a la pestaña Actions
   2. Haz clic en New
   3. Action: Start a program
   4. Program: C:\Python39\python.exe (ajusta la ruta)
   5. Arguments: copy_footage_script_threading.py --api_key YOUR_API_KEY --duration 3600
   6. Start in: C:\path\to\NAS-Backup-v2
5. Guardar y probar
   1. Haz clic en OK para guardar
   2. Haz clic derecho en la tarea y selecciona "Run" para probarla

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 un token federado para el acceso a los medios. El script pide una hora; el expiresAtMs de la respuesta indica cuándo expira el token, y ningún token federado dura más de 24 horas.

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.

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

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

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

# 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

# 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

# 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

# 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

# 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

Consideraciones de seguridad

Protección de la API key

1. Almacena de forma segura: usa variables de entorno o administradores de credenciales
2. Restringe el acceso: limita los permisos de los archivos de los scripts que contienen claves
3. Rota con regularidad: cambia las claves de API periódicamente
4. Audita el uso: monitorea la actividad de la clave de API 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

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