<?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: ARTURO SEBASTIAN CUTIPA FLORES</title>
    <description>The latest articles on DEV Community by ARTURO SEBASTIAN CUTIPA FLORES (@arturo_sebastiancutipaf).</description>
    <link>https://dev.to/arturo_sebastiancutipaf</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%2F4160458%2Fa8ee3ef8-b04d-4195-8633-4d483a1b3378.png</url>
      <title>DEV Community: ARTURO SEBASTIAN CUTIPA FLORES</title>
      <link>https://dev.to/arturo_sebastiancutipaf</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/arturo_sebastiancutipaf"/>
    <language>en</language>
    <item>
      <title>Una copia que nadie restauró no es una copia: backups de Firestore verificados con GitHub Actions</title>
      <dc:creator>ARTURO SEBASTIAN CUTIPA FLORES</dc:creator>
      <pubDate>Sat, 14 Nov 2026 22:51:21 +0000</pubDate>
      <link>https://dev.to/arturo_sebastiancutipaf/una-copia-que-nadie-restauro-no-es-una-copia-backups-de-firestore-verificados-con-github-actions-24eg</link>
      <guid>https://dev.to/arturo_sebastiancutipaf/una-copia-que-nadie-restauro-no-es-una-copia-backups-de-firestore-verificados-con-github-actions-24eg</guid>
      <description>&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Arturo Cutipa Flores&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Curso:&lt;/strong&gt; Base de Datos II · Universidad Privada de Tacna&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Actividad:&lt;/strong&gt; Estrategias de copia de seguridad NoSQL, desarrollada junto con Carlos Jimenez Laura  &lt;/p&gt;



&lt;p&gt;Casi todos los fallos de copias de seguridad se descubren el día que hace falta restaurar: el archivo está vacío, la clave se perdió o falta una parte. Así que nos propusimos una regla para este proyecto: ninguna copia se guarda sin haberla restaurado antes, y que lo haga una máquina todos los días, sin tocar producción ni gastar cuota.&lt;/p&gt;

&lt;p&gt;Lo aplicamos en &lt;strong&gt;StockSeguro&lt;/strong&gt;, un inventario sobre Google Cloud Firestore. Esto es lo que construimos.&lt;/p&gt;
&lt;h2&gt;
  
  
  Enlaces del proyecto
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Aplicación:&lt;/strong&gt; &lt;a href="https://stockseguro-firestore.onrender.com" rel="noopener noreferrer"&gt;https://stockseguro-firestore.onrender.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Repositorio público:&lt;/strong&gt; &lt;a href="https://github.com/CRJL19/firestore-backups" rel="noopener noreferrer"&gt;https://github.com/CRJL19/firestore-backups&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Video:&lt;/strong&gt; &lt;a href="https://youtu.be/uTJn93AaZgo" rel="noopener noreferrer"&gt;https://youtu.be/uTJn93AaZgo&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  La aplicación y sus copias
&lt;/h2&gt;

&lt;p&gt;StockSeguro guarda productos con sus movimientos en una subcolección. Está hecha con Node.js y Express, y corre en un contenedor Docker en Render. Firestore es una base NoSQL de documentos, y su exportación administrada exige un plan de pago, así que hacemos una copia lógica con el Admin SDK:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Completa cada 7 días:&lt;/strong&gt; recorre todas las colecciones y subcolecciones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Incremental cada día:&lt;/strong&gt; lee lo cambiado según &lt;code&gt;updatedAt&lt;/code&gt;, más las marcas que la app deja al borrar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Formato:&lt;/strong&gt; registros NDJSON, comprimidos con gzip y cifrados con AES-256-GCM.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Para probarla en tu máquina no necesitas cuenta de Google, porque corre contra el emulador:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm ci
npm run dev
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&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%2Fd1ylxflq5zsdalhsp2oq.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%2Fd1ylxflq5zsdalhsp2oq.png" alt=" " width="644" height="694"&gt;&lt;/a&gt;&lt;/p&gt;

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

&lt;h2&gt;
  
  
  El recorrido de una copia
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Cada día a las 03:00 (Perú)
   │
   ▼
GitHub Actions
   ├─ 1. Descarga las copias anteriores
   ├─ 2. Lee Firestore con una cuenta de solo lectura
   ├─ 3. Comprime y cifra
   ├─ 4. Restaura en un emulador y compara
   └─ 5. Solo si coincide, guarda el artifact
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El orden es lo importante: una copia que no pasa el paso 4 nunca llega al 5, y el workflow falla a la vista.&lt;/p&gt;

