Dev.to Security 🔐 Cybersecurity 👁 0 📖 6 min read

Respaldos de MongoDB en piloto automático: GitHub Actions, cifrado AES-256, regla 3-2-1 y un simulacro de desastre con RTO medido

TL;DR — Los respaldos manuales se olvidan y los que nadie restaura fallan justo el día que se necesitan. En Mongo Backup Guardian, cinco workflows de GitHub Actions se encargan de todo: Terraform crea MongoDB Atlas y Ren

Respaldos de MongoDB en piloto automático: GitHub Actions, cifrado AES-256, regla 3-2-1 y un simulacro de desastre con RTO medido

TL;DR — Los respaldos manuales se olvidan y los que nadie restaura fallan justo el día que se necesitan. En Mongo Backup Guardian, cinco workflows de GitHub Actions se encargan de todo: Terraform crea MongoDB Atlas y Render; cada noche un usuario de solo lectura hace mongodump, el respaldo se restaura en un MongoDB desechable, se compara con SHA-256, se cifra con AES-256 y se guarda en dos lugares fuera de Atlas. Un workflow de recuperación ante desastres comprueba la integridad, descifra, ensaya y restaura producción: en el simulacro, 12 segundos desde el clic hasta los datos verificados.

🔗 Repositorio: https://github.com/keylalopezz/mongo-backup-guardian
🌐 App publicada: https://mongo-backup-guardian.onrender.com
🎥 Video (menos de 5 min): (se agrega en cuanto se publique)
✍️ Artículo complementario (tipos de respaldo: completo, oplog y PITR): https://dev.to/keylalopezz/un-respaldo-que-no-se-restaura-no-es-un-respaldo-estrategia-de-backup-en-mongodb-con-dump-lo1

1. Objetivo: respaldos que nadie tenga que recordar

La app es una biblioteca universitaria sobre MongoDB Atlas M0, el plan gratuito, que no incluye backups administrados. Keyla explica en su artículo los tipos de respaldo y cómo verificarlos. Yo me enfoco en otra pregunta: ¿cómo se vuelve todo eso automático, seguro y repetible?

Mis reglas:

  1. Nada se crea a mano: la infraestructura está en Terraform.
  2. El proceso de respaldo tiene el mínimo privilegio posible.
  3. Cada respaldo se restaura y verifica antes de guardarse.
  4. Ningún dato sale del runner sin cifrar (el repositorio es público).
  5. La recuperación también es un workflow, con su tiempo medido.

2. Arquitectura

                   ┌─ ci-cd.yml   : pruebas con MongoDB 8.0 ─► imagen ghcr.io ─► Render ─► verifica versión
GitHub Actions ────┼─ infra.yml   : Terraform ─► Atlas (proyecto, M0, 2 usuarios, red) + Render
                   ├─ backup.yml  : 03:00 diario ─► mongodump ─► restore de prueba ─► SHA-256 ─► AES-256 ─► 2 copias
                   ├─ restore.yml : manual ─► SHA-256 ─► descifrar ─► ensayo ─► producción (con confirmación)
                   └─ pitr.yml    : semanal ─► replica set ─► completo + oplog ─► recuperación a un instante

Los cinco workflows en verde

3. Terraform: dos usuarios, dos niveles de confianza

Terraform crea el proyecto en Atlas, el clúster M0 y dos usuarios distintos:

# La app: lectura/escritura solo en sus bases.
resource "mongodbatlas_database_user" "app" {
  username = "guardian-app"
  password = var.app_password
  roles {
    role_name     = "readWrite"
    database_name = "biblioteca"
  }
  roles {
    role_name     = "readWrite"
    database_name = "biblioteca_guardian"
  }
  # ...
}

# Los respaldos: SOLO lectura. Si su contraseña se filtra, no puede borrar nada.
resource "mongodbatlas_database_user" "backup" {
  username = "guardian-backup"
  password = var.backup_password
  roles {
    role_name     = "read"
    database_name = "biblioteca"
  }
  scopes {
    name = mongodbatlas_advanced_cluster.guardian.name
    type = "CLUSTER"
  }
}

El respaldo diario corre sin intervención cada noche, así que su credencial es la más expuesta. Por eso solo puede leer. La credencial de escritura la usa únicamente el workflow de restauración, y solo cuando una persona lo lanza.

Las contraseñas no están en el código: llegan como TF_VAR_* desde los secretos de GitHub. El estado de Terraform las contiene, y en un repositorio público los artefactos son descargables, así que el estado también se guarda cifrado con AES-256.

Terraform aplicado: Atlas M0 con MongoDB 8.0.37 y Render

4. El respaldo diario, paso a paso

on:
  schedule:
    - cron: "0 8 * * *"   # 03:00 en Lima (UTC-5)
  workflow_dispatch:

El job levanta un MongoDB 8.0 desechable como service container y ejecuta 7 pasos:

# Paso Detalle
1 Huella de producción SHA-256 por colección con el usuario de solo lectura
2 mongodump --gzip --archive, herramientas desde la imagen mongo:8.0
3 Restauración de prueba mongorestore en el MongoDB desechable
4 Comparación Si una huella difiere, el workflow falla
5 Cifrado gpg --symmetric --cipher-algo AES256 + manifiesto con el SHA-256 del archivo cifrado
6 Copias fuera de Atlas Artefacto de Actions (30 días) + release respaldos (últimos 14)
7 Registro POST /api/respaldos con un token, para que la app muestre el historial

