<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Carlos Raí Jimenez Laura</title>
    <description>The latest articles on DEV Community by Carlos Raí Jimenez Laura (@crjl11).</description>
    <link>https://dev.to/crjl11</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4160649%2Fcb9a0767-c54a-4250-abbf-cf42dd7868d6.jpeg</url>
      <title>DEV Community: Carlos Raí Jimenez Laura</title>
      <link>https://dev.to/crjl11</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/crjl11"/>
    <language>en</language>
    <item>
      <title>Copiar una base NoSQL no es exportar JSON: lo que aprendimos haciendo backups de Firestore</title>
      <dc:creator>Carlos Raí Jimenez Laura</dc:creator>
      <pubDate>Fri, 13 Nov 2026 05:30:35 +0000</pubDate>
      <link>https://dev.to/crjl11/copiar-una-base-nosql-no-es-exportar-json-lo-que-aprendimos-haciendo-backups-de-firestore-n5p</link>
      <guid>https://dev.to/crjl11/copiar-una-base-nosql-no-es-exportar-json-lo-que-aprendimos-haciendo-backups-de-firestore-n5p</guid>
      <description>&lt;p&gt;Autor: Carlos Jimenez Laura&lt;br&gt;
Curso: Base de Datos II · Universidad Privada de Tacna&lt;br&gt;
Actividad: Estrategias de copia de seguridad NoSQL, desarrollada junto con Arturo Cutipa Flores&lt;br&gt;
En PostgreSQL ejecutas pg_dump y obtienes un archivo que recrea la base. En Firestore, con el plan gratuito, no existe un equivalente: la exportación administrada exige un plan de pago y un bucket de Cloud Storage. La idea obvia es leer todos los documentos y guardarlos como JSON, y esa copia parece correcta hasta que intentas restaurarla.&lt;br&gt;
En este artículo cuento qué se pierde con esa idea y cómo lo resolvimos en StockSeguro, un inventario con copias automáticas, cifradas y comprobadas.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Enlaces del proyecto&lt;/strong&gt;&lt;br&gt;
• Aplicación: &lt;a href="https://stockseguro-firestore.onrender.com" rel="noopener noreferrer"&gt;https://stockseguro-firestore.onrender.com&lt;/a&gt;&lt;br&gt;
• Repositorio público: &lt;a href="https://github.com/CRJL19/firestore-backups" rel="noopener noreferrer"&gt;https://github.com/CRJL19/firestore-backups&lt;/a&gt;&lt;br&gt;
• Video: &lt;a href="https://youtu.be/56mY6DRLr8U" rel="noopener noreferrer"&gt;https://youtu.be/56mY6DRLr8U&lt;/a&gt; &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxye6c6momze8xlk219x5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxye6c6momze8xlk219x5.png" alt=" " width="581" height="625"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 1. StockSeguro con el panel de copias de seguridad.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Las opciones que teníamos&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F16d3mqv7rb8toddmalsp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F16d3mqv7rb8toddmalsp.png" alt=" " width="607" height="189"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Elegimos la copia lógica porque era lo posible con nuestro presupuesto, no porque sea la mejor en general. Para una base grande en producción, recomendaría la nativa.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cuatro formas de perder datos sin enterarte&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. JSON no conoce los tipos de Firestore&lt;/strong&gt;&lt;br&gt;
Un documento nuestro tiene un Timestamp, un GeoPoint y una referencia a su proveedor. JSON.stringify los convierte en objetos corrientes, y al restaurar ya no son esos tipos. La referencia deja de ser una referencia y ninguna consulta por fecha vuelve a funcionar.&lt;/p&gt;