&lt;h2&gt;
  
  
  La verificación
&lt;/h2&gt;

&lt;p&gt;El truco es que el emulador oficial de Firestore corre dentro del propio runner. Los pasos 2 y 4 son procesos separados, y el de verificación no recibe credenciales de producción:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Hacer la copia&lt;/span&gt;
  &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;create&lt;/span&gt;
  &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;FIREBASE_SERVICE_ACCOUNT&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ secrets.FIREBASE_BACKUP_SA }}&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;node src/backup/cli.js create --dir backups --type "$BACKUP_TYPE"&lt;/span&gt;

&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Verificar restaurando en el emulador&lt;/span&gt;
  &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;BACKUP_ID&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ steps.create.outputs.id }}&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npx firebase emulators:exec --only firestore --project demo-stockseguro "node src/backup/cli.js verify --dir backups --id $BACKUP_ID"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La verificación borra la base de destino, restaura la cadena completa y compara dos cosas:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Una huella SHA-256 del contenido:&lt;/strong&gt; la de lo restaurado debe coincidir con la de la copia.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los conteos reales del origen:&lt;/strong&gt; cada copia los guarda, y deben coincidir por colección.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Los conteos detectan lo que la huella no puede. Si alguien borra un documento desde la consola, la incremental no se entera, pero los números ya no cuadran y el workflow falla.&lt;/p&gt;

&lt;p&gt;Como esa operación empieza borrando todo, el código se niega a ejecutarla fuera del emulador:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;FIRESTORE_EMULATOR_HOST&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nb"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'La verificación borra la base de destino: solo se ejecuta contra el emulador.'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Dónde viven las copias
&lt;/h2&gt;

&lt;p&gt;Las guardamos como artifacts de GitHub Actions. Las completas duran 90 días y las incrementales 30, porque estas dependen de aquellas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;retention-days&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ steps.create.outputs.type == 'full' &amp;amp;&amp;amp; 90 || 30 }}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Hay un detalle que condicionó el diseño: los artifacts de un repositorio público los puede descargar cualquier persona con cuenta de GitHub. El cifrado no era opcional. Usamos AES-256-GCM, que además autentica el contenido. Enlazamos cada archivo con su manifiesto, de modo que no se puede cambiar el de una copia por el de otra sin que se note, y una prueba lo comprueba.&lt;/p&gt;

&lt;p&gt;El panel de la app lee el historial desde la API de GitHub y no desde Firestore. Si se pierde la base, el historial sigue visible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Permisos separados
&lt;/h2&gt;

&lt;p&gt;Usamos dos cuentas de servicio:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;backup-reader&lt;/code&gt;, con el rol Lector de Cloud Datastore. Hace las copias a diario y no puede escribir.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;stockseguro-app&lt;/code&gt;, con el rol Usuario de Cloud Datastore. La usan la app y la restauración.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Si se filtrara la credencial del workflow diario, serviría para leer, pero no para borrar nada. Además, ninguna vive en el repositorio: están en los secrets de GitHub y en las variables de Render.&lt;/p&gt;

&lt;h2&gt;
  
  
  Restaurar es una operación manual y con red
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;restore.yml&lt;/code&gt; solo se lanza a mano, pidiendo el ID de la copia y escribir RESTAURAR. Antes de tocar nada hace una copia del estado actual, para poder deshacer una restauración equivocada:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Copia del estado actual&lt;/span&gt;
  &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;safety&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;node src/backup/cli.js create --dir backups --type full --label prerestore&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Permite restaurar toda la base o solo una rama, por ejemplo un único producto con sus movimientos. Después de restaurar deja una marca para que la siguiente copia automática sea completa, porque los documentos restaurados conservan su &lt;code&gt;updatedAt&lt;/code&gt; antiguo y una incremental no los vería.&lt;/p&gt;

&lt;p&gt;Backups y restauraciones comparten la misma cola de concurrencia, así que nunca corren a la vez:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;concurrency&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;group&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;backups&lt;/span&gt;
  &lt;span class="na"&gt;cancel-in-progress&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  El despliegue
&lt;/h2&gt;

&lt;p&gt;Cada &lt;code&gt;git push&lt;/code&gt; a &lt;code&gt;main&lt;/code&gt; pasa por &lt;code&gt;ci-cd.yml&lt;/code&gt;: 39 pruebas contra el emulador, construcción de la imagen Docker y una llamada al Deploy Hook de Render, un proveedor público en la nube. En &lt;code&gt;render.yaml&lt;/code&gt; está &lt;code&gt;autoDeploy: false&lt;/code&gt;, así que el único camino a producción pasa por las pruebas.&lt;/p&gt;

