---
title: "Backup y recuperación"
description: "Aprende a configurar backups automáticos, recuperar tu base de datos de MPCIUM e integrar AWS S3 para el almacenamiento en la nube."
url: https://docs.fystack.io/es/mpcium/backup
last_updated: 2026-11-13
---

> ## Documentation index
> Fetch the complete documentation index at: https://docs.fystack.io/llms.txt
> Use it to discover all available pages before exploring further.

# Backup y recuperación

MPCIUM ofrece capacidades robustas de backup y recuperación para garantizar que los datos de tu clúster MPC distribuido estén protegidos contra pérdidas. El sistema de backup usa una estrategia de backup incremental con cifrado para almacenar y proteger de forma eficiente el estado de tu base de datos, minimizando el uso de recursos.

_Diagram: Backup incremental_

> **Warning.** **Importante**: prueba siempre tus procedimientos de backup y recuperación en un entorno que no sea de producción antes de implementarlos en producción.

## Configuración de backups

MPCIUM admite una configuración de backups ajustable en tu archivo `config.yaml`:

**Configuración de backups**

```yaml
# Backup Configuration
backup_enabled: true                    # Enable/disable automatic backups (default: true)
backup_period_seconds: 300              # How often to perform backups in seconds (default: 300)
backup_dir: "./backups"                 # Directory where encrypted backups are stored
```

### Parámetros de configuración

**backup_enabled** (boolean)

Controla si se realizan backups automáticos. Configúralo en `false` para desactivar los backups por completo.

**backup_period_seconds** (integer)

Define el intervalo entre backups automáticos, en segundos. El valor predeterminado de 300 segundos (5 minutos) ofrece un buen equilibrio entre la protección de los datos y el rendimiento del sistema.

**backup_dir** (string)

Especifica el directorio donde se almacenan los archivos de backup cifrados. Asegúrate de que este directorio tenga los permisos adecuados y suficiente espacio en disco.

## Estrategia de backup

MPCIUM implementa una **estrategia de backup incremental** que almacena de forma eficiente solo los cambios desde el último backup, lo que reduce los requisitos de almacenamiento y el tiempo de backup. Este enfoque garantiza que cada backup no sea un duplicado de los anteriores, lo que ahorra una cantidad significativa de espacio de almacenamiento y ancho de banda de red sin dejar de proteger completamente los datos.

### Estructura de los archivos de backup

Los archivos de backup se almacenan en el directorio de backup configurado con la siguiente convención de nombres:

```
node0/
└── backups/
    ├── backup-node0-2025-07-28_20-46-39-1.enc
    ├── backup-node0-2025-07-28_20-48-39-2.enc
    ├── backup-node0-2025-07-28_20-49-39-3.enc
    └── latest.version
```

### Formato de los archivos de backup

Cada archivo de backup contiene:

- **Cambios incrementales de la base de datos** desde el último backup (no duplicados completos)
- **Estado cifrado de la base de datos** con cifrado AES-256-GCM para mayor seguridad durante el tránsito y el almacenamiento
- **Metadatos**, que incluyen la marca de tiempo de creación, los parámetros de cifrado y la información de versión
- **Cadena de actualizaciones incrementales** que puede reconstruirse para restaurar el estado completo de la base de datos

### Ejemplo de metadatos de backup

```json
{
  "algo": "AES-256-GCM",
  "nonce_b64": "MgDMCSqKNujD+9na",
  "created_at": "2025-07-28T20:46:39+07:00",
  "since": 0,
  "next_since": 6,
  "encryption_key_id": "bd1937594bea2580"
}
```

> **Info.** **Seguridad**: los archivos de backup se cifran con la misma `badger_password` que se usa para cifrar la base de datos, lo que garantiza que tus datos de backup permanezcan seguros durante el tránsito y el almacenamiento. El enfoque incremental combinado con el cifrado ofrece tanto eficiencia de recursos como protección de los datos.

## Procedimientos de recuperación

### Usar mpcium-cli recover

Para recuperar tu base de datos de MPCIUM a partir de archivos de backup cifrados, usa el comando `mpcium-cli recover`:

**Comando de recuperación**

```bash
mpcium-cli recover --help

NAME:
   mpcium recover - Recover database from encrypted backup files

USAGE:
   mpcium recover [command [command options]]

OPTIONS:
   --backup-dir string, -b string             Directory containing encrypted backup files
   --recovery-path string, -r string          Target path for database recovery
   --backup-encryption-key string, -k string  Encryption key for backup files (will prompt if not provided)
   --force, -f                                Force overwrite if recovery path already exists (default: false)
   --help, -h                                 show help
```

### Proceso de recuperación

1. **Detén el nodo de MPCIUM** para asegurarte de que no haya operaciones activas en la base de datos
2. **Ejecuta el comando de recuperación** con los parámetros adecuados
3. **Actualiza la configuración** para que apunte a la base de datos recuperada
4. **Reinicia el nodo** con los datos recuperados

_Image: Recuperación de backup_

**Ejemplo de recuperación**