&lt;p&gt;Por eso cada tipo especial se guarda con una etiqueta:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5be5v5dzjqi3anruznbf.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5be5v5dzjqi3anruznbf.png" alt=" " width="585" height="52"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Y hay una decisión deliberada al final de esa función: un tipo desconocido lanza un error. Prefiero que falle la copia a que parezca correcta y le falten datos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Las subcolecciones no vienen con su padre&lt;/strong&gt;&lt;br&gt;
Leer products no trae products/{id}/movements. Hay que recorrerlas. Y hay un caso peor: una subcolección puede colgar de un documento que ya no existe. Firestore lo llama documento fantasma, y un collection.get() no lo devuelve, así que sus hijos quedarían fuera.&lt;br&gt;
listDocuments() sí los incluye:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb3wkes3imwiuqoxqtull.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb3wkes3imwiuqoxqtull.png" alt=" " width="583" height="79"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Una de nuestras pruebas crea justo ese caso, borra todo, restaura y comprueba que el hijo volvió.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Una copia que tarda no es una foto&lt;/strong&gt;&lt;br&gt;
Si la app sigue escribiendo mientras copias, puedes guardar un producto de hace un minuto con los movimientos de ahora. Resolvimos esto leyendo los documentos dentro de una transacción de solo lectura, de modo que todo corresponde a un mismo instante:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgif5r6utexl09l5b4p58.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgif5r6utexl09l5b4p58.png" alt=" " width="587" height="63"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Un borrado no deja rastro&lt;/strong&gt;&lt;br&gt;
La copia incremental lee lo que cambió según updatedAt, pero un documento borrado ya no tiene ese campo: simplemente deja de existir, y la consulta no puede verlo. Sin más, al restaurar reaparecerían productos eliminados.&lt;br&gt;
Por eso la app deja una marca en la misma operación que borra:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2hbd8e6vz9s3a1fx7kr8.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2hbd8e6vz9s3a1fx7kr8.png" alt=" " width="587" height="97"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;La estrategia completa&lt;/strong&gt;&lt;br&gt;
• Copia completa cada 7 días, que corrige cualquier desviación acumulada.&lt;br&gt;
• Copia incremental diaria, que gasta menos cuota porque lee menos documentos.&lt;br&gt;
• Restauración selectiva: --only products/abc123 recupera un producto y sus movimientos sin tocar el resto.&lt;br&gt;
• Cifrado AES-256-GCM, necesario porque los artifacts de un repositorio público se pueden descargar con cualquier cuenta de GitHub.&lt;br&gt;
• Objetivo de pérdida (RPO): 24 horas. El panel de la app avisa si la última copia supera las 26.&lt;br&gt;
Restaurar una incremental significa aplicar la cadena en orden: la completa y luego cada incremental. Dentro de cada copia, los borrados se aplican antes que los documentos, porque un documento presente en una copia existía al hacerla, aunque se hubiera borrado y creado de nuevo.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;El problema que no se resuelve del todo&lt;/strong&gt;&lt;br&gt;
La copia incremental depende de un contrato: todo se escribe a través de la app, con updatedAt y sus marcas de borrado. Alguien que borre un documento desde la consola de Firebase lo rompe, y la incremental no se entera.&lt;br&gt;
No pudimos evitarlo, pero sí detectarlo. Cada copia guarda los conteos reales del origen con consultas de agregación, que son baratas. Si al restaurar los números no coinciden, la verificación falla:&lt;br&gt;
products: la copia dice 1 y la restauración tiene 2&lt;br&gt;
Una prueba automática reproduce ese caso. La solución entonces es una copia completa. Queda un hueco que prefiero admitir: una modificación externa que no cambie los conteos solo se recoge en la siguiente completa.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cómo se publica y se automatiza&lt;/strong&gt;&lt;br&gt;
El código está en un repositorio público de GitHub, y todo se ejecuta con GitHub Actions:&lt;br&gt;
• Cada git push ejecuta las 39 pruebas contra el emulador de Firestore, construye la imagen Docker y despliega en Render, un proveedor público en la nube.&lt;br&gt;
• Cada día, a las 03:00 hora de Perú, un workflow hace la copia, la restaura en un emulador y solo si coincide la guarda.&lt;br&gt;
Las copias se hacen con una cuenta de servicio de solo lectura, y la base está en Firestore, sobre Google Cloud.&lt;/p&gt;

&lt;p&gt;Resultados&lt;br&gt;
En producción, con Firestore real, la primera copia completa dio esto:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3ed9dk8alryjofm67i9f.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3ed9dk8alryjofm67i9f.png" alt=" " width="605" height="207"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpz4nbcn5qjspswegfdrb.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpz4nbcn5qjspswegfdrb.png" alt=" " width="800" height="286"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 2. Resumen de la copia verificada en GitHub Actions.&lt;/p&gt;