&lt;p&gt;En nuestra última ejecución tardó 38 s: 29 s las pruebas, 12 s la imagen y 2 s el despliegue.&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%2F4iz1jhg08jgs5omtsy4q.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%2F4iz1jhg08jgs5omtsy4q.png" alt=" " width="799" height="470"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Figura 2.&lt;/strong&gt; CI/CD en verde en GitHub Actions.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Resultados
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Comprobación&lt;/th&gt;
&lt;th&gt;Dónde&lt;/th&gt;
&lt;th&gt;Resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Copia completa&lt;/td&gt;
&lt;td&gt;Firestore real&lt;/td&gt;
&lt;td&gt;27 documentos en 5,6 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Restauración de esa copia&lt;/td&gt;
&lt;td&gt;Emulador en GitHub Actions&lt;/td&gt;
&lt;td&gt;27 documentos en 1,1 s, sin diferencias&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ejecución completa del workflow&lt;/td&gt;
&lt;td&gt;GitHub Actions&lt;/td&gt;
&lt;td&gt;33 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copias diarias programadas&lt;/td&gt;
&lt;td&gt;GitHub Actions, del 2 al 12 de noviembre&lt;/td&gt;
&lt;td&gt;11 de 11 en verde&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copia completa semanal&lt;/td&gt;
&lt;td&gt;Automática&lt;/td&gt;
&lt;td&gt;Creada sola el 9 de noviembre&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Simulacro: copias, base vaciada y restauración&lt;/td&gt;
&lt;td&gt;Emulador local&lt;/td&gt;
&lt;td&gt;25 documentos en 237 ms, los esperados&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&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%2Ft97lu4vqmvgv03pgfd5k.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%2Ft97lu4vqmvgv03pgfd5k.png" alt=" " width="800" height="286"&gt;&lt;/a&gt;&lt;/p&gt;

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

&lt;p&gt;El simulacro de desastre lo hicimos en el emulador local, con los mismos comandos del workflow. &lt;code&gt;restore.yml&lt;/code&gt; está listo para producción, pero no lo ejecutamos para esta demostración.&lt;/p&gt;

&lt;p&gt;Con estos volúmenes el tiempo de recuperación son segundos, pero no lo extrapolaría. Lo valioso es que cada verificación lo mide, así que veríamos crecer esa cifra junto con los datos.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que aprendimos en el camino
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un paso en rojo puede ser lo esperado.&lt;/strong&gt; La primera ejecución falló en el despliegue porque aún no existía el secret. Pasaron las pruebas y la imagen, y el mensaje decía exactamente qué faltaba.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La inspección visual sigue haciendo falta.&lt;/strong&gt; Las 39 pruebas pasaban, y aun así un navegador en tamaño de celular mostró la página desbordada 184 píeles: un texto oculto para lectores de pantalla se salía de la tabla.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Las dependencias externas fallan.&lt;/strong&gt; Una consulta a la API de GitHub falló una vez, con la causa sin confirmar. El panel mostró «No disponible» en lugar de «sin copias», que habría sido falso, y se recuperó solo.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Limitaciones
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Dos ubicaciones, no tres.&lt;/strong&gt; Hay datos en Firestore y copias en GitHub. La regla 3-2-1 pediría una tercera.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Horario de GitHub.&lt;/strong&gt; Una tarea programada puede retrasarse, y lo comprobamos: programada para las 08:00 UTC, la copia empezó cada día entre 6 y 10 horas tarde. Además, GitHub desactiva las tareas programadas tras 60 días sin actividad en el repositorio. Por eso el panel avisa si la última copia supera las 26 horas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan gratuito.&lt;/strong&gt; Firestore Spark permite 50 000 lecturas y 20 000 escrituras al día. La instancia de Render se duerme tras un rato sin tráfico.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escala.&lt;/strong&gt; Cada copia se procesa en memoria. Para millones de documentos, lo correcto sería la exportación nativa.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Conclusión
&lt;/h2&gt;

&lt;p&gt;Lo que cambió fue dónde ponemos la confianza. Ya no decimos «tenemos copias», sino «cada copia guardada se restauró antes y coincidió». Y gracias al emulador, esa comprobación no cuesta nada.&lt;/p&gt;

&lt;p&gt;Para saber por qué exportar JSON no basta en una base NoSQL, recomiendo el artículo de Carlos.&lt;/p&gt;

