<?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: Rodriguez Patrick</title>
    <description>The latest articles on DEV Community by Rodriguez Patrick (@dejameingresar).</description>
    <link>https://dev.to/dejameingresar</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%2F4160479%2Ff9daea6f-ff33-446e-9e40-4ce41fe8e1ea.jpg</url>
      <title>DEV Community: Rodriguez Patrick</title>
      <link>https://dev.to/dejameingresar</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/dejameingresar"/>
    <language>en</language>
    <item>
      <title>Estrategia de respaldo para Apache Cassandra</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Mon, 16 Nov 2026 20:54:15 +0000</pubDate>
      <link>https://dev.to/dejameingresar/estrategia-de-respaldo-para-apache-cassandra-2mfc</link>
      <guid>https://dev.to/dejameingresar/estrategia-de-respaldo-para-apache-cassandra-2mfc</guid>
      <description>&lt;h1&gt;
  
  
  Estrategia de respaldo para Apache Cassandra
&lt;/h1&gt;

&lt;p&gt;&lt;strong&gt;Curso:&lt;/strong&gt; SI783 – Base de Datos II · &lt;strong&gt;Actividad Grupal 02-U2&lt;/strong&gt;&lt;br&gt;
&lt;strong&gt;Autores:&lt;/strong&gt; Rodriguez Cardenas, Patrick Elvis · Rios Cohaila, Nicole Luciana&lt;br&gt;
&lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/dejameingresar/inventario-cassandra" rel="noopener noreferrer"&gt;https://github.com/dejameingresar/inventario-cassandra&lt;/a&gt;&lt;/p&gt;


&lt;h2&gt;
  
  
  El problema
&lt;/h2&gt;