&lt;p&gt;Después dejamos el workflow funcionando solo. Del 2 al 12 de noviembre se ejecutó todos los días y guardó 12 copias, todas verificadas antes de guardarse: 2 completas, la segunda creada automáticamente al cumplirse los 7 días, y 10 incrementales. Cada incremental cifrada pesa unos 650 bytes, frente a 1,8 KB de una completa.&lt;br&gt;
El simulacro de desastre lo hicimos en el emulador local, con los mismos comandos que usa GitHub Actions: una copia completa, un cambio de stock y un borrado, una incremental, la base vaciada y la restauración de la cadena. Volvieron los 25 documentos esperados en 237 ms, con el stock actualizado y sin el producto eliminado. En producción, la restauración existe como un workflow manual, pero no la ejecutamos para esta demostración.&lt;br&gt;
Un dato que me sorprendió: esa incremental, hecha segundos después de la completa, copió 26 registros frente a 27. No es un error. Cada incremental relee los últimos 5 minutos por seguridad, porque copiar de más es inofensivo y copiar de menos no lo es. El ahorro aparece cuando las copias están separadas por horas.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Limitaciones&lt;/strong&gt;&lt;br&gt;
• Dos ubicaciones, no tres. Hay datos en Firestore y copias en GitHub. La regla 3-2-1 pediría una tercera.&lt;br&gt;
• Enteros y decimales. El SDK de JavaScript no distingue 1 de 1.0. Tampoco se conservan createTime ni updateTime, que asigna el servidor.&lt;br&gt;
• Memoria. Cada copia se procesa completa en memoria, adecuado para miles de documentos, no para millones.&lt;br&gt;
• La clave de cifrado. Si se pierde, las copias no sirven de nada, así que hay que guardarla también fuera de GitHub.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Qué me llevo&lt;/strong&gt;&lt;br&gt;
En una base relacional el esquema y la herramienta de volcado resuelven casi todo por ti. En NoSQL, el esquema vive en la aplicación, y por eso la estrategia de copia también: tuvimos que cambiar cómo borra la app para poder copiar bien.&lt;br&gt;
Lo otro que me llevo es desconfiar de una copia hasta verla restaurada. Mi compañero Arturo cuenta en su artículo cómo automatizamos esa comprobación.&lt;/p&gt;

</description>
      <category>backend</category>
      <category>cloud</category>
      <category>database</category>
      <category>firebase</category>
    </item>
    <item>
      <title>Modelar para NoSQL: cómo construimos encuestas en vivo con Firestore y por qué una transacción nos estorbaba</title>
      <dc:creator>Carlos Raí Jimenez Laura</dc:creator>
      <pubDate>Fri, 13 Nov 2026 04:41:58 +0000</pubDate>
      <link>https://dev.to/crjl11/modelar-para-nosql-como-construimos-encuestas-en-vivo-con-firestore-y-por-que-una-transaccion-nos-5gef</link>
      <guid>https://dev.to/crjl11/modelar-para-nosql-como-construimos-encuestas-en-vivo-con-firestore-y-por-que-una-transaccion-nos-5gef</guid>
      <description>&lt;p&gt;Autor: Carlos Jimenez Laura&lt;br&gt;
Curso: Base de Datos II · Universidad Privada de Tacna&lt;br&gt;
Actividad: Grupal 01-U2, NoSQL App Development, desarrollada junto con Arturo Cutipa Flores&lt;/p&gt;

&lt;p&gt;Veníamos de trabajar con bases relacionales, y nuestro primer instinto fue pensar en tablas: una de encuestas, otra de opciones, otra de votos y un GROUP BY para los resultados. En Firestore ese diseño funciona mal. En este artículo cuento cómo construimos VotaYa, una app de encuestas con resultados en vivo, y qué decisiones cambian cuando la base de datos es NoSQL.&lt;/p&gt;

