> ## Índice de la documentación > Consulta el índice completo de la documentación en: https://developer.rhombus.com/llms.txt > Úsalo para descubrir todas las páginas disponibles antes de seguir explorando. # Respaldo de grabaciones en almacenamiento local > Descarga y archiva grabaciones de cámaras Rhombus en almacenamiento local como NAS o unidades externas usando la API para cumplimiento, retención y acceso sin conexión. > **Note**: Esta página se tradujo automáticamente. Si encuentras errores o tienes sugerencias, [escríbenos](mailto:support@rhombus.com). > **Warning**: **Implementación de ejemplo — no cubierta por el Soporte de Rhombus** > > Esta guía es una implementación de ejemplo y **no está cubierta por el Soporte de Rhombus**. 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 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](https://console.rhombussystems.com/settings/integrations/api-tokens/) - **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 > **Tip**: 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** ```bash # 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 ``` **macOS** ```bash # 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 ``` **Windows** ```powershell # 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 ``` **Synology NAS** ```bash # 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: ```bash # 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: ```bash # 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: - **`--api_key` (path, string, required)**: Tu clave de API de Rhombus para la autenticación. Requerido a menos que uses autenticación basada en certificados. **Ejemplo**: `--api_key YOUR_API_KEY_HERE` - **`--start_time` (path, 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) - **`--duration` (path, integer)**: Duración en segundos a respaldar desde la hora de inicio. Por defecto es 3600 segundos (1 hora). **Ejemplo**: `--duration 7200` (2 horas) - **`--location_uuid` (path, 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` - **`--camera_uuid` (path, string)**: Respalda las grabaciones de una sola cámara específica. **Ejemplo**: `--camera_uuid camera-uuid-here` - **`--usewan` (path, boolean)**: Usa direcciones WAN en lugar de LAN. Habilítalo cuando el sistema de respaldo esté fuera de tu red local. **Ejemplo**: `--usewan` - **`--debug` (path, boolean)**: Habilita el registro de depuración para la resolución de problemas. **Ejemplo**: `--debug` - **`--cert` (path, string)**: Ruta al certificado de cliente para autenticación mTLS (caso de uso avanzado). **Ejemplo**: `--cert /path/to/cert.pem` - **`--private_key` (path, 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```text {CameraName}_{CameraUUID}_{Timestamp}_{Type}.{Extension} ``` **Ejemplos:** ```text 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) > **Note**: 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: 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: ```bash Hourly Backup # 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 ``` ```bash Daily Backup (Midnight) # Respaldar las últimas 24 horas a medianoche 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 86400 >> /var/log/rhombus_backup.log 2>&1 ``` ```bash Every 4 Hours # Respaldar cada 4 horas 0 */4 * * * cd /path/to/api-examples-python/NAS-Backup-v2 && /usr/bin/python3 copy_footage_script_threading.py --api_key YOUR_API_KEY --duration 14400 >> /var/log/rhombus_backup.log 2>&1 ``` ```bash Business Hours Only # Respaldar cada 2 horas durante el horario laboral (8 a.m. - 6 p.m., lun-vie) 0 8-18/2 * * 1-5 cd /path/to/api-examples-python/NAS-Backup-v2 && /usr/bin/python3 copy_footage_script_threading.py --api_key YOUR_API_KEY --duration 7200 >> /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 ``` > **Tip**: **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) 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 ```text 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 ```text 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 ```text 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 ```text 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 ```text POST https://api2.rhombussystems.com/api/audiogateway/getMediaUris ``` Obtiene las plantillas MPD para los flujos de audio. > **Note**: Todas las llamadas a la API REST se autentican con tu clave de API (`x-auth-scheme: api-token` y `x-auth-apikey`) o, con `--cert` y `--private_key`, con una clave de certificado mediante mTLS. Las claves de certificado solo funcionan en la API REST; las descargas de medios usan el token federado que genera el script. ## 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: ```python # 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 > **Warning**: 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:** ```text 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: ```bash Delete Files Older Than 30 Days # 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 ``` ```bash Automated Weekly Cleanup (Cron) # 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 ``` ```python Python Cleanup Script 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:** - Respuestas `401` cuyo `errorCode` JSON es `INVALID_CREDENTIAL` (una clave desconocida o eliminada), `CREDENTIAL_EXPIRED` (la clave expiró) o `UNAUTHENTICATED` (no llegó ninguna clave al servidor) **Soluciones:** 1. Verifica que la clave de API sea correcta en la Consola de Rhombus y que no haya expirado 2. Asegúrate de que la clave de API tenga permisos de acceso a las cámaras 3. Comprueba que el encabezado `x-auth-scheme` esté configurado correctamente 4. Regenera la clave de API si está comprometida ```bash # 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:** 1. Usa el modo LAN en lugar de WAN si respaldas localmente 2. Reduce la cantidad de subprocesos en `ThreadPoolExecutor` 3. Verifica el ancho de banda de la red y la conectividad de las cámaras 4. Verifica la velocidad de escritura del dispositivo de almacenamiento 5. Considera programar los respaldos durante las horas de menor actividad ```bash # 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:** 1. Verifica que FFmpeg esté instalado y en el PATH 2. Comprueba que tanto los archivos de video como los de audio se hayan descargado 3. Asegúrate de tener suficiente espacio en disco para los archivos temporales 4. Actualiza FFmpeg a la última versión ```bash # 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:** 1. Verifica que las cámaras estén en línea en la Consola de Rhombus 2. Comprueba el filtro de UUID de ubicación si se especificó 3. Asegúrate de que la clave de API tenga acceso a las cámaras 4. Revisa los filtros de estado de conexión de las cámaras en el script ```bash # 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:** 1. Verifica el espacio disponible en disco: `df -h` 2. Implementa una política de retención para eliminar grabaciones antiguas 3. Reduce la duración o la frecuencia del respaldo 4. Agrega capacidad de almacenamiento adicional 5. Usa compresión para las grabaciones archivadas ```bash # 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:** 1. Verifica el estado del servicio cron: `systemctl status cron` 2. Verifica la sintaxis del crontab: `crontab -l` 3. Revisa los registros de cron: `grep CRON /var/log/syslog` 4. Asegúrate de que las rutas del script sean absolutas 5. Verifica los permisos del usuario ```bash # 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 claves de API**: Nunca incluyas claves de API directamente en los scripts. Usa variables de entorno o sistemas seguros de administración de claves. Rota las claves de API 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 > **Warning**: Sigue estas prácticas recomendadas de seguridad al implementar el respaldo local: ### 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 ```bash # 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: ```python # 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: ```python 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: ```python 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](https://developer.rhombus.com/es/implementations/streaming-video)**: Aprende a transmitir grabaciones en vivo desde cámaras Rhombus - **[Integración de webhooks](https://developer.rhombus.com/es/implementations/webhook-listener)**: Configura webhooks para recibir eventos en tiempo real - **[Repositorio de GitHub](https://github.com/RhombusSystems/api-examples-python/tree/master/NAS-Backup-v2)**: Accede al código fuente completo del script de respaldo - **[Soporte de Rhombus](mailto:support@rhombus.com)**: Contacta al Soporte de Rhombus para obtener ayuda con tu integració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](https://docs.python-requests.org/) - **Documentación de FFmpeg**: [ffmpeg.org/documentation](https://ffmpeg.org/documentation.html) - **Documentación de Cron**: [man7.org/linux/man-pages/man5/crontab.5.html](https://man7.org/linux/man-pages/man5/crontab.5.html) > **Note**: Si tienes preguntas sobre los endpoints de la API de Rhombus que usa este ejemplo, escribe a .