</description>
      <category>cloud</category>
      <category>database</category>
      <category>devops</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>De git push a producción: desplegar una app con Firestore usando GitHub Actions, un emulador y Render</title>
      <dc:creator>ARTURO SEBASTIAN CUTIPA FLORES</dc:creator>
      <pubDate>Sat, 14 Nov 2026 22:12:00 +0000</pubDate>
      <link>https://dev.to/arturo_sebastiancutipaf/de-git-push-a-produccion-desplegar-una-app-con-firestore-usando-github-actions-un-emulador-y-370</link>
      <guid>https://dev.to/arturo_sebastiancutipaf/de-git-push-a-produccion-desplegar-una-app-con-firestore-usando-github-actions-un-emulador-y-370</guid>
      <description>&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Arturo Cutipa Flores&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Curso:&lt;/strong&gt; Base de Datos II · Universidad Privada de Tacna&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Actividad:&lt;/strong&gt; Grupal 01-U2, NoSQL App Development, desarrollada junto con Carlos Jimenez Laura  &lt;/p&gt;



&lt;p&gt;Una pregunta incómoda aparece al automatizar una app con base de datos en la nube: ¿cómo la pruebas en CI sin tocar los datos reales ni gastar la cuota? En este artículo cuento cómo resolvimos eso en &lt;strong&gt;VotaYa&lt;/strong&gt;, nuestra app de encuestas en vivo sobre Google Cloud Firestore, para que un simple &lt;code&gt;git push&lt;/code&gt; termine en producción solo si todo funciona.&lt;/p&gt;
&lt;h2&gt;
  
  
  Enlaces del proyecto
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Aplicación:&lt;/strong&gt; &lt;a href="https://votaya-firestore.onrender.com" rel="noopener noreferrer"&gt;https://votaya-firestore.onrender.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Repositorio público:&lt;/strong&gt; &lt;a href="https://github.com/CRJL19/votaya" rel="noopener noreferrer"&gt;https://github.com/CRJL19/votaya&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Video:&lt;/strong&gt; &lt;a href="https://youtu.be/u6Ftpt7l-Mo" rel="noopener noreferrer"&gt;https://youtu.be/u6Ftpt7l-Mo&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  La aplicación
&lt;/h2&gt;

&lt;p&gt;VotaYa permite crear una encuesta, compartir su enlace y ver los votos llegar sin recargar la página. La construimos con Node.js y Express en el servidor, y con HTML, CSS y JavaScript sin frameworks en el navegador.&lt;/p&gt;

&lt;p&gt;La actividad pedía evitar Redis, MongoDB, Neo4j y Prometheus, así que usamos Firestore, una base NoSQL de documentos. Cada encuesta es un documento que guarda sus opciones y contadores, y cada voto es un documento en una subcolección:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;polls/{pollId}                   pregunta, opciones, contadores, estado
polls/{pollId}/votes/{voterId}   opción elegida, fecha
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El servidor se conecta con el Admin SDK de Firebase, y con ese SDK registrar un voto ocupa pocas líneas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;batch&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ref&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;collection&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'votes'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;doc&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;voterId&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;optionId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;votedAt&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;update&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ref&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sb"&gt;`counts.${optionId}`&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;FieldValue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;increment&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;commit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Para probarla en tu máquina no necesitas cuenta de Google, porque corre contra el emulador:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm ci
npm run dev
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  El recorrido
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;git push a main
   │
   ▼
GitHub Actions
   ├─ Pruebas contra el emulador de Firestore
   ├─ Construcción de la imagen Docker
   └─ Si ambas pasan: POST al Deploy Hook de Render
                          │
                          ▼
                 Render publica la nueva versión
                          │
                          ▼
                 Firestore (Google Cloud)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Requisito de la actividad&lt;/th&gt;
&lt;th&gt;Cómo lo cumplimos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Base NoSQL permitida&lt;/td&gt;
&lt;td&gt;Google Cloud Firestore&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Repositorio público&lt;/td&gt;
&lt;td&gt;GitHub&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Implementación automatizada&lt;/td&gt;
&lt;td&gt;GitHub Actions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nube pública o SaaS&lt;/td&gt;
&lt;td&gt;Render y Firebase, ambos en plan gratuito&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Probar sin la nube: el emulador
&lt;/h2&gt;

&lt;p&gt;Firebase ofrece un emulador oficial de Firestore. Es un programa en Java que se ejecuta en local y responde igual que el servicio real, sin credenciales. El proyecto usa un ID que empieza por &lt;code&gt;demo-&lt;/code&gt;, para que el emulador nunca intente conectarse a servicios reales:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="nl"&gt;"test"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"firebase emulators:exec --only firestore --project demo-votaya \"node --test test/api.test.js\""&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;emulators:exec&lt;/code&gt; levanta el emulador, ejecuta las pruebas y lo apaga al terminar.&lt;/p&gt;