&lt;p&gt;La actividad pedía evitar Redis, MongoDB, Neo4j y Prometheus, así que elegimos Google Cloud Firestore, una base de documentos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Enlaces del proyecto&lt;/strong&gt;&lt;br&gt;
• Aplicación: &lt;a href="https://votaya-firestore.onrender.com" rel="noopener noreferrer"&gt;https://votaya-firestore.onrender.com&lt;/a&gt;&lt;br&gt;
• Repositorio público: &lt;a href="https://github.com/CRJL19/votaya" rel="noopener noreferrer"&gt;https://github.com/CRJL19/votaya&lt;/a&gt;&lt;br&gt;
• Video: &lt;a href="https://youtu.be/isFjASR8LGw" rel="noopener noreferrer"&gt;https://youtu.be/isFjASR8LGw&lt;/a&gt; &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw8zom9a9kkenj3rv5lrr.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw8zom9a9kkenj3rv5lrr.png" alt=" " width="800" height="511"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 1. Pantalla de inicio de VotaYa.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué Firestore&lt;/strong&gt;&lt;br&gt;
Comparamos tres opciones que cumplían la restricción:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgkgr36x98emltu8v0d4i.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgkgr36x98emltu8v0d4i.png" alt=" " width="605" height="190"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;El emulador pesó mucho: nos permitió probar contra el motor real de Firestore sin tocar la nube ni gastar cuota.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;En NoSQL se modela a partir de las consultas&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;La pantalla más visitada muestra una encuesta con sus resultados. Con un diseño relacional, cada carga contaría votos. En Firestore pagas por documento leído, así que contar 1 000 votos costaría 1 000 lecturas.&lt;br&gt;
Por eso guardamos los contadores dentro de la propia encuesta:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fimfforjncakyib9m052b.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fimfforjncakyib9m052b.png" alt=" " width="577" height="186"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Mostrar los resultados cuesta ahora una sola lectura, sin importar cuántos votos existan. Es desnormalizar a propósito: el dato se duplica y el trabajo se paga al escribir. En una aplicación donde se lee mucho más de lo que se vota, el cambio sale a cuenta.&lt;br&gt;
Los votos van en una subcolección, y el identificador del votante es el identificador del documento. Así la unicidad la garantiza la propia clave, sin consultar antes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;La transacción que nos estorbaba&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Mi primera versión del voto usaba una transacción, lo que parecía la opción correcta: leer la encuesta, leer si el votante ya existe, escribir ambas cosas.&lt;br&gt;
Las pruebas pasaban, pero una llamaba la atención: 10 votos simultáneos tardaban 11,6 segundos en el emulador. Sin esa prueba de concurrencia no lo habríamos visto. La transacción leía el documento de la encuesta, de modo que los votos competían por él y se reintentaban una y otra vez.&lt;/p&gt;

&lt;p&gt;Lo que resolvió el problema fue preguntarnos si de verdad necesitábamos leer dentro de la operación. No hacía falta:&lt;br&gt;
• FieldValue.increment() suma sin conocer el valor anterior.&lt;br&gt;
• create() falla por sí solo si el documento del votante ya existe.&lt;br&gt;
Eso permite usar un batch atómico, sin lecturas y por tanto sin bloqueos:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftaqnpd7tc0ca8cqoq3va.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftaqnpd7tc0ca8cqoq3va.png" alt=" " width="582" height="153"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Las dos escrituras ocurren juntas o no ocurren. Si alguien vota dos veces, create() falla, se cancela todo el batch y el contador no se infla, aunque las peticiones lleguen a la vez.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fnr19guvyo3id2n5gdynp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fnr19guvyo3id2n5gdynp.png" alt=" " width="610" height="127"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;La cifra de producción incluye la red y el servidor, así que no es comparable con las otras dos. Lo importante es que los 10 votos se registraron y el total coincidió.&lt;br&gt;
Hay una concesión: el estado de la encuesta se comprueba antes del batch, por lo que un voto que coincida justo con el cierre aún puede contar. En una encuesta es aceptable. En un sistema de pagos no lo sería.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Resultados en vivo sin gastar la cuota&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Firestore puede avisar de cada cambio en un documento mediante listeners, y eso hace que los resultados se actualicen solos. El navegador no se conecta a Firestore directamente: el servidor escucha y reenvía por Server-Sent Events.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fad37zajyknambfuc1nui.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fad37zajyknambfuc1nui.png" alt=" " width="800" height="511"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 2. Encuesta con resultados en vivo.&lt;/p&gt;