El cifrado y la eliminación del archivo en claro van en el mismo paso, para que el respaldo nunca salga del runner sin cifrar:

gpg --batch --yes --pinentry-mode loopback --passphrase "$BACKUP_PASSPHRASE" \
  --symmetric --cipher-algo AES256 --output "salida/$NOMBRE.archive.gz.gpg" respaldo.archive.gz
rm respaldo.archive.gz
SHA=$(sha256sum "salida/$NOMBRE.archive.gz.gpg" | cut -d' ' -f1)

El manifiesto (.manifest.json) acompaña a cada respaldo y guarda el SHA-256 del archivo cifrado y la huella esperada de cada colección. Con eso, la restauración puede comprobar antes de descifrar que el archivo no se dañó, y después que los datos son los correctos.

Resumen del respaldo: restauración de prueba idéntica a producción

5. La regla 3-2-1, aplicada

Regla Cómo se cumple
3 copias Producción (Atlas) + artefacto de Actions + release respaldos
2 medios / proveedores MongoDB Atlas (AWS us-east-1) y GitHub
1 fuera del sitio Las dos copias de GitHub están fuera del proveedor de la base de datos

Release con los respaldos cifrados y sus manifiestos

El release conserva los 14 respaldos más recientes: el workflow borra los más antiguos con gh release delete-asset. La retención es parte de la estrategia, no un detalle: sin ella, el almacenamiento crece sin límite.

Los puntos de restauración que la app guarda en GridFS no cuentan para la regla 3-2-1: viven en el mismo clúster y desaparecerían con él.

6. Recuperación ante desastres: un workflow, no un documento

Un procedimiento de recuperación escrito en un PDF se desactualiza. Aquí es un workflow manual con tres entradas:

on:
  workflow_dispatch:
    inputs:
      respaldo:     { default: ultimo }
      destino:      { type: choice, options: [ prueba, produccion ], default: prueba }
      confirmacion: { description: 'Escribe RESTAURAR para restaurar en producción' }

Por defecto solo ensaya: restaura en un MongoDB desechable y compara. Para tocar producción hay que elegir produccion y escribir RESTAURAR; si no, el primer paso termina con error.

Los pasos:

  1. Descarga el .gpg y su manifiesto desde el release.
  2. Comprueba el SHA-256 del archivo cifrado (sha256sum -c).
  3. Lo descifra con AES-256.
  4. Ensayo en MongoDB desechable y comparación con las huellas del manifiesto.
  5. Solo entonces, mongorestore --nsInclude "biblioteca.*" --drop en Atlas, y una última comparación de huellas en producción.

El simulacro

Desde la app provoqué un borrado accidental real en producción: deleteMany({}) sobre prestamos, 180 documentos perdidos. Luego lancé restore.yml con destino=produccion:

Restauración en producción: ensayo y producción idénticos, RTO de 12 s

Métrica Valor
Documentos recuperados 180 de 180 (prestamos), 250 en total
mongorestore en Atlas 1586 ms
RTO medido (de inicio a datos verificados) 12 s
RPO con el respaldo diario hasta 24 h (el PITR con oplog lo baja a segundos)

La app registra cada respaldo y restauración, así que el historial queda visible para cualquiera:

Historial de respaldos y restauraciones en la app

7. PITR semanal en CI

El plan M0 no expone el oplog, así que el point-in-time recovery se ensaya cada domingo en un replica set dentro del runner (pitr.yml): respaldo completo con --oplog, escrituras, un deleteMany({}), respaldo del oplog y mongorestore --oplogReplay --oplogLimit hasta el instante anterior al desastre. Resultado: 1250 de 1250 documentos con la misma huella SHA-256. Keyla explica el detalle técnico en su artículo.

Ensayarlo con frecuencia tiene una razón práctica: si una versión nueva de MongoDB cambia el formato del oplog (como el applyOps por lotes de MongoDB 8), me entero en un ensayo, no durante un desastre.

8. Lecciones

  1. Separa las credenciales por riesgo. Lo que corre solo cada noche, solo lee; lo que escribe, lo lanza una persona y pide confirmación.
  2. Repositorio público = artefactos públicos. El respaldo y el estado de Terraform se cifran antes de subirse, y el archivo en claro se borra en el mismo paso.
  3. Verifica integridad dos veces: el SHA-256 del archivo cifrado (¿se dañó en el almacenamiento?) y las huellas de las colecciones (¿son los datos correctos?).
  4. El plan de recuperación debe ser ejecutable. Un workflow con modo ensayo por defecto se puede probar sin miedo, así que se prueba.
  5. Mide RTO y RPO, no los supongas. 12 segundos de RTO y 24 horas de RPO son números concretos que permiten decidir si hace falta PITR.
  6. Contenedores y permisos. El primer intento falló porque mongodump, dentro de mongo:8.0, no podía escribir en el directorio del runner; se resolvió ejecutándolo con --user "$(id -u):$(id -g)".

Autores: Adrian Fabricio Salas Acuña y Keyla Noelia Lopez Ojeda — Base de Datos II, Escuela Profesional de Ingeniería de Sistemas, Universidad Privada de Tacna.

🔗 Repositorio: https://github.com/keylalopezz/mongo-backup-guardian · 🌐 App: https://mongo-backup-guardian.onrender.com

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.