&lt;p&gt;Elegimos no simular la base con mocks. Las 15 pruebas llaman a la API real por HTTP, y eso nos dio algo que un mock nunca habría mostrado: la prueba de 10 votos simultáneos reveló que nuestra primera versión tardaba 11,6 segundos. Carlos explica ese problema en su artículo.&lt;/p&gt;

&lt;p&gt;También probamos los casos que solo fallan bajo presión:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;El mismo votante enviando 5 votos en paralelo cuenta solo una vez.&lt;/li&gt;
&lt;li&gt;Tras 10 votos simultáneos, el total coincide con los documentos guardados.&lt;/li&gt;
&lt;li&gt;Los resultados en vivo llegan por Server-Sent Events.&lt;/li&gt;
&lt;li&gt;Al borrar una encuesta también se borran sus votos.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  El pipeline
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;.github/workflows/ci-cd.yml&lt;/code&gt; tiene tres trabajos. Las pruebas necesitan Node y Java:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/setup-node@v5&lt;/span&gt;
  &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;node-version&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;24&lt;/span&gt;
    &lt;span class="na"&gt;cache&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm&lt;/span&gt;

&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/setup-java@v5&lt;/span&gt;
  &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;distribution&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;temurin&lt;/span&gt;
    &lt;span class="na"&gt;java-version&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;21&lt;/span&gt;

&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm ci&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm run check&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El despliegue depende de los otros dos trabajos, y nunca corre desde un pull request:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;deploy&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;needs&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;test&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;docker&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="na"&gt;if&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;github.ref == 'refs/heads/main' &amp;amp;&amp;amp; github.event_name != 'pull_request'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;En nuestra ejecución tardaron 23 s las pruebas, 12 s la imagen Docker y 3 s disparar el despliegue.&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%2Fh3roi638yzy6tvuagcv0.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%2Fh3roi638yzy6tvuagcv0.png" alt=" " width="799" height="405"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Figura 1.&lt;/strong&gt; CI/CD en verde en GitHub Actions.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  La infraestructura también va en el repositorio
&lt;/h2&gt;

&lt;p&gt;El servicio de Render está definido en &lt;code&gt;render.yaml&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;services&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;web&lt;/span&gt;
    &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;votaya-firestore&lt;/span&gt;
    &lt;span class="na"&gt;runtime&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;docker&lt;/span&gt;
    &lt;span class="na"&gt;plan&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;free&lt;/span&gt;
    &lt;span class="na"&gt;autoDeploy&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
    &lt;span class="na"&gt;healthCheckPath&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;/api/health&lt;/span&gt;
    &lt;span class="na"&gt;envVars&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;key&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;NODE_ENV&lt;/span&gt;
        &lt;span class="na"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;production&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;key&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;FIREBASE_SERVICE_ACCOUNT&lt;/span&gt;
        &lt;span class="na"&gt;sync&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Dos líneas importan especialmente:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;autoDeploy: false&lt;/code&gt;: Render no despliega por su cuenta al detectar un cambio. El único camino a producción pasa por las pruebas.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;sync: false&lt;/code&gt;: Render pide la credencial al crear el servicio y su valor nunca queda en el repositorio.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Credenciales: el mínimo permiso
&lt;/h2&gt;

&lt;p&gt;Lo cómodo habría sido usar la cuenta de servicio de administrador que propone Firebase. Al intentar crearla desde la consola nos apareció un aviso de error vacío. La salida fue crear nuestra propia cuenta de servicio en Google Cloud, y resultó ser mejor opción:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Cuenta &lt;code&gt;votaya-app&lt;/code&gt;, con un único rol: Usuario de Cloud Datastore.&lt;/li&gt;
&lt;li&gt;Una clave JSON guardada fuera del proyecto.&lt;/li&gt;
&lt;li&gt;El contenido de esa clave, pegado como variable de entorno en Render.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Si esa clave se filtrara, daría acceso a los datos de Firestore, pero no permitiría administrar el resto del proyecto.&lt;/p&gt;

&lt;p&gt;En &lt;code&gt;.gitignore&lt;/code&gt; y &lt;code&gt;.dockerignore&lt;/code&gt; excluimos además los patrones de nombre de estas claves, para evitar subirlas por accidente. Y GitHub solo guarda un secret, &lt;code&gt;RENDER_DEPLOY_HOOK&lt;/code&gt;, porque el CI no necesita acceso a la base: prueba contra el emulador.&lt;/p&gt;