&lt;p&gt;Una primera idea era un listener por cada navegador, pero Firestore cobra cada documento entregado a cada listener. Con 50 personas mirando, cada voto costaría 50 lecturas. Por eso el servidor mantiene un solo listener por encuesta y lo reparte a todos los conectados; una prueba automática lo verifica.&lt;br&gt;
El mismo razonamiento se aplicó al health check. Render lo consulta periódicamente y, si cada consulta leyera Firestore, gastaría cuota solo en comprobaciones. Separamos /api/health, que no toca la base, de /api/health/ready, que sí la comprueba.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Seguridad&lt;/strong&gt;&lt;br&gt;
• El navegador nunca habla con Firestore, y firestore.rules deniega cualquier acceso directo.&lt;br&gt;
• Cerrar o borrar una encuesta exige un token que se entrega solo a quien la crea. En la base se guarda únicamente su hash.&lt;br&gt;
• Hay límite de peticiones por IP y cabeceras de seguridad con Helmet.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Despliegue automático en la nube&lt;/strong&gt;&lt;br&gt;
La aplicación está publicada en Render, un proveedor público, con su base en Firestore, en Google Cloud. No la desplegamos a mano: cada git push a main ejecuta un workflow de GitHub Actions con tres pasos:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt; Pruebas de integración contra el emulador oficial de Firestore.&lt;/li&gt;
&lt;li&gt; Construcción de la imagen Docker.&lt;/li&gt;
&lt;li&gt; Si ambos pasan, una llamada al Deploy Hook de Render, que publica la nueva versión.
El despliegue automático propio de Render está desactivado (autoDeploy: false en render.yaml), de modo que el único camino a producción pasa por las pruebas. La credencial de Firestore se configura como variable de entorno en Render y nunca entra al repositorio.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Limitaciones&lt;/strong&gt;&lt;br&gt;
Prefiero dejarlas claras:&lt;br&gt;
• Un voto por navegador, no por persona. Quien borre sus datos locales puede votar de nuevo. Evitarlo exigiría iniciar sesión.&lt;br&gt;
• Escrituras por documento. Google recomienda no sostener más de una por segundo sobre un mismo documento, y aquí todos los votos actualizan el mismo. Una encuesta masiva necesitaría repartir los contadores en varios documentos.&lt;br&gt;
• Borrar no es en cascada. Eliminar un documento no borra sus subcolecciones, así que usamos recursiveDelete.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Qué me llevo&lt;/strong&gt;&lt;br&gt;
Lo que más me sirvió fue dejar de preguntar "¿cómo guardo esto?" y empezar por "¿cómo se va a leer?". Y la transacción lenta me enseñó otra cosa: el diseño más seguro en apariencia no siempre es el correcto, y una prueba de concurrencia lo detecta antes que un usuario.&lt;br&gt;
Mi compañero Arturo cuenta en su artículo la otra mitad del proyecto: cómo lo probamos y lo desplegamos de forma automática.&lt;/p&gt;

</description>
      <category>backend</category>
      <category>cloud</category>
      <category>database</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Backups de PostgreSQL que se prueban solos: pg_dump, cifrado y verificación automática con GitHub Actions</title>
      <dc:creator>Carlos Raí Jimenez Laura</dc:creator>
      <pubDate>Sun, 04 Oct 2026 02:59:50 +0000</pubDate>
      <link>https://dev.to/crjl11/backups-de-postgresql-que-se-prueban-solos-pgdump-cifrado-y-verificacion-automatica-con-github-4a84</link>
      <guid>https://dev.to/crjl11/backups-de-postgresql-que-se-prueban-solos-pgdump-cifrado-y-verificacion-automatica-con-github-4a84</guid>
      <description>&lt;p&gt;Autor: Carlos Jimenez Laura&lt;/p&gt;

&lt;p&gt;Curso: Base de Datos II · Universidad Privada de Tacna&lt;br&gt;
Proyecto grupal: DB Backup Strategies, desarrollado junto con Arturo Cutipa Flores&lt;/p&gt;