&lt;p&gt;En una base distribuida el respaldo no es "copiar el archivo". Cassandra reparte los datos en varios nodos según la partition key, replica cada fila en N nodos y escribe en memoria primero (memtable) para luego volcar a disco (SSTable). Un respaldo coherente tiene que considerar las tres cosas: qué nodo tiene qué token, qué réplicas están vivas y qué parte de los datos todavía no bajó a disco.&lt;/p&gt;
&lt;h2&gt;
  
  
  Niveles de respaldo
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. Snapshot por nodo (&lt;code&gt;nodetool snapshot&lt;/code&gt;).&lt;/strong&gt; Crea un hard link de las SSTables actuales en &lt;code&gt;sstables/&amp;lt;keyspace&amp;gt;/&amp;lt;tabla&amp;gt;-&amp;lt;uuid&amp;gt;/snapshots/&amp;lt;nombre&amp;gt;&lt;/code&gt;. Es instantáneo y no duplica el espacio hasta que las SSTables cambian. Se complementa con &lt;code&gt;nodetool flush&lt;/code&gt; previo para vaciar la memtable y con &lt;code&gt;nodetool clearsnapshot&lt;/code&gt; para no acumular.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;nodetool flush inventario
nodetool snapshot -t backup_2026_11_16 inventario
&lt;span class="c"&gt;# copiar snapshots fuera del nodo&lt;/span&gt;
tar czf inventario_2026_11_16.tar.gz \
  /var/lib/cassandra/data/inventario/*/snapshots/backup_2026_11_16
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;2. Respaldo gestionado.&lt;/strong&gt; En Astra DB el proveedor administra snapshots y retención; el equipo define la ventana y la política. Es la opción razonable cuando no se quiere mantener infraestructura de respaldo propia, a cambio de depender del proveedor.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Export lógico.&lt;/strong&gt; &lt;code&gt;cqlsh COPY ... TO&lt;/code&gt; o &lt;code&gt;dsbulk unload&lt;/code&gt; generan CSV de una tabla. Sirve para migraciones y para respaldos pequeños, pero no escala: recorre todas las filas y compite con el tráfico de producción.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué hace un respaldo realmente útil
&lt;/h2&gt;

&lt;p&gt;Un respaldo que nunca se restauró no es un respaldo. La estrategia se define por dos números: &lt;strong&gt;RPO&lt;/strong&gt; (cuántos datos puedo perder) y &lt;strong&gt;RTO&lt;/strong&gt; (cuánto puedo tardar en volver). Para un inventario que se actualiza durante el día, un RPO de 24 h con snapshots diarios es insuficiente; se necesitan incrementales más frecuentes o replicación a otra región.&lt;/p&gt;

&lt;p&gt;Puntos que se pasan por alto:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Topología en la restauración.&lt;/strong&gt; Restaurar en un clúster con distinto número de nodos exige rebalancear tokens; no basta con copiar directorios.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Esquema incluido.&lt;/strong&gt; El respaldo debe incluir &lt;code&gt;DESCRIBE KEYSPACE&lt;/code&gt; o el &lt;code&gt;.cql&lt;/code&gt; del esquema: los datos sin esquema no se pueden releer.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Consistencia de la copia entre nodos.&lt;/strong&gt; Si se respalda nodo por nodo sin coordinar, dos copias del mismo día pueden representar estados distintos. Lo correcto es snapshot en ventana común o usar el mecanismo del proveedor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cifrado y retención.&lt;/strong&gt; El respaldo contiene los mismos datos sensibles que producción; se cifra en reposo y se define cuánto tiempo se conserva.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Procedimiento propuesto
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Frecuencia&lt;/th&gt;
&lt;th&gt;Acción&lt;/th&gt;
&lt;th&gt;Retención&lt;/th&gt;
&lt;th&gt;RPO&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Diario 02:00&lt;/td&gt;
&lt;td&gt;Snapshot + copia a almacenamiento de objetos&lt;/td&gt;
&lt;td&gt;14 días&lt;/td&gt;
&lt;td&gt;24 h&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cada 6 h&lt;/td&gt;
&lt;td&gt;Snapshot incremental a otra región&lt;/td&gt;
&lt;td&gt;7 días&lt;/td&gt;
&lt;td&gt;6 h&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Semanal&lt;/td&gt;
&lt;td&gt;Prueba de restauración en clúster aislado&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mensual&lt;/td&gt;
&lt;td&gt;Export lógico del esquema y tablas críticas&lt;/td&gt;
&lt;td&gt;12 meses&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La prueba de restauración semanal es la parte que casi nadie hace y la que decide si el plan sirve. Se restaura en un clúster aislado, se valida el conteo de filas por partición y se documenta el tiempo real que tomó.&lt;/p&gt;

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



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;-- tras restaurar, comparar cardinalidad por partición con producción
SELECT categoria, count(*) FROM inventario.productos_por_categoria GROUP BY categoria;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Si los conteos no cuadran, el respaldo no sirve, independientemente de que el archivo exista y pese lo esperado.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué se aprendió
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;El respaldo en Cassandra se piensa por nodo y por token, no por base de datos.&lt;/li&gt;
&lt;li&gt;Un snapshot sin &lt;code&gt;flush&lt;/code&gt; previo deja fuera lo que está en memoria.&lt;/li&gt;
&lt;li&gt;RPO y RTO definen la estrategia; sin esos números, cualquier política es arbitraria.&lt;/li&gt;
&lt;li&gt;La única prueba válida de un respaldo es restaurarlo y comparar datos.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cassandra</category>
      <category>backup</category>
      <category>nosql</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Construir y desplegar una aplicación con Apache Cassandra</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Mon, 16 Nov 2026 20:53:31 +0000</pubDate>
      <link>https://dev.to/dejameingresar/construir-y-desplegar-una-aplicacion-con-apache-cassandra-3p03</link>
      <guid>https://dev.to/dejameingresar/construir-y-desplegar-una-aplicacion-con-apache-cassandra-3p03</guid>
      <description>&lt;h1&gt;
  
  
  Construir y desplegar una aplicación con Apache Cassandra
&lt;/h1&gt;

&lt;p&gt;&lt;strong&gt;Curso:&lt;/strong&gt; SI783 – Base de Datos II · &lt;strong&gt;Actividad Grupal 01-U2&lt;/strong&gt;&lt;br&gt;
&lt;strong&gt;Autores:&lt;/strong&gt; Rodriguez Cardenas, Patrick Elvis · Rios Cohaila, Nicole Luciana&lt;br&gt;
&lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/dejameingresar/inventario-cassandra" rel="noopener noreferrer"&gt;https://github.com/dejameingresar/inventario-cassandra&lt;/a&gt;&lt;/p&gt;


&lt;h2&gt;
  
  
  Por qué Cassandra
&lt;/h2&gt;

&lt;p&gt;Cuando se elige una base NoSQL la pregunta correcta no es "cuál es más moderna" sino "qué patrón de acceso voy a tener". Cassandra es una base columnar distribuida, pensada para escrituras intensivas, alta disponibilidad y crecimiento horizontal por nodos. No tiene un nodo maestro: cada nodo puede atender lecturas y escrituras, y la replicación se define por keyspace.&lt;/p&gt;

&lt;p&gt;Eso la diferencia de las otras familias: un documento (MongoDB) brilla cuando el objeto se lee completo y su forma cambia; un grafo (Neo4j) cuando lo importante son las relaciones; una clave-valor (Redis) cuando se necesita latencia mínima sobre datos efímeros. Cassandra gana cuando el volumen manda y la consulta siempre entra por una clave conocida.&lt;/p&gt;
&lt;h2&gt;
  
  
  Modelado: la consulta primero
&lt;/h2&gt;

&lt;p&gt;En Cassandra la tabla se diseña a partir de la consulta, no del diagrama entidad-relación. La aplicación necesita listar productos por categoría, así que la tabla queda así:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;CREATE TABLE inventario.productos_por_categoria (
  categoria text,
  id uuid,
  nombre text,
  precio decimal,
  stock int,
  actualizado timestamp,
  PRIMARY KEY ((categoria), id)
);
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;categoria&lt;/code&gt; es la &lt;strong&gt;partition key&lt;/strong&gt;: todos los productos de una categoría viven en la misma partición, y la lectura &lt;code&gt;WHERE categoria = ?&lt;/code&gt; se resuelve en un solo nodo sin &lt;code&gt;ALLOW FILTERING&lt;/code&gt;. &lt;code&gt;id&lt;/code&gt; como clustering key ordena dentro de la partición y garantiza unicidad del producto.&lt;/p&gt;

&lt;p&gt;Este es el punto donde más se falla al venir de SQL: si se modela pensando en &lt;code&gt;JOIN&lt;/code&gt; y en normalización, en Cassandra se termina con consultas que exigen &lt;code&gt;ALLOW FILTERING&lt;/code&gt; y degradan el clúster. La regla práctica es una tabla por consulta.&lt;/p&gt;

&lt;h2&gt;
  
  
  La API
&lt;/h2&gt;

&lt;p&gt;Node.js 20 con Express y el driver oficial &lt;code&gt;cassandra-driver&lt;/code&gt;. La conexión se abstrae para soportar dos entornos sin cambiar el código: Cassandra local en Docker y Astra DB en producción.&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;function&lt;/span&gt; &lt;span class="nf"&gt;buildClient&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="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;secureBundle&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;ASTRA_BUNDLE_PATH&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;secureBundle&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;cassandra&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="n"&gt;cloud&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;secureConnectBundle&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;secureBundle&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="n"&gt;credentials&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;username&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;ASTRA_CLIENT_ID&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                     &lt;span class="n"&gt;password&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;ASTRA_CLIENT_SECRET&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="n"&gt;keyspace&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;ASTRA_KEYSPACE&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="p"&gt;}&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;cassandra&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;contactPoints&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;CASSANDRA_CONTACT_POINTS&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="s2"&gt;"127.0.0.1"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&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;localDataCenter&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&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;CASSANDRA_DC&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="s2"&gt;"datacenter1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;keyspace&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"inventario"&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="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Las consultas van con &lt;code&gt;prepare: true&lt;/code&gt;. Eso es importante en Cassandra: las sentencias preparadas evitan el parseo repetido en el coordinador y evitan inyección, porque los valores viajan como parámetros binarios y no como texto CQL.&lt;/p&gt;

&lt;p&gt;El upsert es natural en este motor: &lt;code&gt;INSERT&lt;/code&gt; sobre una clave existente actualiza los campos enviados. No hay &lt;code&gt;MERGE&lt;/code&gt; ni verificación previa de existencia.&lt;/p&gt;

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

&lt;p&gt;Tres flujos de GitHub Actions cubren el ciclo completo:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;ci.yml&lt;/strong&gt; — levanta un contenedor &lt;code&gt;cassandra:5&lt;/code&gt; real, espera a que acepte CQL, aplica &lt;code&gt;schema.cql&lt;/code&gt; y &lt;code&gt;seed.cql&lt;/code&gt;, arranca la API y verifica &lt;code&gt;/health&lt;/code&gt; y &lt;code&gt;/productos/laptops&lt;/code&gt;. La prueba no usa mocks: si el esquema está mal, el pipeline falla.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;build-image.yml&lt;/strong&gt; — construye la imagen y la publica en &lt;code&gt;ghcr.io&lt;/code&gt; con dos etiquetas: &lt;code&gt;latest&lt;/code&gt; y el SHA del commit, para poder volver a una versión exacta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;deploy.yml&lt;/strong&gt; — al terminar la construcción, dispara el despliegue en el proveedor mediante un webhook guardado como secreto (&lt;code&gt;RENDER_DEPLOY_HOOK&lt;/code&gt;).&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Con eso, el camino desde &lt;code&gt;git push&lt;/code&gt; hasta una versión nueva en producción no requiere intervención manual ni comandos en un servidor.&lt;/p&gt;

&lt;h2&gt;
  
  
  Despliegue en la nube
&lt;/h2&gt;

&lt;p&gt;La base de datos va en &lt;strong&gt;Astra DB&lt;/strong&gt;, la oferta gestionada de Cassandra: se crea un keyspace serverless, se descarga el &lt;em&gt;Secure Connect Bundle&lt;/em&gt; y se genera un token con permisos solo sobre ese keyspace. La API se despliega como contenedor en un servicio PaaS y recibe el bundle y las credenciales por variables de entorno, nunca en el repositorio.&lt;/p&gt;

&lt;p&gt;Detalle que suele olvidarse: el &lt;em&gt;Secure Connect Bundle&lt;/em&gt; es un archivo, no una cadena de conexión. En un PaaS hay que montarlo como secreto o descargarlo al arrancar; no sirve pegarlo en una variable de entorno de texto.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué se aprendió
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;El esquema en Cassandra se deriva de la consulta; modelar "en tercera forma normal" lleva directo a &lt;code&gt;ALLOW FILTERING&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;La partition key decide el rendimiento y también los límites: una partición demasiado grande degrada el nodo que la aloja.&lt;/li&gt;
&lt;li&gt;Las sentencias preparadas son obligatorias en la práctica, no un adorno.&lt;/li&gt;
&lt;li&gt;Un pipeline que levanta la base real cuesta minutos y evita el clásico "en mi máquina funciona".&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cassandra</category>
      <category>nosql</category>
      <category>spanish</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Escaneo de vulnerabilidades con Nuclei sobre una app desplegada en Vercel</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Fri, 13 Nov 2026 08:13:30 +0000</pubDate>
      <link>https://dev.to/dejameingresar/escaneo-de-vulnerabilidades-con-nuclei-sobre-una-app-desplegada-en-vercel-4j4</link>
      <guid>https://dev.to/dejameingresar/escaneo-de-vulnerabilidades-con-nuclei-sobre-una-app-desplegada-en-vercel-4j4</guid>
      <description>&lt;h1&gt;
  
  
  Escaneo de vulnerabilidades con Nuclei sobre una app desplegada en Vercel
&lt;/h1&gt;

&lt;p&gt;En los laboratorios del curso trabajamos con gosec (análisis estático en Go) y OWASP Dependency-Check (auditoría de dependencias). Este artículo muestra otra categoría: escaneo dinámico de la aplicación desplegada con Nuclei, de ProjectDiscovery, una herramienta distinta a las de los labs.&lt;/p&gt;

&lt;p&gt;Repositorio: &lt;a href="https://github.com/dejameingresar/api-testing-app" rel="noopener noreferrer"&gt;https://github.com/dejameingresar/api-testing-app&lt;/a&gt;&lt;br&gt;
App escaneada: &lt;a href="https://api-testing-app-nine.vercel.app" rel="noopener noreferrer"&gt;https://api-testing-app-nine.vercel.app&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Por qué Nuclei
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;gosec analiza código fuente; Dependency-Check analiza librerías. Ninguno prueba la app corriendo.&lt;/li&gt;
&lt;li&gt;Nuclei ataca la URL pública con miles de plantillas (templates) comunitarias: misconfigurations, exposures, XSS, SQLi, CVEs conocidos.&lt;/li&gt;
&lt;li&gt;Referencia: OWASP reconoce el escaneo DAST como complemento del SAST (ver OWASP Vulnerability Scanning Tools).&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  2. Instalación y ejecución
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;nuclei -u https://api-testing-app-nine.vercel.app \
  -severity low,medium,high,critical \
  -tags misconfig,exposure -o nuclei-report.txt
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El primer run descarga ~2900 plantillas firmadas de &lt;code&gt;nuclei-templates&lt;/code&gt; (v10.5.2) y las ejecuta contra el objetivo.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Resultado real
&lt;/h2&gt;

&lt;p&gt;Escaneo con 1524 plantillas (tags misconfig + exposure): &lt;strong&gt;0 hallazgos&lt;/strong&gt;. La app expone solo los endpoints previstos, sin paneles, ni archivos sensibles, ni cabeceras que delaten versiones vulnerables.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Lectura del resultado
&lt;/h2&gt;

&lt;p&gt;Cero hallazgos no significa "invulnerable": significa que esa superficie y esas plantillas no detectaron nada. El valor está en repetirlo en cada deploy (Nuclei corre en CI igual que Newman) y ampliar tags (xss, sqli, cve) a medida que la app crezca.&lt;/p&gt;

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

&lt;p&gt;SAST (gosec) + SCA (Dependency-Check) + DAST (Nuclei) cubren tres ángulos distintos. El escaneo dinámico es el único que valida lo que realmente está expuesto en producción.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Efecto colateral real: el escaneo activo el bot-protection de Vercel
&lt;/h2&gt;

&lt;p&gt;Tras lanzar ~1500 plantillas contra la app, Vercel activo temporalmente su Security Checkpoint ("We're verifying your browser") para todo el host, incluidos curl y Newman. El bloqueo expiro solo al cesar el trafico y se verifico con Newman (4 requests, 5 assertions, 0 fallos). Leccion: los escaneos DAST agresivos pueden degradar el servicio; en produccion se programan en ventanas de mantenimiento.&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>testing</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>API Testing con k6 y Newman sobre una API desplegada en Vercel</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Fri, 13 Nov 2026 08:13:16 +0000</pubDate>
      <link>https://dev.to/dejameingresar/api-testing-con-k6-y-newman-sobre-una-api-desplegada-en-vercel-19o2</link>
      <guid>https://dev.to/dejameingresar/api-testing-con-k6-y-newman-sobre-una-api-desplegada-en-vercel-19o2</guid>
      <description>&lt;h1&gt;
  
  
  API Testing con k6 y Newman sobre una API desplegada en Vercel
&lt;/h1&gt;

&lt;p&gt;Probar una API no es solo "pegarle con curl una vez". En este artículo muestro un flujo completo y reproducible: una API Node/Express mínima, despliegue automático a Vercel desde GitHub, pruebas funcionales con Newman (Postman CLI) y pruebas de carga con k6, todo corriendo en CI con GitHub Actions.&lt;/p&gt;

&lt;p&gt;Repositorio: &lt;a href="https://github.com/dejameingresar/api-testing-app" rel="noopener noreferrer"&gt;https://github.com/dejameingresar/api-testing-app&lt;/a&gt;&lt;br&gt;
API en producción: &lt;a href="https://api-testing-app-nine.vercel.app" rel="noopener noreferrer"&gt;https://api-testing-app-nine.vercel.app&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  1. La aplicación
&lt;/h2&gt;

&lt;p&gt;API REST mínima con Express:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;GET /health&lt;/code&gt; → &lt;code&gt;{ "status": "ok" }&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;GET /api/items&lt;/code&gt; → lista&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;GET /api/items/:id&lt;/code&gt; → un item (404 si no existe)&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;POST /api/items&lt;/code&gt; → crea (400 si falta &lt;code&gt;name&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;DELETE /api/items/:id&lt;/code&gt; → elimina (404 si no existe)&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  2. Despliegue a través de automatización
&lt;/h2&gt;

&lt;p&gt;El repo está conectado a Vercel (integración GitHub). Cada &lt;code&gt;push&lt;/code&gt; a &lt;code&gt;main&lt;/code&gt; dispara un deploy automático a producción, sin pasos manuales. Además, un workflow de GitHub Actions (&lt;code&gt;.github/workflows/ci.yml&lt;/code&gt;) levanta la API y corre la colección Newman en cada push y pull request.&lt;/p&gt;
&lt;h2&gt;
  
  
  3. Pruebas funcionales con Newman
&lt;/h2&gt;

&lt;p&gt;La colección &lt;code&gt;tests/newman/collection.json&lt;/code&gt; cubre 4 casos: health check, listado, creación (201) y el caso negativo de item inexistente (404). Ejecución contra producción:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx newman run tests/newman/collection.json \
  --env-var &lt;span class="nv"&gt;baseUrl&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;https://api-testing-app-nine.vercel.app
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Resultado real: 4 requests, 5 assertions, 0 fallos. Tiempo medio de respuesta ~374 ms.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Pruebas de carga con k6
&lt;/h2&gt;

&lt;p&gt;El script &lt;code&gt;tests/k6/load.js&lt;/code&gt; usa stages (rampa a 10 usuarios virtuales, 1 minuto sostenido) con umbrales: menos de 1% de fallos y p95 bajo 500 ms.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;k6 run --env &lt;span class="nv"&gt;BASE_URL&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;https://api-testing-app-nine.vercel.app tests/k6/load.js
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;k6 separa dos niveles que Newman no cubre: comportamiento bajo concurrencia y degradación de latencia (p95), no solo respuestas correctas.&lt;/p&gt;

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

&lt;p&gt;Newman verifica que la API responde lo correcto; k6 verifica que lo hace bajo carga. Combinados con deploy automático y CI, cada cambio queda probado funcional y no-funcionalmente antes de llegar a producción.&lt;/p&gt;

</description>
      <category>testing</category>
      <category>api</category>
      <category>devops</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Detectar vulnerabilidades en Go con gosec</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Sun, 04 Oct 2026 01:44:36 +0000</pubDate>
      <link>https://dev.to/dejameingresar/detectar-vulnerabilidades-en-go-con-gosec-2h46</link>
      <guid>https://dev.to/dejameingresar/detectar-vulnerabilidades-en-go-con-gosec-2h46</guid>
      <description>&lt;p&gt;En los laboratorios analizamos el código de una aplicación con SonarCloud,&lt;br&gt;
Snyk y Semgrep. En este ejercicio el punto de mira es el mismo código fuente,&lt;br&gt;
pero con una herramienta que no usamos en los labs: &lt;strong&gt;gosec&lt;/strong&gt;, el analizador&lt;br&gt;
estático estándar del ecosistema de Go, que publica reglas mapeadas a CWE de&lt;br&gt;
la OWASP.&lt;/p&gt;

&lt;p&gt;Para demostrar que la herramienta funciona de verdad, la aplicamos a una&lt;br&gt;
aplicación escrita a propósito con los fallos más comunes. El resultado son&lt;br&gt;
&lt;strong&gt;17 hallazgos&lt;/strong&gt;, cinco de ellos de severidad alta.&lt;/p&gt;


&lt;h2&gt;
  
  
  La idea detrás de gosec
&lt;/h2&gt;

&lt;p&gt;gosec analiza el código buscando patrones que se sabe que son peligrosos:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;credenciales o claves privadas escritas en el fuente&lt;/li&gt;
&lt;li&gt;comandos del sistema construidos con variables&lt;/li&gt;
&lt;li&gt;rutas de archivo tomadas de entrada externa&lt;/li&gt;
&lt;li&gt;algoritmos de hash débiles&lt;/li&gt;
&lt;li&gt;consultas SQL por concatenación de cadenas&lt;/li&gt;
&lt;li&gt;redirecciones y plantillas construidas con datos del usuario&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Cada regla tiene un identificador (&lt;code&gt;G###&lt;/code&gt;), una severidad y un CWE asociado,&lt;br&gt;
así que el resultado se puede mapear a lo que exige la norma y no quedarse en&lt;br&gt;
un "algo está mal aquí".&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-sSfL&lt;/span&gt; https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh
gosec &lt;span class="nt"&gt;-no-fail&lt;/span&gt; &lt;span class="nt"&gt;-fmt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;json &lt;span class="nt"&gt;-out&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;informe.json ./...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Un detalle que puede arruinar el resultado: gosec necesita el compilador de Go&lt;br&gt;
instalado. Sin él termina sin errores y reporta &lt;code&gt;Files: 0&lt;/code&gt;, lo que parece un&lt;br&gt;
escaneo limpio cuando en realidad no analysó nada.&lt;/p&gt;
&lt;h2&gt;
  
  
  La aplicación de prueba
&lt;/h2&gt;

&lt;p&gt;Es un servidor web pequeño, en un solo archivo, con seis rutas. Cada una contiene&lt;br&gt;
un fallo deliberado:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Ruta&lt;/th&gt;
&lt;th&gt;Fallo introducido&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/saludo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;plantilla HTML sin escapar y redirección con datos del usuario&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/descarga&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;escritura en ruta construida sin restringir&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/archivo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;lectura de archivo con ruta de la petición&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/token&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;secreto concatenado sin validar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/tipo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;comando del sistema con valor del usuario&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/hash&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;MD5 y SHA1 para derivar contraseñas&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;No está publicada en ningún servicio y no debe usarse con datos reales. Es un&lt;br&gt;
caso de estudio, no una aplicación de producción.&lt;/p&gt;
&lt;h2&gt;
  
  
  Los 17 hallazgos
&lt;/h2&gt;

&lt;p&gt;Resultado real de &lt;code&gt;gosec -no-fail -fmt=json&lt;/code&gt;:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Severidad&lt;/th&gt;
&lt;th&gt;Regla&lt;/th&gt;
&lt;th&gt;Línea&lt;/th&gt;
&lt;th&gt;Hallazgo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;HIGH&lt;/td&gt;
&lt;td&gt;G101&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;td&gt;Credencial escrita en el código&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HIGH&lt;/td&gt;
&lt;td&gt;G101&lt;/td&gt;
&lt;td&gt;33-35&lt;/td&gt;
&lt;td&gt;Clave privada RSA embebida&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HIGH&lt;/td&gt;
&lt;td&gt;G702&lt;/td&gt;
&lt;td&gt;39&lt;/td&gt;
&lt;td&gt;Inyección de comandos por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HIGH&lt;/td&gt;
&lt;td&gt;G703&lt;/td&gt;
&lt;td&gt;45&lt;/td&gt;
&lt;td&gt;Recorrido de rutas por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HIGH&lt;/td&gt;
&lt;td&gt;G703&lt;/td&gt;
&lt;td&gt;51&lt;/td&gt;
&lt;td&gt;Recorrido de rutas por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G112&lt;/td&gt;
&lt;td&gt;138-143&lt;/td&gt;
&lt;td&gt;Slowloris: falta &lt;code&gt;ReadHeaderTimeout&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G202&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;td&gt;Concatenación de cadenas en SQL&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G204&lt;/td&gt;
&lt;td&gt;39&lt;/td&gt;
&lt;td&gt;Subproceso lanzado con variable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G304&lt;/td&gt;
&lt;td&gt;45&lt;/td&gt;
&lt;td&gt;Inclusión de archivo vía variable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G401&lt;/td&gt;
&lt;td&gt;70-71&lt;/td&gt;
&lt;td&gt;Primitiva criptográfica débil&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G401&lt;/td&gt;
&lt;td&gt;70&lt;/td&gt;
&lt;td&gt;Primitiva criptográfica débil&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G501&lt;/td&gt;
&lt;td&gt;14&lt;/td&gt;
&lt;td&gt;Import bloqueado &lt;code&gt;crypto/md5&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G505&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;Import bloqueado &lt;code&gt;crypto/sha1&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G705&lt;/td&gt;
&lt;td&gt;117&lt;/td&gt;
&lt;td&gt;XSS por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G705&lt;/td&gt;
&lt;td&gt;122&lt;/td&gt;
&lt;td&gt;XSS por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MEDIUM&lt;/td&gt;
&lt;td&gt;G710&lt;/td&gt;
&lt;td&gt;77&lt;/td&gt;
&lt;td&gt;Redirección abierta por análisis de taint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;LOW&lt;/td&gt;
&lt;td&gt;G104&lt;/td&gt;
&lt;td&gt;117&lt;/td&gt;
&lt;td&gt;Errores sin manejar&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Resumen:&lt;/strong&gt; 5 HIGH, 11 MEDIUM, 1 LOW. 17 en total.&lt;/p&gt;
&lt;h2&gt;
  
  
  Lo que las reglas de taint aportan
&lt;/h2&gt;

&lt;p&gt;Cuatro de los hallazgos (G702, G703, G705, G710) no vienen de buscar una palabra&lt;br&gt;
clave: gosec sigue el valor desde que entra en la función hasta donde se usa.&lt;/p&gt;

&lt;p&gt;En &lt;code&gt;/tipo&lt;/code&gt;, el valor de &lt;code&gt;mime&lt;/code&gt; llega de &lt;code&gt;r.URL.Query().Get("mime")&lt;/code&gt; y acaba como&lt;br&gt;
argumento de &lt;code&gt;exec.Command&lt;/code&gt;. G204 lo marca como "subproceso con variable", que es&lt;br&gt;
correcto pero genérico. &lt;strong&gt;G702 lo marca como inyección de comandos&lt;/strong&gt;, porque&lt;br&gt;
sabe que ese valor no se ha validado. La misma línea, dos reglas, y la segunda&lt;br&gt;
es la que dice qué hacer.&lt;/p&gt;

&lt;p&gt;Lo mismo con G703: &lt;code&gt;G304&lt;/code&gt; dice "inclusión de archivo vía variable", y &lt;strong&gt;G703 dice&lt;br&gt;
recorrido de rutas&lt;/strong&gt;, siguiendo que &lt;code&gt;ruta&lt;/code&gt; viene de la petición sin comprobar.&lt;/p&gt;

&lt;p&gt;Es la diferencia entre un filtro por patrón y un análisis de flujo de datos.&lt;/p&gt;
&lt;h2&gt;
  
  
  Integrarlo en la automatización
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gosec&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;gosec -no-fail -fmt=json -out=gosec.json ./...&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;code&gt;-no-fail&lt;/code&gt; deja que el escaneo termine y muestre el informe completo. Para que&lt;br&gt;
el pipeline falle:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gosec ./... &lt;span class="nt"&gt;-severity&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;HIGH           &lt;span class="c"&gt;# falla si hay hallazgos altos&lt;/span&gt;
gosec &lt;span class="nt"&gt;-no-fail&lt;/span&gt; ./... &lt;span class="nt"&gt;-severity&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;HIGH  &lt;span class="c"&gt;# solo informa&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Para un error justificado hay una directiva en la misma línea:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="n"&gt;ruta&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;validarComoInterno&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ruta&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c"&gt;// #nosec G304 -- ya sanitizada arriba&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La convención es no abusar de ella: cada &lt;code&gt;#nosec&lt;/code&gt; es una excepción que alguien&lt;br&gt;
tiene que leer y justificar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sobre los falsos negativos
&lt;/h2&gt;

&lt;p&gt;gosec analiza el flujo de información dentro del archivo y entre archivos del&lt;br&gt;
mismo paquete. Hay casos que se le escapan:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Lógica de negocio incorrecta&lt;/strong&gt; sin ningún patrón peligroso.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Vulnerabilidades en dependencias&lt;/strong&gt;, que es otro problema: para eso está
OWASP Dependency-Check.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Código generado automáticamente&lt;/strong&gt;, que normalmente no se revisa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Otro lenguaje&lt;/strong&gt;: gosec solo analiza Go.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;El informe incluye el CWE de cada hallazgo, que permite priorizar por lo que la&lt;br&gt;
norma exige y no por la severidad que le asigne la herramienta.&lt;/p&gt;

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

&lt;p&gt;El ejercicio deja un resultado concreto: 17 hallazgos correctamente&lt;br&gt;
clasificados, cinco de ellos de severidad alta, sobre una aplicación escrita&lt;br&gt;
para contenerlos.&lt;/p&gt;

&lt;p&gt;Lo que demuestra el análisis de taint es lo más aprovechable. Una herramienta&lt;br&gt;
que dice "aquí hay un &lt;code&gt;exec.Command&lt;/code&gt; con variable" obliga a revisar; una que&lt;br&gt;
dice "el valor llega desde la petición sin validar" dice cuál es el problema.&lt;/p&gt;

&lt;p&gt;Ningún análisis estático sustituye a revisar el diseño, y un resultado limpio&lt;br&gt;
no significa que el código sea correcto: significa que esta herramienta no&lt;br&gt;
encontró nada. La diferencia entre las dos afirmaciones es la que hace que un&lt;br&gt;
informe sirva para algo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Enlaces
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Repositorio: &lt;a href="https://github.com/UPT-FAING-EPIS/actividad-grupal-1-sast" rel="noopener noreferrer"&gt;https://github.com/UPT-FAING-EPIS/actividad-grupal-1-sast&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Aplicación con el informe: &lt;a href="https://sast-taskflow.vercel.app" rel="noopener noreferrer"&gt;https://sast-taskflow.vercel.app&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;gosec: &lt;a href="https://github.com/securego/gosec" rel="noopener noreferrer"&gt;https://github.com/securego/gosec&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;CWE de la OWASP: &lt;a href="https://cwe.mitre.org/" rel="noopener noreferrer"&gt;https://cwe.mitre.org/&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>security</category>
      <category>gosec</category>
      <category>go</category>
      <category>staticanalysis</category>
    </item>
    <item>
      <title>Seis estrategias de respaldo para bases de datos NoSQL, y qué falla de verdad</title>
      <dc:creator>Rodriguez Patrick</dc:creator>
      <pubDate>Sun, 04 Oct 2026 01:03:50 +0000</pubDate>
      <link>https://dev.to/dejameingresar/seis-estrategias-de-respaldo-para-bases-de-datos-nosql-y-que-falla-de-verdad-5hce</link>
      <guid>https://dev.to/dejameingresar/seis-estrategias-de-respaldo-para-bases-de-datos-nosql-y-que-falla-de-verdad-5hce</guid>
      <description>&lt;h1&gt;
  
  
  Seis estrategias de respaldo para bases de datos NoSQL, y qué falla de verdad
&lt;/h1&gt;

&lt;p&gt;No uso MS SQL Server: el enunciado lo excluye y, además, el problema que quiero&lt;br&gt;
estudiar es el de los motores NoSQL, donde cada familia de motor tiene una forma&lt;br&gt;
distinta de persistir y, sobre todo, una forma distinta de romperse.&lt;/p&gt;

&lt;p&gt;Lo que hice fue construir una aplicación que ejecuta seis estrategias de respaldo&lt;br&gt;
sobre tres motores reales, restaura cada una y &lt;strong&gt;cuenta lo que vuelve&lt;/strong&gt;. No me&lt;br&gt;
conformé con que el comando terminara con código cero: varias veces terminó en&lt;br&gt;
cero sin haber restaurado nada.&lt;/p&gt;
&lt;h2&gt;
  
  
  Enlaces del proyecto
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Repositorio público con el código y la documentación:&lt;/strong&gt;
&lt;a href="https://github.com/dejameingresar/dataforge-backup-nosql" rel="noopener noreferrer"&gt;https://github.com/dejameingresar/dataforge-backup-nosql&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Aplicación desplegada en la nube (Render):&lt;/strong&gt;
&lt;a href="https://dataforge-backup-si783.onrender.com" rel="noopener noreferrer"&gt;https://dataforge-backup-si783.onrender.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Video de construcción y demostración:&lt;/strong&gt; &lt;em&gt;(pendiente de publicar)&lt;/em&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Los tres motores
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Motor&lt;/th&gt;
&lt;th&gt;Versión&lt;/th&gt;
&lt;th&gt;Modelo de datos&lt;/th&gt;
&lt;th&gt;Rol en el proyecto&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;MongoDB&lt;/td&gt;
&lt;td&gt;7.0.14&lt;/td&gt;
&lt;td&gt;documentos en colecciones&lt;/td&gt;
&lt;td&gt;base documental con índices&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Redis&lt;/td&gt;
&lt;td&gt;7.0.15&lt;/td&gt;
&lt;td&gt;pares clave-valor en memoria&lt;/td&gt;
&lt;td&gt;claves de cinco tipos distintos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Neo4j&lt;/td&gt;
&lt;td&gt;5.24.0&lt;/td&gt;
&lt;td&gt;grafos (nodos y relaciones)&lt;/td&gt;
&lt;td&gt;grafo con tres tipos de arista&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;h2&gt;
  
  
  Las seis estrategias, con las cifras medidas
&lt;/h2&gt;

&lt;p&gt;Cada número de esta tabla salió de una corrida real: se genera el respaldo, se&lt;br&gt;
calcula su SHA-256, se destruyen los datos, se restaura y se cuenta lo que volvió.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Motor&lt;/th&gt;
&lt;th&gt;Estrategia&lt;/th&gt;
&lt;th&gt;Artefacto&lt;/th&gt;
&lt;th&gt;Tamaño&lt;/th&gt;
&lt;th&gt;Duración&lt;/th&gt;
&lt;th&gt;Round-trip&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;MongoDB&lt;/td&gt;
&lt;td&gt;&lt;code&gt;logico_mongodump&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;*.bson.gz&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;30.8 KiB&lt;/td&gt;
&lt;td&gt;343 ms&lt;/td&gt;
&lt;td&gt;1400 → 1400 docs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MongoDB&lt;/td&gt;
&lt;td&gt;&lt;code&gt;fisico_wiredtiger&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;snapshot_wiredtiger.tar.gz&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;1.11 MiB&lt;/td&gt;
&lt;td&gt;2.44 s&lt;/td&gt;
&lt;td&gt;1400 → 1400 docs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Redis&lt;/td&gt;
&lt;td&gt;&lt;code&gt;rdb_dump&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;dump.rdb&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;11.3 KiB&lt;/td&gt;
&lt;td&gt;154 ms&lt;/td&gt;
&lt;td&gt;240 → 240 claves&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Redis&lt;/td&gt;
&lt;td&gt;&lt;code&gt;aof_append&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;appendonlydir/&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;11.4 KiB&lt;/td&gt;
&lt;td&gt;2.15 s&lt;/td&gt;
&lt;td&gt;240 → 240 claves&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Neo4j&lt;/td&gt;
&lt;td&gt;&lt;code&gt;dump_binario&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;neo4j.dump&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;509.1 KiB&lt;/td&gt;
&lt;td&gt;3.48 s&lt;/td&gt;
&lt;td&gt;200/594 → 200/594&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Neo4j&lt;/td&gt;
&lt;td&gt;&lt;code&gt;exportacion_cypher&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;JSON Lines&lt;/td&gt;
&lt;td&gt;104.0 KiB&lt;/td&gt;
&lt;td&gt;420 ms&lt;/td&gt;
&lt;td&gt;200/594 → 200/594&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;6 de 6&lt;/strong&gt; restauraron exactamente lo que había. Ese "exactamente" es lo que&lt;br&gt;
importa: varias veces costó llegar ahí.&lt;/p&gt;
&lt;h3&gt;
  
  
  1. MongoDB, &lt;code&gt;mongodump&lt;/code&gt;: el lógico
&lt;/h3&gt;

&lt;p&gt;Exporta cada colección a BSON comprimido. Habla el protocolo de red, así que&lt;br&gt;
funciona &lt;strong&gt;con el servidor encendido&lt;/strong&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;mongodump &lt;span class="nt"&gt;--uri&lt;/span&gt; mongodb://127.0.0.1:27017/dataforge_backup &lt;span class="nt"&gt;--out&lt;/span&gt; DIR &lt;span class="nt"&gt;--gzip&lt;/span&gt;
mongorestore &lt;span class="nt"&gt;--uri&lt;/span&gt; mongodb://127.0.0.1:27017 &lt;span class="nt"&gt;--gzip&lt;/span&gt; DIR/dataforge_backup/clientes.bson.gz
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Protege los documentos y los índices. No protege los usuarios, los roles, el&lt;br&gt;
oplog ni el estado interno de WiredTiger: eso va aparte.&lt;/p&gt;
&lt;h3&gt;
  
  
  2. MongoDB, copia en frío de WiredTiger
&lt;/h3&gt;

&lt;p&gt;Con el motor &lt;strong&gt;detenido&lt;/strong&gt;, se copia el &lt;code&gt;dbpath&lt;/code&gt; entero: los &lt;code&gt;.wt&lt;/code&gt;, el catálogo,&lt;br&gt;
&lt;code&gt;WiredTiger.turtle&lt;/code&gt;, &lt;code&gt;sizeStorer&lt;/code&gt; y el &lt;code&gt;journal&lt;/code&gt;. Es una foto del almacenamiento.&lt;/p&gt;

&lt;p&gt;Aquí está la primera limitación que vale la pena entender: &lt;strong&gt;el archivo es del&lt;br&gt;
motor completo, no de una base&lt;/strong&gt;. Al probarlo, el &lt;code&gt;dbpath&lt;/code&gt; tenía tres bases y el&lt;br&gt;
respaldo se llevó las tres. Si lo que quieres es respaldar &lt;em&gt;una&lt;/em&gt; base, esta&lt;br&gt;
estrategia no sirve, y esa es exactamente la razón por la que existe&lt;br&gt;
&lt;code&gt;mongodump&lt;/code&gt;.&lt;/p&gt;
&lt;h3&gt;
  
  
  3. Redis, volcado RDB
&lt;/h3&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;redis-cli &lt;span class="nt"&gt;-p&lt;/span&gt; 6379 &lt;span class="nt"&gt;--rdb&lt;/span&gt; dump.rdb
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Un punto de control binario de toda la base. Redis 7 usa &lt;em&gt;copy-on-write&lt;/em&gt;:&lt;br&gt;
mientras se copia, las páginas modificadas se duplican, así que el archivo es&lt;br&gt;
consistente aunque el servidor siga recibiendo escrituras.&lt;/p&gt;

&lt;p&gt;No protege los comandos ejecutados entre puntos de control: la ventana de pérdida&lt;br&gt;
es de segundos.&lt;/p&gt;
&lt;h3&gt;
  
  
  4. Redis, copia del AOF
&lt;/h3&gt;

&lt;p&gt;El AOF es un registro de &lt;strong&gt;órdenes de escritura&lt;/strong&gt;, no de estado. Su ventana de&lt;br&gt;
pérdida es mucho menor que la del RDB.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;redis-cli &lt;span class="nt"&gt;-p&lt;/span&gt; 6379 BGREWRITEAOF
&lt;span class="c"&gt;# esperar a que termine:&lt;/span&gt;
redis-cli &lt;span class="nt"&gt;-p&lt;/span&gt; 6379 INFO persistence   &lt;span class="c"&gt;# aof_rewrite_in_progress == 0&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Con Redis 7 el AOF ya no es un archivo suelto: es un &lt;strong&gt;directorio&lt;/strong&gt; con un&lt;br&gt;
manifiesto y varios &lt;code&gt;.base.rdb&lt;/code&gt; e &lt;code&gt;.incr.aof&lt;/code&gt;. Copiar solo el &lt;code&gt;.aof&lt;/code&gt; deja fuera&lt;br&gt;
los incrementales y se pierde lo escrito después.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Neo4j, dump binario
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;neo4j-admin database dump neo4j &lt;span class="nt"&gt;--to-path&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;DESTINO
neo4j-admin database load neo4j &lt;span class="nt"&gt;--from-path&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;DESTINO &lt;span class="nt"&gt;--overwrite-destination&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Empaqueta todo en un &lt;code&gt;.dump&lt;/code&gt;. En la edición &lt;strong&gt;Community exige que la base esté&lt;br&gt;
detenida&lt;/strong&gt; para el dump y para la carga: es una ventana sin servicio, y la&lt;br&gt;
ficha de la estrategia lo declara en vez de esconderlo.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Neo4j, exportación a JSON Lines
&lt;/h3&gt;

&lt;p&gt;Nodos y aristas como texto, con los identificadores internos reemplazados por&lt;br&gt;
claves de negocio. Es la única que &lt;strong&gt;corre en caliente&lt;/strong&gt; y la única que se puede&lt;br&gt;
revisar a mano, versionar en un repositorio o comparar entre versiones.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que falló de verdad
&lt;/h2&gt;

&lt;p&gt;Esta es la parte que más aporta, porque no aparece en los manuales.&lt;/p&gt;

&lt;h3&gt;
  
  
  Un respaldo que "tiene éxito" y no restaura nada
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;mongorestore&lt;/code&gt; &lt;strong&gt;no acepta un directorio&lt;/strong&gt;. Si se le pasa la carpeta del dump&lt;br&gt;
devuelve código de salida &lt;code&gt;0&lt;/code&gt; y restaura &lt;strong&gt;cero documentos&lt;/strong&gt;, con un mensaje&lt;br&gt;
apodable: &lt;code&gt;don't know what to do with file ... skipping&lt;/code&gt;. Hay que pasarle cada&lt;br&gt;
&lt;code&gt;.bson.gz&lt;/code&gt; individual.&lt;/p&gt;

&lt;p&gt;Lo detecté porque conté los documentos después de restaurar. Si hubiera confiado&lt;br&gt;
en el código de salida, habría publicado un respaldo que no restauraba nada.&lt;/p&gt;

&lt;h3&gt;
  
  
  Redis 7 ya no permite elegir dónde guardar el RDB
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;CONFIG SET dir&lt;/code&gt; falla con &lt;code&gt;can't set protected config&lt;/code&gt;. La salida es usar&lt;br&gt;
&lt;code&gt;redis-cli --rdb DESTINO&lt;/code&gt;, que además &lt;strong&gt;no detiene el servidor&lt;/strong&gt;: usa replicación&lt;br&gt;
en modo &lt;code&gt;rdb-only&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Neo4j: las etiquetas no se pueden añadir después
&lt;/h3&gt;

&lt;p&gt;Neo4j 5 rechaza &lt;code&gt;SET n:Etiqueta&lt;/code&gt; con un error de sintaxis: eso exige el plugin&lt;br&gt;
APOC, que no viene instalado. La forma sin plugins es crear el nodo con sus&lt;br&gt;
etiquetas desde el &lt;code&gt;CREATE&lt;/code&gt; (&lt;code&gt;CREATE (n:Uno:Dos {...})&lt;/code&gt;), lo que obliga a agrupar&lt;br&gt;
las filas por su conjunto exacto de etiquetas.&lt;/p&gt;

&lt;h3&gt;
  
  
  Neo4j: &lt;code&gt;MERGE&lt;/code&gt; colapsa las aristas repetidas
&lt;/h3&gt;

&lt;p&gt;En un grafo puede haber &lt;strong&gt;varias aristas del mismo tipo entre el mismo par de&lt;br&gt;
nodos&lt;/strong&gt;, con propiedades distintas. &lt;code&gt;MERGE&lt;/code&gt; las funde en una sola. Al medir el&lt;br&gt;
round-trip me faltaban 4 relaciones: 590 de 594. Parecía "casi bien", y por eso&lt;br&gt;
lo investigué en vez de anotarlo como una pérdida menor. Con &lt;code&gt;CREATE&lt;/code&gt; se&lt;br&gt;
conservan todas.&lt;/p&gt;

&lt;p&gt;La tentación era relajar la comparación para que el número cuadrara. Eso habría&lt;br&gt;
convertido un defecto real en un falso positivo.&lt;/p&gt;

&lt;h3&gt;
  
  
  Una ventana sin servicio
&lt;/h3&gt;

&lt;p&gt;Las dos estrategias físicas (&lt;code&gt;fisico_wiredtiger&lt;/code&gt; y &lt;code&gt;dump_binario&lt;/code&gt;) exigen el&lt;br&gt;
motor detenido. En un sistema en producción eso no es un detalle de&lt;br&gt;
implementación: es una decisión de arquitectura. Para la misma base, la&lt;br&gt;
exportación lógica de Neo4j corría en caliente en 420 ms, frente a los 3.48 s del&lt;br&gt;
dump con el servidor parado.&lt;/p&gt;

&lt;h2&gt;
  
  
  Integración continua
&lt;/h2&gt;

&lt;p&gt;Cada &lt;code&gt;push&lt;/code&gt; a &lt;code&gt;main&lt;/code&gt; ejecuta la suite. Los casos que necesitan motores reales no&lt;br&gt;
pueden correr en el runner de GitHub Actions, así que &lt;strong&gt;fallan de forma&lt;br&gt;
explícita&lt;/strong&gt; en vez de devolver un resultado inventado; la verificación completa se&lt;br&gt;
hace contra los motores locales. El despliegue en Render es un &lt;code&gt;render.yaml&lt;/code&gt; con&lt;br&gt;
&lt;code&gt;autoDeploy&lt;/code&gt; por commit y el health check en &lt;code&gt;/api/salud&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;La aplicación usa solo la biblioteca estándar de Python: sin &lt;code&gt;requirements.txt&lt;/code&gt;,&lt;br&gt;
sin instalación, sin cadena de dependencias. En la nube los motores aparecen como&lt;br&gt;
&lt;code&gt;n/d&lt;/code&gt;, porque un servicio público no expone puertos de base de datos; en local&lt;br&gt;
responden de verdad.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusiones
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Un respaldo no es un archivo: es una cadena.&lt;/strong&gt; Backup, verificación por
hash, restauración y conteo. Saltaba un eslabón, el resultado no servía.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El código de salida no es evidencia.&lt;/strong&gt; Dos de los fallos más caros de este
proyecto salían con &lt;code&gt;0&lt;/code&gt;. Contar lo que volvió sí lo es.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cada familia de motor tiene su propia restricción&lt;/strong&gt;, y la operación más
cara no siempre es la que parece: la física es más rápida de escribir pero te
quita el servicio.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El respaldo físico es del motor; el lógico, de la base.&lt;/strong&gt; Esa diferencia
decide qué estrategia sirve y cuál no.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Documentar lo que no protege&lt;/strong&gt; es más útil que documentar lo que sí. Una
ficha de estrategia que solo enumera ventajas no sirve para decidir.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Código
&lt;/h2&gt;

&lt;p&gt;El repositorio incluye los tres adaptadores, la batería de 27 pruebas con el&lt;br&gt;
ciclo completo contra un motor real, el smoke test en navegador y el&lt;br&gt;
&lt;code&gt;render.yaml&lt;/code&gt; del despliegue.&lt;/p&gt;

</description>
      <category>mongodb</category>
      <category>redis</category>
      <category>nosql</category>
      <category>backup</category>
    </item>
  </channel>
</rss>