```bash
# Step 1: Stop the MPCIUM node

# Step 2: Recover the database
mpcium-cli recover \
  --backup-dir backups/ \
  --recovery-path restore_db/node0

# Step 3: Update config.yaml
# Change db_path to: db_path: "restore_db"

# Step 4: Restart the node

mpcium start -n node0
```

## Integración con AWS S3

MPCIUM admite AWS S3 para el almacenamiento de backups en la nube, lo que aporta redundancia adicional y capacidades de recuperación ante desastres.

### Configurar el backup en S3

#### 1. Crea un bucket de S3

**Crear un bucket de S3**

```bash
aws s3 mb s3://node0-backup --region ap-southeast-1
```

> **Info.** **Nota**: reemplaza `ap-southeast-1` por la región que prefieras. Los nombres de los buckets deben ser únicos a nivel global.

#### 2. Configura los permisos de S3

Asegúrate de que tus credenciales de AWS tengan los permisos adecuados para las operaciones de S3:

**Ejemplo de política de S3**

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject",
        "s3:ListBucket",
        "s3:DeleteObject"
      ],
      "Resource": [
        "arn:aws:s3:::node0-backup",
        "arn:aws:s3:::node0-backup/*"
      ]
    }
  ]
}
```

### Operaciones de backup en S3

#### Sube los backups locales a S3

**Subir a S3**

```bash
# Sync local backup folder to S3
aws s3 sync ./backups s3://node0-backup
```

#### Descarga los backups desde S3

**Descargar desde S3**

```bash
# Sync from S3 to local folder
aws s3 sync s3://node0-backup ./backups
```

#### Verifica el backup en S3

**Verificar el contenido de S3**

```bash
# List S3 backup contents
aws s3 ls s3://node0-backup --recursive

# Check backup file details
aws s3api head-object --bucket node0-backup --key backup-node0-2025-07-28_20-46-39-1.enc
```

Former: Product Manager at TomoChain labs

## Backups automatizados

### Configuración de cron jobs

Configura backups automatizados en S3 mediante cron jobs para garantizar una sincronización periódica con el almacenamiento en la nube:

**Configuración de cron jobs**

```bash
# Edit crontab
crontab -e

# Add backup job (runs every hour)
0 * * * * /usr/local/bin/backup-mpcium.sh

# Add daily backup verification
0 2 * * * /usr/local/bin/verify-backup.sh
```

### Ejemplo de script de backup

Crea un script de backup para automatizar el proceso de sincronización con S3:

**Script de backup**

```bash
#!/bin/bash
# /usr/local/bin/backup-mpcium.sh

# Configuration
NODE_NAME="node0"
S3_BUCKET="node0-backup"
BACKUP_DIR="/opt/mpcium/node0/backups"
LOG_FILE="/var/log/mpcium-backup.log"

# Log function
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}

# Start backup
log "Starting MPCIUM backup to S3"

# Sync local backups to S3
if aws s3 sync "$BACKUP_DIR" "s3://$S3_BUCKET" --delete; then
    log "Backup completed successfully"
else
    log "Backup failed"
    exit 1
fi

# Verify backup
if aws s3 ls "s3://$S3_BUCKET" | grep -q "backup-$NODE_NAME"; then
    log "Backup verification successful"
else
    log "Backup verification failed"
    exit 1
fi
```

### Script de verificación

Crea un script para verificar la integridad de los backups:

**Script de verificación**

```bash
#!/bin/bash
# /usr/local/bin/verify-backup.sh

# Configuration
S3_BUCKET="node0-backup"
LOG_FILE="/var/log/mpcium-backup-verify.log"

# Log function
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}

# Check S3 bucket accessibility
if aws s3 ls "s3://$S3_BUCKET" > /dev/null 2>&1; then
    log "S3 bucket accessible"
else
    log "S3 bucket not accessible"
    exit 1
fi

# Count backup files
BACKUP_COUNT=$(aws s3 ls "s3://$S3_BUCKET" --recursive | grep -c "\.enc$")
log "Found $BACKUP_COUNT backup files in S3"

# Check for recent backups (within last 24 hours)
RECENT_BACKUPS=$(aws s3 ls "s3://$S3_BUCKET" --recursive | grep "$(date '+%Y-%m-%d')" | wc -l)
log "Found $RECENT_BACKUPS backups from today"

if [ "$RECENT_BACKUPS" -eq 0 ]; then
    log "WARNING: No recent backups found"
    exit 1
fi
```

### Monitoreo y alertas

Configura el monitoreo de tus procesos de backup:

**Configuración del monitoreo**

```bash
# Check backup script exit status
if [ $? -ne 0 ]; then
    # Send alert (example with curl to webhook)
    curl -X POST -H "Content-Type: application/json" \
         -d '{"text":"MPCIUM backup failed"}' \
         https://your-webhook-url.com/alert
fi
```

> **Success.** **Buena práctica**: prueba periódicamente tus procedimientos de backup y recuperación en un entorno de pruebas para asegurarte de que funcionen correctamente cuando los necesites.