&lt;p&gt;En este proyecto partimos de una pregunta sencilla: ¿cómo sabemos que un backup sirve antes de necesitarlo? Muchas estrategias terminan en un archivo .sql guardado en alguna parte, y nadie comprueba que se pueda restaurar hasta el día del desastre. En este artículo explico cómo construimos un pipeline de respaldos para PostgreSQL que genera la copia, la cifra y la restaura automáticamente en una base temporal cada vez que se ejecuta. Me centro en las decisiones técnicas del backend, el CI/CD y la automatización, que fueron mi parte del trabajo.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Enlaces del proyecto&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;• Repositorio: &lt;a href="https://github.com/ArturoCutipaFlores/db-backup-strategies" rel="noopener noreferrer"&gt;https://github.com/ArturoCutipaFlores/db-backup-strategies&lt;/a&gt;&lt;br&gt;
• Aplicación en producción: &lt;a href="https://db-backup-strategies.onrender.com" rel="noopener noreferrer"&gt;https://db-backup-strategies.onrender.com&lt;/a&gt;&lt;br&gt;
• Video de demostración: &lt;a href="https://youtu.be/QhqYIKFYg6k" rel="noopener noreferrer"&gt;https://youtu.be/QhqYIKFYg6k&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjp29kwxf63voedq1iy10.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjp29kwxf63voedq1iy10.png" alt=" " width="635" height="260"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;La restricción del curso era no usar MS SQL Server. Más que una limitación, resultó una ventaja: las herramientas de backup de PostgreSQL vienen en el paquete postgresql-client de cualquier distribución Linux. Eso significa que el runner de GitHub Actions puede respaldar la base sin servidores propios ni licencias.&lt;br&gt;
La aplicación es un CRUD de tareas, deliberadamente simple. El protagonista no es la app sino lo que pasa con sus datos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tres workflows, tres responsabilidades&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Separé la automatización en tres archivos para que cada uno tenga un solo propósito:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt; deploy.yml: en cada push a main levanta un PostgreSQL efímero como service container, arranca la API y ejecuta pruebas de humo del CRUD con curl y jq (crear, listar, actualizar, validar errores 400 y 404, eliminar). También construye la imagen Docker. Solo si todo pasa, hace un POST al Deploy Hook de Render.&lt;/li&gt;
&lt;li&gt; backup.yml: se ejecuta todos los días a las 02:00 UTC (cron: '0 2 * * *') y también a mano.&lt;/li&gt;
&lt;li&gt; restore.yml: restaura la base de producción desde un backup, con confirmación explícita.
En Render desactivé el Auto-Deploy. Así el único camino a producción pasa por los tests: si una prueba falla, el hook nunca se dispara.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Anatomía de backup.sh&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;El script es el corazón del proyecto. Lo escribí en bash con set -Eeuo pipefail para que cualquier error detenga la ejecución. Sus pasos son:&lt;/p&gt;

&lt;p&gt;pg_dump --dbname="$DATABASE_URL" \&lt;br&gt;
  --format=plain --clean --if-exists \&lt;br&gt;
  --no-owner --no-privileges \&lt;br&gt;
  | gzip -9 &amp;gt; "$TMP_FILE"&lt;/p&gt;

&lt;p&gt;• --format=plain: SQL legible y portable, restaurable en cualquier servidor PostgreSQL.&lt;br&gt;
• --clean --if-exists: el backup incluye DROP ... IF EXISTS, así que restaurar reemplaza los objetos dañados en lugar de chocar con ellos.&lt;br&gt;
• --no-owner --no-privileges: Neon usa sus propios roles; sin estas opciones la restauración en otro servidor fallaría por permisos.&lt;br&gt;
• pipefail: si pg_dump falla a mitad de camino, el error no queda oculto detrás de un gzip exitoso.&lt;/p&gt;

&lt;p&gt;Después del volcado vienen las validaciones:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt; gzip -t comprueba que el archivo comprimido no esté corrupto.&lt;/li&gt;
&lt;li&gt; Se busca la marca PostgreSQL database dump complete, que pg_dump escribe solo si terminó el volcado. Si falta, el backup se descarta.&lt;/li&gt;
&lt;li&gt; Si existe el secret BACKUP_ENCRYPTION_KEY, el archivo se cifra con GPG AES-256. La clave se pasa por un descriptor de archivo, nunca como argumento, para que no aparezca en la lista de procesos.&lt;/li&gt;
&lt;li&gt; Se genera un checksum SHA-256 que restore.sh verifica antes de restaurar.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Un trap sobre EXIT borra los archivos parciales si algo falla. Así nunca queda en disco un backup incompleto que parezca válido.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;El detalle que más me enseñó: la versión de pg_dump&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;La primera versión del workflow instalaba postgresql-client desde los repositorios de Ubuntu, que traen la versión 16. Neon usa PostgreSQL 17, y pg_dump se niega a respaldar un servidor más nuevo que él mismo. La solución fue instalar el cliente desde el repositorio oficial PGDG:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;name: Instalar postgresql-client 17
run: |
sudo apt-get install -y -qq postgresql-common gnupg
sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
sudo apt-get install -y -qq postgresql-client-17&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Mientras trabajábamos, GitHub anunció que ubuntu-latest pasará a Ubuntu 26. Como el repositorio PGDG podría no soportarlo de inmediato, fijé los runners en ubuntu-24.04. Un backup diario que se rompe en silencio por una actualización del runner es exactamente el tipo de fallo que queríamos evitar.&lt;br&gt;
Otro detalle de Neon: para pg_dump hay que usar la conexión directa, no la que pasa por el pooler (PgBouncer en modo transacción). La app en Render sí usa la conexión con pooling.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verificación: restaurar cada backup automáticamente&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Este es el paso del que estoy más orgulloso. El job de backup declara un PostgreSQL 17 temporal como service container:&lt;/p&gt;