&lt;h2&gt;
  
  
  Probar lo que se desplegó
&lt;/h2&gt;

&lt;p&gt;Una vez en verde no dimos el despliegue por bueno: probamos la URL pública contra Firestore real.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Comprobación en producción&lt;/th&gt;
&lt;th&gt;Resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Conexión con Firestore (&lt;code&gt;/api/health/ready&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;200, base disponible&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Crear una encuesta&lt;/td&gt;
&lt;td&gt;201&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Votar&lt;/td&gt;
&lt;td&gt;201&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Votar de nuevo con el mismo votante&lt;/td&gt;
&lt;td&gt;409&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10 votos simultáneos&lt;/td&gt;
&lt;td&gt;Los 10 registrados, en cerca de 2 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resultados en vivo&lt;/td&gt;
&lt;td&gt;Recibidos por la conexión SSE&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cerrar sin token&lt;/td&gt;
&lt;td&gt;403&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Votar en una encuesta cerrada&lt;/td&gt;
&lt;td&gt;409&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Eliminar con token&lt;/td&gt;
&lt;td&gt;204&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;También comprobamos en un navegador limpio que un voto externo actualiza la pantalla sin recargar y que la página no se desborda en tamaño de celular.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que aprendimos en el camino
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un paso en rojo puede ser lo esperado.&lt;/strong&gt; La primera ejecución falló en el despliegue porque aún no existía el secret del Deploy Hook. Preferimos que falle a que parezca desplegado sin estarlo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La inspección visual sigue haciendo falta.&lt;/strong&gt; Las pruebas de la API pasaban, pero una captura mostró los botones de administrador a cualquier visitante: &lt;code&gt;display: flex&lt;/code&gt; anulaba el atributo &lt;code&gt;hidden&lt;/code&gt;. El servidor los rechazaba igual, pero no debían verse.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los health checks tienen costo.&lt;/strong&gt; Render consulta el suyo periódicamente. Si leyera Firestore, gastaría la cuota gratuita, así que &lt;code&gt;/api/health&lt;/code&gt; no toca la base.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Limitaciones del plan gratuito
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;La instancia de Render se duerme tras un rato sin tráfico, y la primera visita puede tardar cerca de un minuto.&lt;/li&gt;
&lt;li&gt;Firestore Spark permite 50 000 lecturas y 20 000 escrituras al día, suficiente para una demo pero no para un producto real.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Conclusión
&lt;/h2&gt;

&lt;p&gt;Lo que más valor tuvo fue el emulador: hizo posible un pipeline completo sin credenciales de la base en el CI. Con eso, &lt;code&gt;git push&lt;/code&gt; dejó de ser un riesgo, porque si algo falla no llega a producción.&lt;/p&gt;

&lt;p&gt;Para el detalle del modelo de datos y por qué abandonamos las transacciones, recomiendo el artículo de Carlos.&lt;/p&gt;

</description>
      <category>cicd</category>
      <category>cloud</category>
      <category>git</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Borramos la tabla de producción a propósito: una prueba de desastre real con PostgreSQL, Neon y Render</title>
      <dc:creator>ARTURO SEBASTIAN CUTIPA FLORES</dc:creator>
      <pubDate>Sun, 04 Oct 2026 04:48:02 +0000</pubDate>
      <link>https://dev.to/arturo_sebastiancutipaf/borramos-la-tabla-de-produccion-a-proposito-una-prueba-de-desastre-real-con-postgresql-neon-y-52na</link>
      <guid>https://dev.to/arturo_sebastiancutipaf/borramos-la-tabla-de-produccion-a-proposito-una-prueba-de-desastre-real-con-postgresql-neon-y-52na</guid>
      <description>&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Arturo Cutipa Flores&lt;br&gt;
&lt;strong&gt;Curso:&lt;/strong&gt; Base de Datos II · Universidad Privada de Tacna&lt;br&gt;
&lt;strong&gt;Proyecto grupal:&lt;/strong&gt; DB Backup Strategies, desarrollado junto con Carlos Jimenez Laura&lt;br&gt;
Hablar de backups es fácil; demostrar que funcionan es otra cosa. En nuestro proyecto decidimos no conformarnos con mostrar un archivo de respaldo: eliminamos la tabla principal de la base de datos de producción y medimos cuánto tardábamos en recuperarla. En este artículo cuento cómo planificamos esa prueba, qué salió mal en el primer intento y qué métricas obtuvimos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Enlaces del proyecto&lt;/strong&gt;&lt;br&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/IchI-xmC1Ic" rel="noopener noreferrer"&gt;https://youtu.be/IchI-xmC1Ic&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;El escenario&lt;/strong&gt;&lt;br&gt;
La aplicación es un gestor de tareas (crear, completar, eliminar) con un frontend en HTML y JavaScript que consume una API en Node.js. Los datos se guardan en PostgreSQL 17 en Neon y la aplicación corre en Render. Los backups se generan con pg_dump desde GitHub Actions todos los días a las 02:00 UTC (21:00 en Perú).&lt;br&gt;
Antes de la prueba definimos dos objetivos, como se haría en una empresa:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Métrica&lt;/th&gt;
&lt;th&gt;Significado&lt;/th&gt;
&lt;th&gt;Objetivo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;RPO (&lt;em&gt;Recovery Point Objective&lt;/em&gt;)&lt;/td&gt;
&lt;td&gt;Cuántos datos podemos perder como máximo&lt;/td&gt;
&lt;td&gt;24 h (un backup diario)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RTO (&lt;em&gt;Recovery Time Objective&lt;/em&gt;)&lt;/td&gt;
&lt;td&gt;Cuánto tiempo puede estar caído el servicio&lt;/td&gt;
&lt;td&gt;Menos de 15 minutos&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Empezar en local: un entorno reproducible&lt;/strong&gt;&lt;br&gt;
Antes de tocar producción ensayamos todo en local con Docker Compose, que levanta dos contenedores: PostgreSQL y la aplicación. Con un solo comando:&lt;br&gt;
docker compose up --build&lt;br&gt;
En local practicamos el ciclo completo: generar un backup dentro del contenedor, borrar la tabla, comprobar que la API respondía 503 y restaurar. Allí también probamos los casos negativos, que son los que dan confianza:&lt;br&gt;
• Restaurar un backup cifrado con una clave incorrecta falla y la base queda intacta, porque la restauración corre en una sola transacción.&lt;br&gt;
• Ejecutar restore.sh sin confirmación en un entorno no interactivo se niega a continuar.&lt;br&gt;
• El script verifica el checksum SHA-256 antes de tocar la base.&lt;br&gt;
Un detalle práctico: en mi equipo el puerto 5432 ya estaba ocupado por otro contenedor, así que publicamos la base local en el 5433 y lo dejamos configurable con una variable de entorno.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Restaurar con un clic&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Restaurar a mano exige descargar el artifact, descifrarlo y tener la cadena de conexión y la clave en la computadora. Durante una emergencia esos pasos son lentos y propensos a errores. Por eso creamos un workflow de restauración en GitHub Actions que usa los mismos secrets que el backup. Basta con escribir RESTAURAR como confirmación:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt; Hace un backup de seguridad del estado actual, por si se elige el backup equivocado.&lt;/li&gt;
&lt;li&gt; Descarga el artifact del último backup exitoso.&lt;/li&gt;
&lt;li&gt; Verifica el checksum, descifra y restaura en una sola transacción.&lt;/li&gt;
&lt;li&gt; Reporta las filas antes y después, y el tiempo de recuperación.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Primer intento: un falso positivo&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;En el primer ensayo en producción todo salió en verde... y aun así la prueba no demostraba nada. El resumen del workflow decía "Filas antes: 3", cuando acabábamos de borrar la tabla.&lt;br&gt;
Al investigar en los eventos de Render encontramos la causa. Al borrar la tabla, el health check de la aplicación empezó a responder 503, y Render reinició la instancia. Al arrancar, la aplicación ejecutaba init.sql, que recreaba la tabla e insertaba tres tareas de ejemplo. Como el backup contenía justo esas tres tareas, era imposible distinguir qué había recuperado el backup y qué había regenerado la aplicación.&lt;br&gt;
La corrección fue separar responsabilidades:&lt;br&gt;
• init.sql solo crea la estructura, sin datos. Si la tabla se pierde, la aplicación la recrea vacía.&lt;br&gt;
• Los datos de ejemplo pasaron a seed.sql, que solo se usa en el entorno local con Docker.&lt;br&gt;
Además, para la prueba definitiva creamos datos de control propios: "Tarea de Carlos" y "Tarea de Arturo".&lt;br&gt;
Esta fue para mí la lección más valiosa del proyecto: una prueba de recuperación debe diseñarse para poder fallar. Si el resultado sale bien pase lo que pase, la prueba no sirve.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;La prueba definitiva&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Estado inicial. La aplicación en producción con 5 tareas, incluidas las dos de control.&lt;br&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%2F3xqrg4rn3ldzxkz2orj0.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%2F3xqrg4rn3ldzxkz2orj0.png" alt=" " width="776" height="379"&gt;&lt;/a&gt;&lt;br&gt;
Figura 1. App con 5 tareas.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Backup. Ejecutamos el workflow de backup a mano: 44 segundos, archivo cifrado de 4 KB y verificación automática con 5 filas.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Desastre. En el SQL Editor de Neon ejecutamos: DROP TABLE tasks;&lt;br&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%2Fw259pe4sfiggm4l9mv23.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%2Fw259pe4sfiggm4l9mv23.png" alt=" " width="799" height="390"&gt;&lt;/a&gt;&lt;br&gt;
Figura 2. DROP TABLE en Neon.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Caída. La aplicación dejó de responder y Render mostró un 502 Bad Gateway.&lt;br&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%2Fjb66uhhqyil9z38eslj5.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%2Fjb66uhhqyil9z38eslj5.png" alt=" " width="799" height="391"&gt;&lt;/a&gt;&lt;br&gt;
Figura 3. App caída.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Pérdida de datos confirmada. Tras el reinicio automático, la aplicación volvió a funcionar pero con 0 tareas. Esta vez el desastre era visible.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&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%2Fhbghulana8px9ydz4fhu.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%2Fhbghulana8px9ydz4fhu.png" alt=" " width="799" height="390"&gt;&lt;/a&gt;&lt;br&gt;
Figura 4. App vacía.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Restauración. Lanzamos el workflow de restauración. En 24 segundos la tabla pasó de 0 a 5 filas.&lt;br&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%2Fcun5l8bwwglu5hw3z3fa.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%2Fcun5l8bwwglu5hw3z3fa.png" alt=" " width="800" height="389"&gt;&lt;/a&gt;&lt;br&gt;
Figura 5. Restauración.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Recuperación. Recargamos la aplicación: las 5 tareas volvieron, con sus identificadores originales (la "Tarea de Carlos" seguía siendo la #4 y la "Tarea de Arturo" la #5).&lt;br&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%2Fz0mrda7v4xmr3etpc3j4.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%2Fz0mrda7v4xmr3etpc3j4.png" alt=" " width="800" height="391"&gt;&lt;/a&gt;&lt;br&gt;
Figura 6. App recuperada.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Resultados&lt;/strong&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Métrica&lt;/th&gt;
&lt;th&gt;Objetivo&lt;/th&gt;
&lt;th&gt;Resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Datos perdidos (RPO)&lt;/td&gt;
&lt;td&gt;≤ 24 h&lt;/td&gt;
&lt;td&gt;0 registros&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo de restauración&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;24 s (18 s de recuperación efectiva)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo total de recuperación (RTO)&lt;/td&gt;
&lt;td&gt;&amp;lt; 15 min&lt;/td&gt;
&lt;td&gt;≈ 3 min&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El RPO fue cero porque no hubo escrituras entre el backup y el desastre. En un caso real perderíamos lo escrito desde el último backup diario: hasta 24 horas de datos. Para reducirlo bastaría con ejecutar el backup con más frecuencia o aprovechar la recuperación a un punto en el tiempo (PITR) que ofrece Neon.&lt;br&gt;
El tiempo total incluye detectar la caída y esperar que Render reinicie la instancia; la restauración en sí fue cuestión de segundos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Conclusiones&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;• Medir convierte un backup en una estrategia. Sin RPO y RTO definidos de antemano no hay forma de saber si la recuperación fue "suficientemente rápida".&lt;br&gt;
• Los datos de control hacen la prueba honesta. Registros identificables como "Tarea de Arturo" permiten afirmar con certeza que los datos vinieron del backup.&lt;br&gt;
• La restauración también se automatiza. En una emergencia nadie quiere copiar cadenas de conexión a mano; un workflow con confirmación reduce el error humano.&lt;br&gt;
• Respaldar antes de restaurar. Restaurar el backup equivocado es otro desastre; el backup de seguridad previo lo evita.&lt;/p&gt;

&lt;p&gt;Como mejora futura propondría repetir esta prueba de desastre de forma periódica (por ejemplo, una vez al mes) y registrar el RTO en cada ejecución para detectar si el tiempo de recuperación empeora a medida que crece la base.&lt;br&gt;
El código, los workflows y todas las capturas están en el repositorio. El desarrollo fue grupal; este artículo presenta mi análisis individual de la prueba de recuperación.&lt;/p&gt;

</description>
      <category>backend</category>
      <category>database</category>
      <category>github</category>
      <category>postgres</category>
    </item>
  </channel>
</rss>
