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:
- Nada se crea a mano: la infraestructura está en Terraform.
- El proceso de respaldo tiene el mínimo privilegio posible.
- Cada respaldo se restaura y verifica antes de guardarse.
- Ningún dato sale del runner sin cifrar (el repositorio es público).
- 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 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.
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.
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 |
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:
- Descarga el
.gpgy su manifiesto desde el release. - Comprueba el SHA-256 del archivo cifrado (
sha256sum -c). - Lo descifra con AES-256.
- Ensayo en MongoDB desechable y comparación con las huellas del manifiesto.
- Solo entonces,
mongorestore --nsInclude "biblioteca.*" --dropen 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:
| 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:
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
- Separa las credenciales por riesgo. Lo que corre solo cada noche, solo lee; lo que escribe, lo lanza una persona y pide confirmación.
- 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.
- 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?).
- El plan de recuperación debe ser ejecutable. Un workflow con modo ensayo por defecto se puede probar sin miedo, así que se prueba.
- 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.
- Contenedores y permisos. El primer intento falló porque
mongodump, dentro demongo: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





