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

# 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 fue traducida automáticamente. Si encuentra errores o tiene sugerencias, [contáctenos](mailto:support@rhombus.com).
</Note>

<Warning>
  **Ejemplo de la comunidad - No soportado oficialmente**

  Esta 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.
</Warning>

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

<Steps>
  <Step title="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.
  </Step>

  <Step title="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.
  </Step>

  <Step title="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
  </Step>

  <Step title="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.
  </Step>
</Steps>

## 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](https://console.rhombussystems.com)
* **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.
</Tip>

## Instalación

### Instalar el software requerido

<Tabs>
  <Tab title="Ubuntu/Debian">
    ```bash theme={null}
    # 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
    ```
  </Tab>

  <Tab title="macOS">
    ```bash theme={null}
    # 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
    ```
  </Tab>

  <Tab title="Windows">
    ```powershell theme={null}
    # 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
    ```
  </Tab>

  <Tab title="Synology NAS">
    ```bash theme={null}
    # 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
    ```
  </Tab>
</Tabs>

### Descargar el script de respaldo

Clona el repositorio de ejemplos de la API de Rhombus:

```bash theme={null}
# 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 theme={null}
# 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:

<ParamField path="--api_key" type="string" required>
  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`
</ParamField>

<ParamField path="--start_time" type="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)
</ParamField>

<ParamField path="--duration" type="integer">
  Duración en segundos a respaldar desde la hora de inicio. Por defecto es 3600 segundos (1 hora).

  **Ejemplo**: `--duration 7200` (2 horas)
</ParamField>

<ParamField path="--location_uuid" type="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`
</ParamField>

<ParamField path="--camera_uuid" type="string">
  Respalda las grabaciones de una sola cámara específica.

  **Ejemplo**: `--camera_uuid camera-uuid-here`
</ParamField>

<ParamField path="--usewan" type="boolean">
  Usa direcciones WAN en lugar de LAN. Habilítalo cuando el sistema de respaldo esté fuera de tu red local.

  **Ejemplo**: `--usewan`
</ParamField>

<ParamField path="--debug" type="boolean">
  Habilita el registro de depuración para la resolución de problemas.

  **Ejemplo**: `--debug`
</ParamField>

<ParamField path="--cert" type="string">
  Ruta al certificado de cliente para autenticación mTLS (caso de uso avanzado).

  **Ejemplo**: `--cert /path/to/cert.pem`
</ParamField>

<ParamField path="--private_key" type="string">
  Ruta a la clave privada para autenticación mTLS (caso de uso avanzado).

  **Ejemplo**: `--private_key /path/to/key.pem`
</ParamField>

## Ejemplos de uso

### Respaldo básico (última hora)

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

```bash theme={null}
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 theme={null}
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 theme={null}
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 theme={null}
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 theme={null}
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 theme={null}
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 theme={null}
{CameraName}_{CameraUUID}_{Timestamp}_{Type}.{Extension}
```

**Ejemplos:**

```text theme={null}
FrontDoor_abc123def456_1693526400_video.mp4
Lobby_def789ghi012_1693526400_merged.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.
</Note>

## Programación de respaldos automatizados

### Usando cron (Linux/macOS/NAS)

Crea respaldos automatizados usando cron jobs:

<Steps>
  ### Editar el crontab

  Abre tu configuración de crontab:

  ```bash theme={null}
  crontab -e
  ```

  ### Agregar el horario de respaldo

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

  <CodeGroup>
    ```bash Hourly Backup theme={null}
    # 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) theme={null}
    # 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 theme={null}
    # 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 theme={null}
    # 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
    ```
  </CodeGroup>

  ### Guardar y verificar

  Guarda el crontab y verifica que esté programado:

  ```bash theme={null}
  # Listar los cron jobs actuales
  crontab -l

  # Verificar el estado del servicio cron
  sudo systemctl status cron
  ```
</Steps>

<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.
</Tip>

### Usando el Programador de tareas (Windows)

<Steps>
  ### Abrir el Programador de tareas

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

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

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

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

  ### Guardar y probar

  1. Haz clic en **OK** para guardar
  2. Haz clic derecho en la tarea y selecciona **"Run"** para probarla
</Steps>

## 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 theme={null}
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 theme={null}
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 theme={null}
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

```text theme={null}
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 theme={null}
POST https://api2.rhombussystems.com/api/audiogateway/getMediaUris
```

Obtiene las plantillas MPD para los flujos de audio.

<Note>
  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.
</Note>

## 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 theme={null}
# 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.
</Warning>

### Consideraciones de almacenamiento

**Calcular el espacio requerido:**

```text theme={null}
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:

<CodeGroup>
  ```bash Delete Files Older Than 30 Days theme={null}
  # 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) theme={null}
  # 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 theme={null}
  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)
  ```
</CodeGroup>

## Resolución de problemas

<AccordionGroup>
  <Accordion title="El script falla con un error de autenticación">
    **Síntomas:**

    * Errores `401 Unauthorized`
    * Mensajes `Invalid API key`

    **Soluciones:**

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

    ```bash theme={null}
    # 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"
    ```
  </Accordion>

  <Accordion title="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 theme={null}
    # 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
    ```
  </Accordion>

  <Accordion title="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 theme={null}
    # 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
    ```
  </Accordion>

  <Accordion title="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 API key tenga acceso a las cámaras
    4. Revisa los filtros de estado de conexión de las cámaras en el script

    ```bash theme={null}
    # 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
    ```
  </Accordion>

  <Accordion title="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 theme={null}
    # 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
    ```
  </Accordion>

  <Accordion title="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 theme={null}
    # 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
    ```
  </Accordion>
</AccordionGroup>

## Prácticas recomendadas

<CardGroup cols={2}>
  <Card title="Proteger las API keys" icon="key">
    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.
  </Card>

  <Card title="Monitorear los respaldos" icon="chart-line">
    Configura monitoreo y alertas para las fallas de respaldo. Revisa los registros con regularidad para asegurarte de que los respaldos se completen correctamente.
  </Card>

  <Card title="Probar las restauraciones" icon="rotate-right">
    Prueba con regularidad la restauración de grabaciones desde los respaldos para verificar la integridad y confirmar que tu proceso de recuperación funciona.
  </Card>

  <Card title="Implementar retención" icon="calendar">
    Define y aplica políticas de retención para administrar los costos de almacenamiento y cumplir con las regulaciones de protección de datos.
  </Card>

  <Card title="Usar redundancia" icon="copy">
    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.
  </Card>

  <Card title="Documentar los procedimientos" icon="book">
    Mantén documentación de tu configuración de respaldo, horarios y procedimientos de recuperación para tu equipo.
  </Card>
</CardGroup>

## Consideraciones de seguridad

<Warning>
  Sigue estas prácticas recomendadas de seguridad al implementar el respaldo local:
</Warning>

### 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 API keys periódicamente
4. **Audita el uso**: monitorea la actividad de la API key en la Consola de Rhombus

```bash theme={null}
# 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 theme={null}
# 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 theme={null}
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 theme={null}
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

<CardGroup cols={2}>
  <Card title="Implementación de transmisión de video" icon="video" href="/es/implementations/streaming-video">
    Aprende a transmitir grabaciones en vivo desde cámaras Rhombus
  </Card>

  <Card title="Integración de webhooks" icon="webhook" href="/es/implementations/webhook-listener">
    Configura webhooks para recibir eventos en tiempo real
  </Card>

  <Card title="Repositorio de GitHub" icon="github" href="https://github.com/RhombusSystems/api-examples-python/tree/master/NAS-Backup-v2">
    Accede al código fuente completo del script de respaldo
  </Card>

  <Card title="Comunidad de desarrolladores" icon="comments" href="https://rhombus.community">
    Haz preguntas y comparte tu implementación
  </Card>
</CardGroup>

## 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>
  Para preguntas, problemas o para compartir tu implementación de respaldo, visita la [Comunidad de desarrolladores de Rhombus](https://rhombus.community) y publica en la sección Guides & Resources.
</Note>