&lt;p&gt;services:&lt;br&gt;
  verify-db:&lt;br&gt;
    image: postgres:17-alpine&lt;br&gt;
    env:&lt;br&gt;
      POSTGRES_PASSWORD: postgres&lt;br&gt;
      POSTGRES_DB: restore_check&lt;/p&gt;

&lt;p&gt;Después de generar el backup, el workflow lo restaura en esa base efímera con el mismo restore.sh que usaríamos en un desastre real, y cuenta las filas de la tabla tasks. Si el archivo está corrupto, si la clave de cifrado es incorrecta o si el SQL no es válido, el workflow falla ese mismo día, no el día que necesitemos el backup.&lt;/p&gt;

&lt;p&gt;El resultado se publica en el Job Summary:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5boaqrap8rbws1gjtwu4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5boaqrap8rbws1gjtwu4.png" alt=" " width="800" height="391"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 1. Backup verificado con 5 filas.&lt;/p&gt;

&lt;p&gt;En la ejecución de la demostración el backup tardó 44 segundos, pesó 4 KB cifrado y la verificación recuperó 5 filas. Finalmente se sube como artifact backup-AAAAMMDD con retención de 7 días.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Seguridad: por qué el cifrado no era opcional&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Nuestro repositorio es público, y en un repositorio público cualquier usuario autenticado de GitHub puede descargar los artifacts. Sin cifrado, un volcado de producción quedaría al alcance de cualquiera. Por eso el workflow avisa con un warning si BACKUP_ENCRYPTION_KEY no está configurado.&lt;br&gt;
Las credenciales viven solo en GitHub Secrets (DATABASE_URL, RENDER_DEPLOY_HOOK, BACKUP_ENCRYPTION_KEY), y los scripts imprimen únicamente el host de la base, nunca el usuario ni la contraseña.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Probarlo en producción&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;La prueba final la hicimos sobre la base real. Tras ejecutar DROP TABLE tasks; en Neon, la aplicación quedó vacía. El workflow de restauración la recuperó en 24 segundos, pasando de 0 a 5 filas:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6e3ljqglrgz4pf4z49q8.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6e3ljqglrgz4pf4z49q8.png" alt=" " width="800" height="391"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figura 2. Restauración de 0 a 5 filas.&lt;/p&gt;

&lt;p&gt;Mi compañero Arturo detalla esta prueba de desastre en su artículo.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Qué aprendí&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;• Un backup sin restauración probada es solo un archivo. Integrar la verificación al mismo workflow fue la decisión de mayor impacto.&lt;br&gt;
• La automatización también necesita mantenimiento: versiones del cliente, imágenes de los runners, saltos de línea CRLF en Windows. Añadí un .gitattributes que fuerza LF en los .sh porque Git en Windows los convertía y bash fallaba en Linux.&lt;br&gt;
• Separar despliegue y respaldo. deploy.yml actualiza el servicio y backup.yml protege los datos. Son problemas distintos y merecen workflows distintos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Qué mejoraría&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Con más tiempo agregaría archivado continuo de WAL para bajar el RPO de 24 horas a segundos, una copia externa en almacenamiento S3 (el workflow ya tiene el paso preparado, solo faltan las credenciales) y alertas cuando un backup programado falle.&lt;br&gt;
El código, los workflows y las evidencias están en el repositorio enlazado al inicio. El desarrollo fue grupal; este artículo recoge mi análisis individual del proyecto.&lt;/p&gt;

</description>
      <category>automation</category>
      <category>cicd</category>
      <category>database</category>
      <category>postgres</category>
    </item>
  </channel>
</rss>
