<?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: GERALD DEYBI ZEVALLOS PINTO</title>
    <description>The latest articles on DEV Community by GERALD DEYBI ZEVALLOS PINTO (@gerald_deybizevallospin).</description>
    <link>https://dev.to/gerald_deybizevallospin</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%2F4160798%2Fd2af4b88-fdcb-4d1e-ac73-6d48ad8e5156.jpg</url>
      <title>DEV Community: GERALD DEYBI ZEVALLOS PINTO</title>
      <link>https://dev.to/gerald_deybizevallospin</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/gerald_deybizevallospin"/>
    <language>en</language>
    <item>
      <title>Estrategia de respaldo para Azure Cosmos DB for NoSQL, automatizada con Terraform y GitHub Actions</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Mon, 16 Nov 2026 02:48:48 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/estrategia-de-respaldo-para-azure-cosmos-db-for-nosql-automatizada-con-terraform-y-github-actions-236n</link>
      <guid>https://dev.to/gerald_deybizevallospin/estrategia-de-respaldo-para-azure-cosmos-db-for-nosql-automatizada-con-terraform-y-github-actions-236n</guid>
      <description>&lt;p&gt;Una base de datos sin respaldos es una apuesta. En este artículo cuento cómo mi compañero Kevin Hinojosa y yo diseñamos y automatizamos la estrategia de respaldo de &lt;strong&gt;TacnaGo&lt;/strong&gt;, nuestra guía de lugares turísticos de Tacna que guarda sus datos en &lt;strong&gt;Azure Cosmos DB for NoSQL&lt;/strong&gt;. Yo me encargué de la parte de infraestructura y automatización: dónde se guardan los respaldos, cuánto tiempo se conservan y cómo se ejecutan solos con GitHub Actions.&lt;/p&gt;

&lt;p&gt;👉 &lt;strong&gt;App publicada:&lt;/strong&gt; &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net&lt;/a&gt;&lt;br&gt;
👉 &lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  El punto de partida
&lt;/h2&gt;

&lt;p&gt;TacnaGo es una API en .NET 9 con una página web, desplegada en Azure App Service. Cada lugar es un documento JSON en el contenedor &lt;code&gt;Lugares&lt;/code&gt; de Cosmos DB, con la categoría como clave de partición. Toda la infraestructura se crea con Terraform y se despliega con GitHub Actions.&lt;/p&gt;

&lt;p&gt;Cosmos DB ya trae un respaldo automático, pero no basta por sí solo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;El &lt;strong&gt;respaldo periódico nativo&lt;/strong&gt; guarda una copia cada 4 horas y conserva solo las 2 últimas (8 horas de retención). Si alguien borra datos un viernes y nadie se da cuenta hasta el lunes, ya no hay copia.&lt;/li&gt;
&lt;li&gt;Para restaurarlo hay que abrir un ticket de soporte con Azure, y se restaura toda la cuenta en una cuenta nueva.&lt;/li&gt;
&lt;li&gt;El &lt;strong&gt;respaldo continuo&lt;/strong&gt; (restauración a un punto en el tiempo) es mejor, pero cambiar a ese modo no tiene vuelta atrás y nuestra cuenta de Cosmos DB la compartimos con otro proyecto.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Por eso agregamos un &lt;strong&gt;respaldo lógico&lt;/strong&gt; propio, que controlamos nosotros.&lt;/p&gt;
&lt;h2&gt;
  
  
  La estrategia en capas
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Capa&lt;/th&gt;
&lt;th&gt;Qué hace&lt;/th&gt;
&lt;th&gt;Dónde&lt;/th&gt;
&lt;th&gt;Retención&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1. Respaldo nativo&lt;/td&gt;
&lt;td&gt;Copia automática de la cuenta cada 4 horas&lt;/td&gt;
&lt;td&gt;Azure (geo-redundante)&lt;/td&gt;
&lt;td&gt;8 horas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2. Respaldo lógico diario&lt;/td&gt;
&lt;td&gt;Exporta el contenedor a JSON comprimido con SHA-256&lt;/td&gt;
&lt;td&gt;Azure Blob Storage&lt;/td&gt;
&lt;td&gt;37 días&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3. Copia fuera de Azure&lt;/td&gt;
&lt;td&gt;El mismo archivo como artefacto de GitHub Actions&lt;/td&gt;
&lt;td&gt;GitHub&lt;/td&gt;
&lt;td&gt;30 días&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4. Prueba de restauración&lt;/td&gt;
&lt;td&gt;Restaura cada semana el último respaldo y lo verifica&lt;/td&gt;
&lt;td&gt;Contenedor &lt;code&gt;Lugares-restore&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Con esto el &lt;strong&gt;RPO&lt;/strong&gt; (cuántos datos podemos perder como máximo) es de 24 horas con el respaldo lógico, y el &lt;strong&gt;RTO&lt;/strong&gt; (cuánto tardamos en recuperarnos) es de unos minutos: lo que demora ejecutar un workflow.&lt;/p&gt;
&lt;h2&gt;
  
  
  La infraestructura de respaldos con Terraform
&lt;/h2&gt;

&lt;p&gt;Los respaldos viven en una &lt;strong&gt;cuenta de almacenamiento separada&lt;/strong&gt; de la base de datos. Así, un problema en la base no se lleva también las copias. La cuenta tiene versionado y borrado temporal, de modo que un respaldo sobrescrito o borrado por error se puede recuperar:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hcl"&gt;&lt;code&gt;&lt;span class="n"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"azurerm_storage_account"&lt;/span&gt; &lt;span class="s2"&gt;"backups"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;                            &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"sttacnagobkgerald"&lt;/span&gt;
  &lt;span class="n"&gt;account_tier&lt;/span&gt;                    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"Standard"&lt;/span&gt;
  &lt;span class="n"&gt;account_replication_type&lt;/span&gt;        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"LRS"&lt;/span&gt;
  &lt;span class="n"&gt;min_tls_version&lt;/span&gt;                 &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"TLS1_2"&lt;/span&gt;
  &lt;span class="n"&gt;allow_nested_items_to_be_public&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;

  &lt;span class="n"&gt;blob_properties&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;versioning_enabled&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
    &lt;span class="n"&gt;delete_retention_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="n"&gt;days&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;7&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;La retención la aplica Azure solo, con una &lt;strong&gt;política de ciclo de vida&lt;/strong&gt;: los respaldos pasan al nivel Cool (más barato) a los 7 días y se borran a los 37.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hcl"&gt;&lt;code&gt;&lt;span class="n"&gt;actions&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;base_blob&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;tier_to_cool_after_days_since_modification_greater_than&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;
    &lt;span class="n"&gt;delete_after_days_since_modification_greater_than&lt;/span&gt;        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;37&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;Terraform también crea el contenedor de prueba &lt;code&gt;Lugares-restore&lt;/code&gt;, con la misma clave de partición, dentro de la misma base. Comparte los RU/s de la base, así que no cuesta nada extra.&lt;/p&gt;

&lt;h2&gt;
  
  
  El respaldo diario: backup.yml
&lt;/h2&gt;

&lt;p&gt;Se ejecuta todos los días a las 00:00 (hora de Perú) con un &lt;code&gt;schedule&lt;/code&gt;, y también se puede lanzar a mano:&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;on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;schedule&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;cron&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'0 5 * * *'&lt;/span&gt;   &lt;span class="c1"&gt;# 05:00 UTC = 00:00 en Perú
&lt;/span&gt;  &lt;span class="na"&gt;workflow_dispatch&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Los pasos son:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Inicia sesión en Azure con un service principal guardado en los secrets del repositorio.&lt;/li&gt;
&lt;li&gt;Obtiene la clave de Cosmos DB con &lt;code&gt;az cosmosdb keys list&lt;/code&gt; y la enmascara en el log (&lt;code&gt;::add-mask::&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;Ejecuta &lt;code&gt;backup/backup.py&lt;/code&gt;, que lee todos los documentos, quita las propiedades del sistema (&lt;code&gt;_rid&lt;/code&gt;, &lt;code&gt;_etag&lt;/code&gt;, &lt;code&gt;_ts&lt;/code&gt;) y guarda un &lt;code&gt;.json.gz&lt;/code&gt; con la cantidad de documentos y un hash SHA-256.&lt;/li&gt;
&lt;li&gt;Sube el archivo a Blob Storage con la cantidad y el hash como metadatos.&lt;/li&gt;
&lt;li&gt;Guarda una segunda copia como artefacto de GitHub Actions.
&lt;/li&gt;
&lt;/ol&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;Subir el respaldo a Azure Blob Storage&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;az storage blob upload --container-name "$BLOB_CONTAINER" \&lt;/span&gt;
      &lt;span class="s"&gt;--name "tacnago/${{ steps.respaldo.outputs.nombre }}" \&lt;/span&gt;
      &lt;span class="s"&gt;--file "${{ steps.respaldo.outputs.archivo }}" \&lt;/span&gt;
      &lt;span class="s"&gt;--metadata documentos=${{ steps.respaldo.outputs.documentos }}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  La prueba de restauración: restore.yml
&lt;/h2&gt;

&lt;p&gt;Un respaldo que nunca se probó no es un respaldo. Por eso &lt;code&gt;restore.yml&lt;/code&gt; corre cada domingo y:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Descarga el último respaldo de Blob Storage.&lt;/li&gt;
&lt;li&gt;Verifica el SHA-256 (si el archivo está dañado, falla).&lt;/li&gt;
&lt;li&gt;Vacía el contenedor de prueba &lt;code&gt;Lugares-restore&lt;/code&gt; y restaura ahí todos los documentos.&lt;/li&gt;
&lt;li&gt;Comprueba que la cantidad coincida y lee cada documento por su id y su clave de partición.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;En una emergencia real, el mismo workflow se ejecuta a mano eligiendo el destino &lt;code&gt;Lugares&lt;/code&gt;. Restaura con &lt;code&gt;upsert&lt;/code&gt;, así que se puede repetir sin duplicar datos.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los respaldos en la app
&lt;/h2&gt;

&lt;p&gt;La app tiene una sección &lt;strong&gt;"Respaldos de la base de datos"&lt;/strong&gt; y un endpoint &lt;code&gt;GET /api/respaldos&lt;/code&gt; que lista los respaldos guardados en Blob Storage, con su fecha, cantidad de documentos, tamaño y nivel de acceso. La cadena de conexión de la cuenta de respaldos la pasa Terraform a la configuración del App Service, así que no aparece en el código.&lt;/p&gt;

&lt;h2&gt;
  
  
  Problemas que encontré
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;La cuenta de Cosmos DB es compartida.&lt;/strong&gt; Usamos la cuenta gratuita de la suscripción, que también usa otro proyecto, así que no cambié su política de respaldo nativa (pasar a respaldo continuo no tiene vuelta atrás). El respaldo lógico funciona a nivel de nuestro contenedor sin tocar la cuenta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los permisos del service principal.&lt;/strong&gt; El rol Contributor no puede leer blobs con Azure AD (&lt;code&gt;--auth-mode login&lt;/code&gt;), así que el workflow obtiene la clave de la cuenta con &lt;code&gt;az storage account keys list&lt;/code&gt; y la enmascara en el log.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El nivel Cool tiene un tiempo mínimo de 30 días.&lt;/strong&gt; Si un blob se borra antes, Azure cobra la diferencia. Por eso los respaldos se borran a los 37 días (7 en Hot + 30 en Cool) y no a los 30.&lt;/li&gt;
&lt;/ol&gt;

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

&lt;ul&gt;
&lt;li&gt;El respaldo nativo de Cosmos DB es un buen piso, pero un respaldo lógico propio da más retención, independencia y control.&lt;/li&gt;
&lt;li&gt;Guardar las copias en otra cuenta y en otro proveedor (GitHub) sigue la idea de la regla 3-2-1.&lt;/li&gt;
&lt;li&gt;La prueba de restauración automática es lo que da confianza: cada semana sabemos que el último respaldo sirve.&lt;/li&gt;
&lt;/ul&gt;

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

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workflows de respaldo y restauración:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb/actions" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb/actions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;App publicada:&lt;/strong&gt; &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Video (grabado con Kevin):&lt;/strong&gt; &lt;a href="https://youtu.be/z_5a_3TTS8E" rel="noopener noreferrer"&gt;https://youtu.be/z_5a_3TTS8E&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>azure</category>
      <category>nosql</category>
      <category>devops</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Despliegue automático de una app con Azure Cosmos DB for NoSQL usando Terraform y GitHub Actions</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Sun, 15 Nov 2026 03:57:01 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/despliegue-automatico-de-una-app-con-azure-cosmos-db-for-nosql-usando-terraform-y-github-actions-fci</link>
      <guid>https://dev.to/gerald_deybizevallospin/despliegue-automatico-de-una-app-con-azure-cosmos-db-for-nosql-usando-terraform-y-github-actions-fci</guid>
      <description>&lt;p&gt;En este artículo cuento cómo mi compañero Kevin Hinojosa y yo construimos y desplegamos &lt;strong&gt;TacnaGo&lt;/strong&gt;, una guía de lugares turísticos de Tacna (Perú) que guarda sus datos en &lt;strong&gt;Azure Cosmos DB for NoSQL&lt;/strong&gt;. Yo me encargué sobre todo de la infraestructura y del despliegue automatizado, así que me enfoco en esa parte: con un solo &lt;code&gt;git push&lt;/code&gt; se crea la infraestructura, se cargan los datos, se construye la imagen Docker y la app queda publicada en Azure.&lt;/p&gt;

&lt;p&gt;👉 &lt;strong&gt;App publicada:&lt;/strong&gt; &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net&lt;/a&gt;&lt;br&gt;
👉 &lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  ¿Qué es TacnaGo?
&lt;/h2&gt;

&lt;p&gt;Es una API REST en &lt;strong&gt;.NET 9&lt;/strong&gt; con una página web sencilla. Cada lugar (la Catedral, los Petroglifos de Miculla, la playa Boca del Río, las picanterías de Pocollay…) es un &lt;strong&gt;documento JSON&lt;/strong&gt; en Cosmos DB, y la &lt;strong&gt;categoría&lt;/strong&gt; del lugar es la clave de partición. La app permite filtrar por categoría, buscar por etiqueta, agregar y eliminar lugares, y muestra cuántas &lt;strong&gt;Request Units (RU)&lt;/strong&gt; costó cada operación.&lt;/p&gt;
&lt;h2&gt;
  
  
  ¿Por qué Azure Cosmos DB for NoSQL?
&lt;/h2&gt;

&lt;p&gt;La actividad pedía una base NoSQL que no fuera Redis, MongoDB, Neo4j ni Prometheus. Elegí &lt;strong&gt;Azure Cosmos DB for NoSQL&lt;/strong&gt; (la API nativa de Cosmos DB, no la compatible con MongoDB) por tres razones:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Costo cero:&lt;/strong&gt; tiene una capa gratuita de 1000 RU/s y 25 GB por cuenta, y la usamos con una suscripción &lt;strong&gt;Azure for Students&lt;/strong&gt;, sin tarjeta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se automatiza con Terraform:&lt;/strong&gt; el proveedor &lt;code&gt;azurerm&lt;/code&gt; crea la base y el contenedor con su clave de partición.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se integra con el resto:&lt;/strong&gt; la app corre en Azure App Service, en la misma nube y región (&lt;code&gt;westus3&lt;/code&gt;).&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Arquitectura
&lt;/h2&gt;

&lt;p&gt;Un &lt;code&gt;git push&lt;/code&gt; dispara GitHub Actions. Terraform crea la base de datos en Cosmos DB y el App Service en Azure; la imagen Docker se publica en GitHub Container Registry y App Service la descarga y la ejecuta. La app se conecta a Cosmos DB con el SDK oficial de .NET.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Pieza&lt;/th&gt;
&lt;th&gt;Servicio&lt;/th&gt;
&lt;th&gt;Costo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Base de datos NoSQL&lt;/td&gt;
&lt;td&gt;Azure Cosmos DB for NoSQL (capa gratuita)&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Backend y página web&lt;/td&gt;
&lt;td&gt;Azure App Service Linux, plan F1, con contenedor&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Imagen Docker&lt;/td&gt;
&lt;td&gt;GitHub Container Registry (ghcr.io)&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Estado de Terraform&lt;/td&gt;
&lt;td&gt;Azure Storage Account&lt;/td&gt;
&lt;td&gt;céntimos&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;h2&gt;
  
  
  Infraestructura como código con Terraform
&lt;/h2&gt;

&lt;p&gt;Todo está en &lt;code&gt;infra/main.tf&lt;/code&gt;. La parte de Cosmos DB crea una base de 400 RU/s y el contenedor &lt;code&gt;Lugares&lt;/code&gt; con la clave de partición &lt;code&gt;/categoria&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hcl"&gt;&lt;code&gt;&lt;span class="n"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"azurerm\_cosmosdb\_sql\_database"&lt;/span&gt; &lt;span class="s2"&gt;"db"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;                &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"TacnaGo"&lt;/span&gt;
  &lt;span class="n"&gt;resource&lt;/span&gt;\&lt;span class="n"&gt;_group&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;resource&lt;/span&gt;\&lt;span class="n"&gt;_group&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;
  &lt;span class="n"&gt;account&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;
  &lt;span class="n"&gt;throughput&lt;/span&gt;          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;400&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"azurerm\_cosmosdb\_sql\_container"&lt;/span&gt; &lt;span class="s2"&gt;"lugares"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;                  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"Lugares"&lt;/span&gt;
  &lt;span class="n"&gt;resource&lt;/span&gt;\&lt;span class="n"&gt;_group&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;resource&lt;/span&gt;\&lt;span class="n"&gt;_group&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;
  &lt;span class="n"&gt;account&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;
  &lt;span class="n"&gt;database&lt;/span&gt;\&lt;span class="n"&gt;_name&lt;/span&gt;         &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_sql&lt;/span&gt;\&lt;span class="n"&gt;_database&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;
  &lt;span class="n"&gt;partition&lt;/span&gt;\&lt;span class="n"&gt;_key&lt;/span&gt;\&lt;span class="n"&gt;_paths&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; \&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"/categoria"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="n"&gt;partition&lt;/span&gt;\&lt;span class="n"&gt;_key&lt;/span&gt;\&lt;span class="n"&gt;_version&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El App Service ejecuta la imagen publicada en GitHub Packages. Lo más importante es que &lt;strong&gt;la clave de Cosmos DB va directo de Terraform a la configuración de la app&lt;/strong&gt;: nunca aparece en el código ni en GitHub.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hcl"&gt;&lt;code&gt;&lt;span class="n"&gt;app&lt;/span&gt;\&lt;span class="n"&gt;_settings&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="s2"&gt;"WEBSITES\_PORT"&lt;/span&gt;     &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"8080"&lt;/span&gt;
  &lt;span class="s2"&gt;"Cosmos\_\_Endpoint"&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;endpoint&lt;/span&gt;
  &lt;span class="s2"&gt;"Cosmos\_\_Key"&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cosmos&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;primary&lt;/span&gt;\&lt;span class="n"&gt;_key&lt;/span&gt;
  &lt;span class="s2"&gt;"Cosmos\_\_Database"&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_sql&lt;/span&gt;\&lt;span class="n"&gt;_database&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;
  &lt;span class="s2"&gt;"Cosmos\_\_Container"&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;azurerm&lt;/span&gt;\&lt;span class="n"&gt;_cosmosdb&lt;/span&gt;\&lt;span class="n"&gt;_sql&lt;/span&gt;\&lt;span class="n"&gt;_container&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;lugares&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;ASP.NET Core lee &lt;code&gt;Cosmos\_\_Endpoint&lt;/code&gt; como &lt;code&gt;Cosmos:Endpoint&lt;/code&gt;, así que la misma imagen funciona en local y en Azure. El estado de Terraform se guarda en una Storage Account de Azure, que el propio workflow crea si no existe.&lt;/p&gt;

&lt;h2&gt;
  
  
  El pipeline: 4 workflows de GitHub Actions
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Workflow&lt;/th&gt;
&lt;th&gt;Cuándo corre&lt;/th&gt;
&lt;th&gt;Qué hace&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;infra.yml&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;push en &lt;code&gt;infra/&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;terraform init&lt;/code&gt;, &lt;code&gt;plan&lt;/code&gt; y &lt;code&gt;apply&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;deploydb.yml&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;cuando &lt;code&gt;infra.yml&lt;/code&gt; termina bien&lt;/td&gt;
&lt;td&gt;carga &lt;code&gt;data/lugares.json&lt;/code&gt; con el SDK de Python&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;buildimage.yml&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;push en el código o el Dockerfile&lt;/td&gt;
&lt;td&gt;construye la imagen y la publica en ghcr.io&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;deployimage.yml&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;cuando &lt;code&gt;buildimage.yml&lt;/code&gt; termina bien&lt;/td&gt;
&lt;td&gt;despliega la imagen en App Service y prueba la URL&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Los workflows se encadenan con el evento &lt;code&gt;workflow\_run&lt;/code&gt;. Por ejemplo, la carga de datos espera a la infraestructura:&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;on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;workflow\_run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;workflows&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;\[ "Infraestructura (Terraform)" ]&lt;/span&gt;
    &lt;span class="na"&gt;types&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;\[ completed ]&lt;/span&gt;
    &lt;span class="na"&gt;branches&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;\[ "main" ]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Azure exige verificación en dos pasos (MFA) para iniciar sesión con usuario y contraseña, así que los workflows usan un &lt;strong&gt;service principal&lt;/strong&gt; con rol Contributor. Sus datos, junto con un token de GitHub de solo lectura para descargar la imagen, están guardados como &lt;strong&gt;secrets&lt;/strong&gt; del repositorio; los creé con &lt;code&gt;gh secret set&lt;/code&gt; para no copiarlos a mano.&lt;/p&gt;

&lt;p&gt;La carga de datos usa &lt;code&gt;upsert&lt;/code&gt;, así que se puede repetir sin duplicar nada:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;lugar&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;lugares&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;container&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;upsert&lt;/span&gt;\&lt;span class="nf"&gt;_item&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;lugar&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Problemas que encontré y cómo los resolví
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;La capa gratuita de Cosmos DB ya estaba usada.&lt;/strong&gt; Azure permite solo una cuenta gratuita por suscripción y ya tenía una de otro proyecto. Crear otra cuenta se iba a cobrar. La solución fue que Terraform lea esa cuenta con un &lt;code&gt;data source&lt;/code&gt; y cree dentro una base nueva de 400 RU/s. La otra base usaba 400, así que el total queda en 800 de los 1000 RU/s gratis.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Región bloqueada.&lt;/strong&gt; La suscripción Azure for Students solo deja desplegar en algunas regiones, así que todo va en &lt;code&gt;westus3&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El primer despliegue falló&lt;/strong&gt; con &lt;code&gt;Resource app-tacnago-geraldzvallos of type Microsoft.Web/Sites doesn't exist&lt;/code&gt;. La Web App se acababa de crear y la acción de despliegue todavía no la veía. Volví a lanzar el job y agregué una espera de 60 segundos después de detectar la Web App.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La carga de datos corrió antes que la infraestructura.&lt;/strong&gt; En el primer push, &lt;code&gt;deploydb.yml&lt;/code&gt; también se disparó por los cambios en &lt;code&gt;data/&lt;/code&gt; y falló porque la base todavía no existía. La ejecución encadenada a &lt;code&gt;infra.yml&lt;/code&gt; sí funcionó.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Resultado
&lt;/h2&gt;

&lt;p&gt;La app quedó publicada en &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net&lt;/a&gt; y se actualiza sola con cada push. Se puede filtrar por categoría (la consulta va a una sola partición), buscar por etiqueta, agregar lugares y ver el costo de cada operación en RU. La API también se puede probar desde Swagger: &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net/swagger" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net/swagger&lt;/a&gt;&lt;/p&gt;

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

&lt;ul&gt;
&lt;li&gt;Con Terraform y GitHub Actions, la infraestructura y el despliegue quedan en el repositorio y se repiten igual cada vez.&lt;/li&gt;
&lt;li&gt;La capa gratuita de Cosmos DB alcanza de sobra para una app pequeña, pero hay que vigilar el total de RU/s de la cuenta.&lt;/li&gt;
&lt;li&gt;Encadenar workflows con &lt;code&gt;workflow\_run&lt;/code&gt; ordena el proceso, pero hay que tener en cuenta los tiempos de Azure al crear recursos nuevos.&lt;/li&gt;
&lt;/ul&gt;

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

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;App publicada:&lt;/strong&gt; &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;API (Swagger):&lt;/strong&gt; &lt;a href="https://app-tacnago-geraldzvallos.azurewebsites.net/swagger" rel="noopener noreferrer"&gt;https://app-tacnago-geraldzvallos.azurewebsites.net/swagger&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Despliegue automatizado (GitHub Actions):&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/tacnago-cosmosdb/actions" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/tacnago-cosmosdb/actions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Video (grabado con Kevin):&lt;/strong&gt; &lt;a href="https://youtu.be/ofNwCJyyc8I" rel="noopener noreferrer"&gt;https://youtu.be/ofNwCJyyc8I&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>azure</category>
      <category>nosql</category>
      <category>terraform</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Pruebas de carga de una API .NET con k6 y GitHub Actions</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Sat, 14 Nov 2026 02:30:59 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/pruebas-de-carga-de-una-api-net-con-k6-y-github-actions-hpf</link>
      <guid>https://dev.to/gerald_deybizevallospin/pruebas-de-carga-de-una-api-net-con-k6-y-github-actions-hpf</guid>
      <description>&lt;h2&gt;
  
  
  Introducción
&lt;/h2&gt;

&lt;p&gt;Que una API responda bien a &lt;strong&gt;un&lt;/strong&gt; usuario no garantiza que aguante a &lt;strong&gt;muchos&lt;/strong&gt; al mismo tiempo. Para eso existen las &lt;strong&gt;pruebas de carga&lt;/strong&gt;: simulan usuarios simultáneos y miden tiempos de respuesta y errores.&lt;/p&gt;

&lt;p&gt;En este artículo uso &lt;strong&gt;k6&lt;/strong&gt;, una herramienta open source de Grafana Labs, para hacer una prueba de carga a una API REST en .NET 8. La prueba se ejecuta sola en GitHub Actions en cada cambio y el reporte se publica en la nube con GitHub Pages.&lt;/p&gt;

&lt;h2&gt;
  
  
  ¿Por qué k6?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Las pruebas se escriben en &lt;strong&gt;JavaScript&lt;/strong&gt;, así que son fáciles de leer y versionar junto al código.&lt;/li&gt;
&lt;li&gt;Es un solo binario, rápido y liviano: corre sin problema dentro de un runner de CI.&lt;/li&gt;
&lt;li&gt;Permite definir &lt;strong&gt;thresholds&lt;/strong&gt; (umbrales): si el rendimiento no cumple, k6 termina con error y el pipeline falla.&lt;/li&gt;
&lt;li&gt;Genera un &lt;strong&gt;dashboard web en HTML&lt;/strong&gt; con gráficos de la ejecución.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  La API y el repositorio público
&lt;/h2&gt;

&lt;p&gt;La aplicación es &lt;strong&gt;Banco API&lt;/strong&gt;, una Minimal API en .NET 8 con endpoints para listar, crear, depositar, retirar y eliminar cuentas bancarias (datos en memoria).&lt;/p&gt;

&lt;p&gt;Repositorio público del equipo: &lt;a href="https://github.com/viccarretero/banco-api-pruebas" rel="noopener noreferrer"&gt;github.com/viccarretero/banco-api-pruebas&lt;/a&gt;. Las pruebas funcionales de la misma API se hacen con &lt;strong&gt;Newman&lt;/strong&gt;; eso lo explica mi compañero Victor Carretero en su artículo.&lt;/p&gt;

&lt;h2&gt;
  
  
  El script de carga
&lt;/h2&gt;

&lt;p&gt;El archivo &lt;code&gt;tests/k6/carga.js&lt;/code&gt; define cómo crece la carga y qué se considera aceptable:&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;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;options&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;stages&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;duration&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'30s'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;20&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// subida: de 0 a 20 usuarios&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;duration&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'1m'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;20&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;// carga sostenida: 20 usuarios&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;duration&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'15s'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;// bajada&lt;/span&gt;
  &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;thresholds&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;http&lt;/span&gt;\&lt;span class="n"&gt;_req&lt;/span&gt;\&lt;span class="n"&gt;_duration&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; \&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s1"&gt;'p(95)&amp;lt;500'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// el 95 % de las peticiones en menos de 500 ms&lt;/span&gt;
    &lt;span class="n"&gt;http&lt;/span&gt;\&lt;span class="n"&gt;_req&lt;/span&gt;\&lt;span class="n"&gt;_failed&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; \&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s1"&gt;'rate&amp;lt;0.01'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;   &lt;span class="c1"&gt;// menos del 1 % de errores&lt;/span&gt;
    &lt;span class="n"&gt;checks&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; \&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s1"&gt;'rate&amp;gt;0.99'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;            &lt;span class="c1"&gt;// más del 99 % de validaciones correctas&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;Cada &lt;strong&gt;usuario virtual (VU)&lt;/strong&gt; repite un flujo realista dividido en dos grupos: consultar cuentas y hacer operaciones. Con &lt;code&gt;check&lt;/code&gt; se valida que cada respuesta sea correcta, no solo rápida:&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="nf"&gt;group&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'Operaciones'&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="o"&gt;=&amp;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;nueva&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;post&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sb"&gt;`${BASE\_URL}/api/cuentas`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nb"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;stringify&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;titular&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sb"&gt;`Usuario ${\_\_VU}-${\_\_ITER}`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;saldoInicial&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;100&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="nb"&gt;JSON&lt;/span&gt;\&lt;span class="n"&gt;_HEADERS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nf"&gt;check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;nueva&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="s1"&gt;'crear: status 201'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="mi"&gt;201&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;id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;nueva&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'id'&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;deposito&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;post&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sb"&gt;`${BASE\_URL}/api/cuentas/${id}/depositos`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;stringify&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;monto&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;50&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="nb"&gt;JSON&lt;/span&gt;\&lt;span class="n"&gt;_HEADERS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nf"&gt;check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;deposito&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="s1"&gt;'depositar: saldo 150'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'saldo'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="mi"&gt;150&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;retiro&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;post&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sb"&gt;`${BASE\_URL}/api/cuentas/${id}/retiros`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;stringify&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;monto&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;30&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="nb"&gt;JSON&lt;/span&gt;\&lt;span class="n"&gt;_HEADERS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nf"&gt;check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;retiro&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="s1"&gt;'retirar: saldo 120'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'saldo'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="mi"&gt;120&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="p"&gt;;&lt;/span&gt;
&lt;span class="nf"&gt;sleep&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Así cada usuario crea su propia cuenta, deposita 50 y retira 30, y se comprueba que el saldo final sea exacto aunque haya 20 usuarios operando a la vez.&lt;/p&gt;

&lt;h2&gt;
  
  
  Automatización con GitHub Actions
&lt;/h2&gt;

&lt;p&gt;En el workflow &lt;code&gt;.github/workflows/pruebas-api.yml&lt;/code&gt;, el job de k6 levanta la API dentro del runner, instala k6 con la acción oficial de Grafana y ejecuta el script exportando el dashboard HTML:&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;Instalar k6&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;grafana/setup-k6-action@v1&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;Ejecutar la prueba de carga&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;BASE\_URL&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http://localhost:5000&lt;/span&gt;
    &lt;span class="na"&gt;K6\_WEB\_DASHBOARD&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'true'&lt;/span&gt;
    &lt;span class="na"&gt;K6\_WEB\_DASHBOARD\_EXPORT&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;site/k6/index.html&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;mkdir -p site/k6&lt;/span&gt;
    &lt;span class="s"&gt;k6 run --summary-export=site/k6/resumen.json tests/k6/carga.js&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El job de k6 corre en paralelo con el de Newman, y al final un último job publica ambos reportes en GitHub Pages.&lt;/p&gt;

&lt;h2&gt;
  
  
  Resultados y publicación en la nube
&lt;/h2&gt;

&lt;p&gt;Reporte publicado: &lt;a href="https://viccarretero.github.io/banco-api-pruebas/k6/" rel="noopener noreferrer"&gt;viccarretero.github.io/banco-api-pruebas/k6&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;En la primera ejecución (1 minuto 45 segundos de prueba):&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;Valor&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Usuarios virtuales (máximo)&lt;/td&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Peticiones HTTP&lt;/td&gt;
&lt;td&gt;8 315 (78,9 por segundo)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Iteraciones completas&lt;/td&gt;
&lt;td&gt;1 663&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo de respuesta promedio&lt;/td&gt;
&lt;td&gt;0,29 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Percentil 95 (p95)&lt;/td&gt;
&lt;td&gt;0,95 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo máximo&lt;/td&gt;
&lt;td&gt;23,1 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Peticiones fallidas&lt;/td&gt;
&lt;td&gt;0 %&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Checks&lt;/td&gt;
&lt;td&gt;14 967 correctos, 0 fallidos&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Los tres thresholds se cumplieron con mucho margen: el p95 quedó en menos de 1 ms frente al límite de 500 ms. Es un resultado esperado para una API con datos en memoria; con una base de datos real los tiempos serían mayores, y ahí es donde la prueba de carga se vuelve más útil para detectar cuellos de botella.&lt;/p&gt;

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

&lt;p&gt;k6 permite tratar el rendimiento como un requisito más: se escribe en código, se versiona y se valida automáticamente en cada cambio. Gracias a los thresholds, si un cambio vuelve lenta la API, el pipeline lo detecta antes de publicar. Junto con las pruebas funcionales de Newman, el proyecto cubre las dos preguntas clave: si la API hace lo correcto y si lo sigue haciendo bajo carga.&lt;/p&gt;

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

&lt;ul&gt;
&lt;li&gt;Repositorio: &lt;a href="https://github.com/viccarretero/banco-api-pruebas" rel="noopener noreferrer"&gt;github.com/viccarretero/banco-api-pruebas&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Reportes en GitHub Pages: &lt;a href="https://viccarretero.github.io/banco-api-pruebas/" rel="noopener noreferrer"&gt;viccarretero.github.io/banco-api-pruebas&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Ejecución del pipeline: &lt;a href="https://github.com/viccarretero/banco-api-pruebas/actions/runs/43533654123" rel="noopener noreferrer"&gt;GitHub Actions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Video: &lt;a href="https://youtu.be/blr4M__giUk" rel="noopener noreferrer"&gt;https://youtu.be/blr4M__giUk&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Artículo complementario sobre Newman (Victor Carretero): &lt;a href="https://dev.to/viccarretero/pruebas-funcionales-de-una-api-net-con-newman-y-github-actions-33pm"&gt;https://dev.to/viccarretero/pruebas-funcionales-de-una-api-net-con-newman-y-github-actions-33pm&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;&lt;a href="https://grafana.com/docs/k6/latest/" rel="noopener noreferrer"&gt;Documentación de k6&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Gerald Zevallos — Calidad y Pruebas de Software, Universidad Privada de Tacna.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>testing</category>
      <category>performance</category>
      <category>k6</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Escaneo de dependencias e imágenes Docker de una API .NET con Grype</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Fri, 13 Nov 2026 20:30:11 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/escaneo-de-dependencias-e-imagenes-docker-de-una-api-net-con-grype-520m</link>
      <guid>https://dev.to/gerald_deybizevallospin/escaneo-de-dependencias-e-imagenes-docker-de-una-api-net-con-grype-520m</guid>
      <description>&lt;h2&gt;
  
  
  Introducción
&lt;/h2&gt;

&lt;p&gt;En este artículo uso &lt;strong&gt;Grype&lt;/strong&gt;, de Anchore, para encontrar vulnerabilidades conocidas (CVE) en las dependencias NuGet y en la imagen Docker de una API .NET 8, todo automatizado con GitHub Actions.&lt;/p&gt;

&lt;p&gt;La mayor parte del código de una aplicación moderna no lo escribimos nosotros: viene de librerías y de la imagen base del contenedor. El &lt;strong&gt;análisis de composición de software (SCA)&lt;/strong&gt; revisa esas piezas contra bases de datos de vulnerabilidades públicas.&lt;/p&gt;

&lt;p&gt;Elegí Grype porque está en la &lt;a href="https://owasp.org/www-community/Vulnerability_Scanning_Tools" rel="noopener noreferrer"&gt;lista de herramientas de escaneo de vulnerabilidades de OWASP&lt;/a&gt;, es gratuito y de código abierto, escanea tanto carpetas como imágenes Docker, y exporta resultados en &lt;strong&gt;SARIF&lt;/strong&gt; para GitHub. Este trabajo complementa el de mi compañero Victor Carretero, que analiza el código fuente con DevSkim en el mismo pipeline.&lt;/p&gt;

&lt;h2&gt;
  
  
  La aplicación y el repositorio público
&lt;/h2&gt;

&lt;p&gt;La aplicación es &lt;strong&gt;Banco API&lt;/strong&gt;, una Minimal API en .NET 8 empaquetada en Docker. A propósito usa &lt;code&gt;Newtonsoft.Json 12.0.1&lt;/code&gt;, una versión afectada por &lt;strong&gt;CVE-2024-21907&lt;/strong&gt; (denegación de servicio con JSON profundamente anidado), para que Grype tenga qué detectar.&lt;/p&gt;

&lt;p&gt;Repositorio público del equipo: &lt;a href="https://github.com/viccarretero/banco-api-vulnerabilidades" rel="noopener noreferrer"&gt;github.com/viccarretero/banco-api-vulnerabilidades&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;La dependencia vulnerable en &lt;code&gt;BancoApi.csproj&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight xml"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;PackageReference&lt;/span&gt; &lt;span class="na"&gt;Include&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Newtonsoft.Json"&lt;/span&gt; &lt;span class="na"&gt;Version&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"12.0.1"&lt;/span&gt; &lt;span class="nt"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El &lt;code&gt;Dockerfile&lt;/code&gt; compila en dos etapas, así la imagen final solo lleva el runtime de ASP.NET y la app publicada:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="k"&gt;FROM&lt;/span&gt; mcr.microsoft.com/dotnet/sdk:8.0 AS build
&lt;span class="k"&gt;WORKDIR&lt;/span&gt; /src
&lt;span class="k"&gt;COPY&lt;/span&gt; src/BancoApi/ ./
&lt;span class="k"&gt;RUN&lt;/span&gt; dotnet publish -c Release -o /app

&lt;span class="k"&gt;FROM&lt;/span&gt; mcr.microsoft.com/dotnet/aspnet:8.0
&lt;span class="k"&gt;WORKDIR&lt;/span&gt; /app
&lt;span class="k"&gt;COPY&lt;/span&gt; --from=build /app .
&lt;span class="k"&gt;ENTRYPOINT&lt;/span&gt; &lt;span class="o"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"dotnet"&lt;/span&gt;, &lt;span class="s2"&gt;"BancoApi.dll"&lt;/span&gt;&lt;span class="o"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Grype escanea esa imagen completa: los paquetes del sistema operativo de la imagen base y las librerías .NET que aparecen en el archivo &lt;code&gt;BancoApi.deps.json&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Automatización con GitHub Actions
&lt;/h2&gt;

&lt;p&gt;En cada &lt;code&gt;push&lt;/code&gt; o &lt;code&gt;pull request&lt;/code&gt; a &lt;code&gt;main&lt;/code&gt;, el workflow &lt;code&gt;.github/workflows/seguridad.yml&lt;/code&gt; construye la imagen y la escanea con Grype, sin pasos manuales:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;build&lt;/strong&gt;: compila la API con .NET 8.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;grype&lt;/strong&gt;: construye la imagen Docker, la escanea con la acción oficial &lt;code&gt;anchore/scan-action&lt;/code&gt; y sube el SARIF a &lt;em&gt;GitHub Code Scanning&lt;/em&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;publicar&lt;/strong&gt;: junta el reporte de Grype con el de DevSkim y los despliega en GitHub Pages.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;El job de Grype:&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;Construir imagen Docker&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;docker build -t banco-api:${{ github.sha }} .&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;Ejecutar Grype&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;scan&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;anchore/scan-action@v6&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;image&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;banco-api:${{ github.sha }}&lt;/span&gt;
    &lt;span class="na"&gt;fail-build&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;output-format&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;sarif&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;Publicar hallazgos en GitHub Code Scanning&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;github/codeql-action/upload-sarif@v3&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;sarif_file&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ steps.scan.outputs.sarif }}&lt;/span&gt;
    &lt;span class="na"&gt;category&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;grype&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Con &lt;code&gt;fail-build: false&lt;/code&gt; el pipeline reporta sin bloquear el despliegue; en un proyecto real se cambia a &lt;code&gt;true&lt;/code&gt; con &lt;code&gt;severity-cutoff: high&lt;/code&gt; para frenar los cambios que introduzcan vulnerabilidades graves. En local basta con:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;docker build -t banco-api .
grype banco-api
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Resultados y publicación en la nube
&lt;/h2&gt;

&lt;p&gt;Los hallazgos de Grype quedan en la pestaña &lt;strong&gt;Security → Code scanning&lt;/strong&gt; del repositorio y en un reporte HTML público en &lt;strong&gt;GitHub Pages&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Reporte publicado: &lt;a href="https://viccarretero.github.io/banco-api-vulnerabilidades/grype/" rel="noopener noreferrer"&gt;viccarretero.github.io/banco-api-vulnerabilidades/grype&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;En la primera ejecución, Grype encontró &lt;strong&gt;226 vulnerabilidades&lt;/strong&gt; en la imagen: 52 de severidad alta o crítica, 80 media y 94 baja. Casi todas vienen de la imagen base, no del código del equipo.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Origen&lt;/th&gt;
&lt;th&gt;Ejemplo&lt;/th&gt;
&lt;th&gt;Severidad&lt;/th&gt;
&lt;th&gt;Riesgo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Paquete NuGet (&lt;code&gt;BancoApi.deps.json&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;Newtonsoft.Json 12.0.1&lt;/code&gt; — GHSA-5crp-9r3c-p9vr / CVE-2024-21907&lt;/td&gt;
&lt;td&gt;Alta&lt;/td&gt;
&lt;td&gt;Un JSON muy anidado puede tumbar el servicio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Imagen base Debian (&lt;code&gt;aspnet:8.0&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;libtasn1-6&lt;/code&gt; — CVE-2025-13151&lt;/td&gt;
&lt;td&gt;Alta&lt;/td&gt;
&lt;td&gt;Falla en una librería del sistema que la app no controla&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Imagen base Debian (&lt;code&gt;aspnet:8.0&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;libgnutls30&lt;/code&gt; — CVE-2011-3389&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;td&gt;CVE antiguo sin corrección disponible en la distribución&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Cada hallazgo indica el paquete, la versión instalada, la versión que lo corrige y el enlace al CVE.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cómo corregir las vulnerabilidades
&lt;/h2&gt;

&lt;p&gt;La corrección en SCA casi siempre es actualizar: subir la librería a la versión parcheada y reconstruir la imagen.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight xml"&gt;&lt;code&gt;&lt;span class="c"&gt;&amp;lt;!-- Newtonsoft.Json 13.0.1 o superior corrige CVE-2024-21907 --&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;PackageReference&lt;/span&gt; &lt;span class="na"&gt;Include&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Newtonsoft.Json"&lt;/span&gt; &lt;span class="na"&gt;Version&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"13.0.3"&lt;/span&gt; &lt;span class="nt"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="c"&gt;# Imagen base más pequeña = menos paquetes y menos CVE&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; mcr.microsoft.com/dotnet/aspnet:8.0-alpine
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Tras el &lt;code&gt;push&lt;/code&gt;, el pipeline vuelve a construir y escanear, y el reporte en Pages muestra menos hallazgos. Si un CVE no aplica al proyecto, se puede ignorar de forma documentada en un archivo &lt;code&gt;.grype.yaml&lt;/code&gt;.&lt;/p&gt;

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

&lt;p&gt;Grype cubre lo que el análisis de código no ve: las vulnerabilidades heredadas de librerías y de la imagen base. Junto con DevSkim (SAST), el equipo revisa en cada cambio tanto el código propio como el de terceros, y publica los resultados sin intervención manual.&lt;/p&gt;

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

&lt;ul&gt;
&lt;li&gt;Repositorio: &lt;a href="https://github.com/viccarretero/banco-api-vulnerabilidades" rel="noopener noreferrer"&gt;github.com/viccarretero/banco-api-vulnerabilidades&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Reportes en GitHub Pages: &lt;a href="https://viccarretero.github.io/banco-api-vulnerabilidades/" rel="noopener noreferrer"&gt;viccarretero.github.io/banco-api-vulnerabilidades&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Ejecución del pipeline: &lt;a href="https://github.com/viccarretero/banco-api-vulnerabilidades/actions/runs/43496593984" rel="noopener noreferrer"&gt;GitHub Actions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Video: &lt;a href="https://youtu.be/4PljrMzZLM0" rel="noopener noreferrer"&gt;https://youtu.be/4PljrMzZLM0&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Artículo complementario sobre DevSkim (Victor Carretero): &lt;a href="https://dev.to/viccarretero/escaneo-de-vulnerabilidades-en-net-con-devskim-y-github-actions-4e06"&gt;Escaneo de vulnerabilidades en .NET con DevSkim y GitHub Actions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/anchore/grype" rel="noopener noreferrer"&gt;Grype en GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://owasp.org/www-community/Vulnerability_Scanning_Tools" rel="noopener noreferrer"&gt;Herramientas de escaneo de vulnerabilidades — OWASP&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Gerald Deybi Zevallos Pinto — Calidad y Pruebas de Software, Universidad Privada de Tacna.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>dotnet</category>
      <category>docker</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Backups en la nube sin dramas</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Sun, 04 Oct 2026 04:24:33 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/backups-en-la-nube-sin-dramas-56ap</link>
      <guid>https://dev.to/gerald_deybizevallospin/backups-en-la-nube-sin-dramas-56ap</guid>
      <description>&lt;p&gt;&lt;em&gt;Cómo protegemos SQLite y Oracle en un despliegue automatizado en Azure&lt;/em&gt;&lt;/p&gt;

&lt;h1&gt;
  
  
  1. Introducción: backups, RPO, RTO y qué motores usamos
&lt;/h1&gt;

&lt;p&gt;Un backup que nunca se restauró es una esperanza, no un plan. Antes de tocar un solo comando, conviene fijar dos números:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;RPO (Recovery Point Objective):&lt;/strong&gt; cuántos datos estamos dispuestos a perder, medido en tiempo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;RTO (Recovery Time Objective):&lt;/strong&gt; cuánto tiempo podemos tardar en volver a operar.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Nuestro caso de estudio es un &lt;strong&gt;Framework de Pruebas SQL&lt;/strong&gt; hecho con FastAPI. Permite definir casos de prueba, agruparlos en suites, ejecutarlos contra Oracle y guardar un historial de resultados (PASS, FAIL o ERROR). Para dejar claro el alcance: &lt;strong&gt;trabajamos con SQLite y Oracle Free, y no usamos MS SQL Server&lt;/strong&gt;. Este artículo no lo cubre.&lt;/p&gt;

&lt;p&gt;SQLite guarda los metadatos de la aplicación: proyectos, perfiles de conexión, casos, suites e historial. Oracle es la base &lt;em&gt;objetivo&lt;/em&gt; donde corren las pruebas. Esa diferencia de roles define toda nuestra estrategia.&lt;/p&gt;

&lt;h1&gt;
  
  
  2. Arquitectura: Azure, contenedores y volúmenes
&lt;/h1&gt;

&lt;p&gt;Todo corre en una máquina virtual de Azure con Docker Compose:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Caddy&lt;/strong&gt; recibe el tráfico y termina HTTPS.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Contenedor de la API&lt;/strong&gt; (framework_api_prod): FastAPI más el frontend. Escribe en SQLite.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Contenedor de Oracle Free&lt;/strong&gt; (framework_oracle_prod): base objetivo de la demostración.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Volúmenes persistentes&lt;/strong&gt; para SQLite y para oracle_data.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Los contenedores son desechables y los volúmenes no. El código y las imágenes se reconstruyen en minutos, pero el historial de ejecuciones solo existe en el volumen. Por eso &lt;strong&gt;el volumen es el activo que hay que proteger&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Hay otra decisión de diseño que ayuda. Nuestros perfiles de conexión &lt;strong&gt;nunca almacenan la contraseña de Oracle&lt;/strong&gt;: se pide en el momento de probar o ejecutar. Así, un backup de SQLite no filtra credenciales de bases externas. Sí contiene texto SQL y resultados esperados, así que lo tratamos como información potencialmente sensible y lo cifraríamos en reposo.&lt;/p&gt;

&lt;h1&gt;
  
  
  3. Backup de SQLite: frío y en caliente
&lt;/h1&gt;

&lt;h3&gt;
  
  
  Frío (con la aplicación detenida)
&lt;/h3&gt;

&lt;p&gt;Es el más simple y el más seguro:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;bash
docker compose stop api
&lt;span class="nb"&gt;cp&lt;/span&gt; /ruta/volumen/framework.db /backups/framework_&lt;span class="si"&gt;$(&lt;/span&gt;&lt;span class="nb"&gt;date&lt;/span&gt; &lt;span class="nt"&gt;-u&lt;/span&gt; +%Y%m%dT%H%M%SZ&lt;span class="si"&gt;)&lt;/span&gt;.db
docker compose start api
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El costo es una breve interrupción. Es aceptable en una ventana de mantenimiento, no como rutina diaria.&lt;/p&gt;

&lt;h3&gt;
  
  
  En caliente (con la aplicación en uso)
&lt;/h3&gt;

&lt;p&gt;Un cp sobre una base activa puede producir una copia inconsistente. Si hay modo WAL, copiar solo el .db deja fuera transacciones recientes. Lo correcto es usar la &lt;strong&gt;API de backup de SQLite&lt;/strong&gt;, que genera una copia coherente mientras la app sigue escribiendo. Usamos Python porque ya está en la imagen de la API:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;bash
docker &lt;span class="nb"&gt;exec&lt;/span&gt; &lt;span class="nt"&gt;-i&lt;/span&gt; framework_api_prod python - &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="no"&gt;PY&lt;/span&gt;&lt;span class="sh"&gt;'
import sqlite3
src = sqlite3.connect("/app/data/framework.db")      # ruta ilustrativa
dst = sqlite3.connect("/app/data/backups/snapshot.db")
with dst:
    src.backup(dst)
dst.close(); src.close()
&lt;/span&gt;&lt;span class="no"&gt;PY
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Después verificamos y comprimimos la copia antes de subirla:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;bash
sqlite3 snapshot.db &lt;span class="s2"&gt;"PRAGMA integrity_check;"&lt;/span&gt;   &lt;span class="c"&gt;# debe responder: ok&lt;/span&gt;
&lt;span class="nb"&gt;gzip&lt;/span&gt; &lt;span class="nt"&gt;-9&lt;/span&gt; snapshot.db
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Fuera de la VM
&lt;/h3&gt;

&lt;p&gt;Una copia en el mismo disco no sirve si se pierde la VM. La subimos a un almacenamiento separado, por ejemplo Azure Blob Storage con azcopy o az storage blob upload. Un cron o un timer de systemd la programa según el RPO acordado.&lt;/p&gt;

&lt;p&gt;Un detalle de honestidad técnica: los snapshots de disco de la VM suelen ser consistentes ante caída, no coherentes a nivel de aplicación. Son un complemento, no un reemplazo del backup lógico.&lt;/p&gt;

&lt;h1&gt;
  
  
  4. Backup lógico del contenedor de Oracle
&lt;/h1&gt;

&lt;p&gt;Aquí hay un matiz importante. En nuestro despliegue, Oracle Free contiene un esquema de pruebas que se crea con un script de inicialización (001_test_schema.sh). En parte es &lt;strong&gt;reproducible&lt;/strong&gt;, pero si los casos de prueba dependen de datos cargados después, necesitamos un backup lógico con &lt;strong&gt;Data Pump&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;bash
docker &lt;span class="nb"&gt;exec &lt;/span&gt;framework_oracle_prod bash &lt;span class="nt"&gt;-c&lt;/span&gt; &lt;span class="s1"&gt;'
  expdp userid="system@//localhost:1521/FREEPDB1" \
        schemas=ESQUEMA_PRUEBAS \
        directory=DATA_PUMP_DIR \
        dumpfile=pruebas_%U.dmp logfile=pruebas_exp.log'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Nombres de esquema y credenciales son ilustrativos. En la práctica usaríamos un parfile con permisos restringidos para no exponer contraseñas en la línea de comandos. El .dmp se copia fuera del contenedor y luego a almacenamiento externo, igual que SQLite. Como alternativa en frío, se detiene el contenedor y se empaqueta el volumen oracle_data.&lt;/p&gt;

&lt;p&gt;Una advertencia: &lt;strong&gt;Oracle Free no recibe soporte ni parches del fabricante&lt;/strong&gt;. Para producción real se usa una edición soportada, y la estrategia de backup se rediseña con las herramientas que ese licenciamiento permita.&lt;/p&gt;

&lt;h1&gt;
  
  
  5. Cómo la automatización acelera la recuperación
&lt;/h1&gt;

&lt;p&gt;Nuestro despliegue se actualiza con GitHub Actions. Como el código y la configuración viven en el repositorio, ante un desastre &lt;strong&gt;no hay que reconstruir a mano la aplicación&lt;/strong&gt;. La receta es: nueva VM (o la misma), pipeline de despliegue y restaurar el volumen de datos.&lt;/p&gt;

&lt;p&gt;Un punto fuerte de integrar backups con CI/CD es &lt;strong&gt;respaldar antes de cada despliegue&lt;/strong&gt;, porque ahí se ejecutan las migraciones Alembic sobre SQLite, el momento más riesgoso:&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="s"&gt;yaml&lt;/span&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;Backup previo al despliegue&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ssh deploy@$VM "/opt/framework/scripts/backup_sqlite.sh"&lt;/span&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;Desplegar&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ssh deploy@$VM "cd /opt/framework &amp;amp;&amp;amp; docker compose pull &amp;amp;&amp;amp; docker compose up -d"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Este flujo es ilustrativo. Cada equipo lo adapta a sus secretos y rutas.&lt;/p&gt;

&lt;h1&gt;
  
  
  6. Conclusión
&lt;/h1&gt;

&lt;p&gt;Dos ideas resumen lo aprendido. Primero, &lt;strong&gt;separar lo reproducible de lo irremplazable&lt;/strong&gt;: el código se redespliega, los datos se restauran. Segundo, &lt;strong&gt;un backup vale lo que vale su restauración probada&lt;/strong&gt;. Nuestro siguiente paso es automatizar la copia consistente y ensayar restauraciones periódicas.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;🎥 Mira la demostración aquí:&lt;/strong&gt;   &lt;iframe src="https://www.youtube.com/embed/JM4jHQJt3Mg" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;💻 Repositorio:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/framework-pruebas-sql-publico" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/framework-pruebas-sql-publico&lt;/a&gt;&lt;/p&gt;

</description>
      <category>azure</category>
      <category>cloud</category>
      <category>database</category>
      <category>devops</category>
    </item>
    <item>
      <title>De git push a producción sin sorpresas: SAST con Bandit en un pipeline de GitHub Actions</title>
      <dc:creator>GERALD DEYBI ZEVALLOS PINTO</dc:creator>
      <pubDate>Sun, 04 Oct 2026 03:49:07 +0000</pubDate>
      <link>https://dev.to/gerald_deybizevallospin/de-git-push-a-produccion-sin-sorpresas-sast-con-bandit-en-un-pipeline-de-github-actions-1k69</link>
      <guid>https://dev.to/gerald_deybizevallospin/de-git-push-a-produccion-sin-sorpresas-sast-con-bandit-en-un-pipeline-de-github-actions-1k69</guid>
      <description>&lt;p&gt;&lt;em&gt;Cómo integramos análisis estático de seguridad en el despliegue continuo de una aplicación FastAPI + Oracle sobre Azure, y qué aprendimos al leer 467 hallazgos.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Introducción
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Qué construimos
&lt;/h3&gt;

&lt;p&gt;Somos dos estudiantes de Ingeniería de Sistemas de la Universidad Privada de Tacna y, para el curso de Calidad y Pruebas de Software, construimos un &lt;strong&gt;Framework de Pruebas de Base de Datos SQL&lt;/strong&gt;: una aplicación web para definir, ejecutar y registrar pruebas SQL sobre bases de datos Oracle. Es un prototipo académico, sin un cliente empresarial detrás, y justamente por eso quisimos tratarlo con las prácticas que aplicaríamos en un proyecto real.&lt;/p&gt;

&lt;p&gt;El problema es fácil de enunciar. Cuando se modifica una consulta o una operación sobre los datos, hay que comprobar que sigue entregando lo esperado; si esa comprobación queda como una ejecución aislada, después cuesta repetirla o compararla con una anterior. Nuestra aplicación reúne en un solo lugar la sentencia, la conexión, el resultado esperado y el registro de cada ejecución.&lt;/p&gt;

&lt;p&gt;Hoy permite:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Gestionar proyectos y perfiles de conexión&lt;/strong&gt; a Oracle. Un perfil guarda host, puerto, usuario y service name, pero &lt;strong&gt;nunca la contraseña&lt;/strong&gt;: se solicita solo al probar la conexión o ejecutar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Definir casos de prueba&lt;/strong&gt; con dos validaciones: ROW_COUNT (número de filas esperado) y EXISTS (una condición verdadera o falsa).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agrupar casos en suites&lt;/strong&gt; del mismo proyecto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ejecutar y clasificar&lt;/strong&gt; cada resultado como PASS, FAIL o ERROR.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Consultar el historial&lt;/strong&gt; por proyecto, suite, caso y estado, además de un dashboard con indicadores.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  La seguridad que la app ya trae por diseño
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Sesión con cookie HttpOnly, token firmado con HMAC-SHA256 y comparación en tiempo constante con secrets.compare_digest.&lt;/li&gt;
&lt;li&gt;Una política SQL aplicada en el backend: una sola sentencia por caso, DDL y TCL bloqueados y ROLLBACK obligatorio sobre todo DML.&lt;/li&gt;
&lt;li&gt;Reglas por ambiente: en TEST se admite DML con reversión; en STAGING además se exige confirmación explícita; en PRODUCTION solo se permite SELECT y las filas devueltas se ocultan.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Aun así, sabemos que ningún control es suficiente por sí solo. Un ROLLBACK no vuelve inocuo cualquier SQL (Oracle confirma de forma implícita al ejecutar DDL y admite transacciones autónomas), y sqlparse, la librería con la que reconocemos las sentencias, se describe a sí misma como un analizador, no como un validador. La seguridad tiene que ser por capas, y una de esas capas es mirar con lupa nuestro propio código.&lt;/p&gt;

&lt;h3&gt;
  
  
  Por qué integrar SAST en el desarrollo
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;SAST&lt;/strong&gt; (&lt;em&gt;Static Application Security Testing&lt;/em&gt;) analiza el código fuente sin ejecutarlo. Su gran ventaja es el momento: detecta patrones inseguros (credenciales escritas en el código, excepciones silenciadas, llamadas a procesos del sistema) en minutos y antes del despliegue, cuando corregir todavía es barato.&lt;/p&gt;

&lt;p&gt;Elegimos &lt;strong&gt;Bandit&lt;/strong&gt; porque está hecho específicamente para Python: recorre el árbol sintáctico (AST) de cada archivo, aplica reglas identificadas con códigos como B105 o B603, asocia cada hallazgo a un CWE y entrega un reporte en JSON fácil de procesar. OWASP lo incluye en su catálogo de herramientas de análisis de código fuente (aclarando que no avala ninguna en particular). Y conocemos su límite: Bandit encuentra patrones; no entiende la lógica de negocio ni revisa las dependencias.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Arquitectura del despliegue
&lt;/h2&gt;

&lt;p&gt;Todo corre en una &lt;strong&gt;máquina virtual de Microsoft Azure&lt;/strong&gt; con Docker Compose. Hacia afuera solo se exponen los puertos 80 y 443; la API y la base Oracle se comunican por la red interna de los contenedores.&lt;/p&gt;

&lt;p&gt;Usuario ──HTTPS──▶ Caddy (80/443) ──▶ Contenedor API (FastAPI + frontend)&lt;br&gt;&lt;br&gt;
│ │&lt;br&gt;&lt;br&gt;
▼ ▼&lt;br&gt;&lt;br&gt;
SQLite Oracle Free (contenedor)&lt;br&gt;&lt;br&gt;
(metadatos e (base objetivo de&lt;br&gt;&lt;br&gt;
historial) la demostración)&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Componente&lt;/th&gt;
&lt;th&gt;Rol&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Caddy&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Proxy inverso; termina HTTPS y enruta hacia la API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;FastAPI&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;API REST, autenticación, política SQL y motor de ejecución; sirve también la interfaz web&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;SQLite + Alembic&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Metadatos, casos, suites e historial, con migraciones versionadas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;python-oracledb&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Conexión a Oracle en modo Thin&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Oracle Free&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Base objetivo de la demostración&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;GitHub Actions&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Escaneo SAST y despliegue automático&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;ul&gt;
&lt;li&gt; &lt;strong&gt;Aplicación en la nube:&lt;/strong&gt; &lt;a href="https://frameworksql.sytes.net/login" rel="noopener noreferrer"&gt;https://frameworksql.sytes.net/login&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt; &lt;strong&gt;Repositorio público:&lt;/strong&gt; &lt;a href="https://github.com/Geraldzvallos/framework-pruebas-sql-publico" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/framework-pruebas-sql-publico&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Una aclaración honesta: Oracle Free sirve para la demostración, pero no cuenta con soporte ni parches del fabricante, así que en un entorno empresarial lo reemplazaríamos por una edición soportada.&lt;/p&gt;

&lt;p&gt;El flujo de entrega queda así:&lt;/p&gt;

&lt;p&gt;git push (main) ──▶ Job 1: SAST con Bandit ──¿pasa?──▶ Job 2: despliegue en la VM de Azure&lt;br&gt;&lt;br&gt;
│&lt;br&gt;&lt;br&gt;
└─ no ──▶ el pipeline se detiene y no se despliega&lt;/p&gt;
&lt;h2&gt;
  
  
  3. Implementación de la automatización
&lt;/h2&gt;
&lt;h3&gt;
  
  
  Paso 1: probar Bandit en local
&lt;/h3&gt;

&lt;p&gt;pip install bandit&lt;br&gt;&lt;br&gt;
bandit -r . -f json -o bandit-report.json&lt;/p&gt;

&lt;p&gt;-r recorre el repositorio de forma recursiva y -f json genera un reporte estructurado que luego podemos guardar como artefacto del pipeline o analizar con un script.&lt;/p&gt;
&lt;h3&gt;
  
  
  Paso 2: el workflow
&lt;/h3&gt;

&lt;p&gt;Esta es una versión simplificada de nuestro workflow de GitHub Actions:&lt;/p&gt;

&lt;p&gt;name: Security Scan and Deploy&lt;/p&gt;

&lt;p&gt;on:&lt;/p&gt;

&lt;p&gt;push:&lt;/p&gt;

&lt;p&gt;branches:&lt;/p&gt;

&lt;p&gt;- main&lt;/p&gt;

&lt;p&gt;jobs:&lt;/p&gt;

&lt;p&gt;security-scan:&lt;/p&gt;

&lt;p&gt;runs-on: ubuntu-latest&lt;/p&gt;

&lt;p&gt;steps:&lt;/p&gt;

&lt;p&gt;- name: Checkout code&lt;/p&gt;

&lt;p&gt;uses: actions/checkout@v4&lt;/p&gt;

&lt;p&gt;- name: Set up Python&lt;/p&gt;

&lt;p&gt;uses: actions/setup-python@v5&lt;/p&gt;

&lt;p&gt;with:&lt;/p&gt;

&lt;p&gt;python-version: '3.12'&lt;/p&gt;

&lt;p&gt;- name: Install Bandit (SAST Tool)&lt;/p&gt;

&lt;p&gt;run: pip install bandit&lt;/p&gt;

&lt;p&gt;- name: Run Security Scan&lt;/p&gt;

&lt;p&gt;run: bandit -r ./framework-pruebas-sql -f json -o bandit-report.json || true&lt;/p&gt;

&lt;p&gt;- name: Upload Security Report&lt;/p&gt;

&lt;p&gt;uses: actions/upload-artifact@v4&lt;/p&gt;

&lt;p&gt;with:&lt;/p&gt;

&lt;p&gt;name: sast-report&lt;/p&gt;

&lt;p&gt;path: bandit-report.json&lt;/p&gt;

&lt;p&gt;Las decisiones que más importan:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ejecución focalizada: En esta primera fase de CI/CD, priorizamos la ejecución de la herramienta SAST sobre nuestro directorio principal (./framework-pruebas-sql) usando el operador || true para asegurar que el pipeline no se rompa de inmediato y nos permita recoger los datos.&lt;/li&gt;
&lt;li&gt;Generación del artefacto: Usamos actions/upload-artifact@v4 para empaquetar el bandit-report.json. Esta es la decisión más útil, porque la plataforma guarda el reporte completo para que podamos descargarlo y analizar qué vulnerabilidades críticas existen antes de configurar el túnel SSH hacia la máquina de Azure.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;
  
  
  Paso 3: el alcance importa
&lt;/h3&gt;

&lt;p&gt;Nuestro primer escaneo apuntó a la raíz del repositorio (.), y eso incluyó la carpeta tests/. Como veremos en la siguiente sección, esa decisión multiplicó el ruido. Bandit permite fijar el alcance en pyproject.toml:&lt;/p&gt;

&lt;p&gt;[tool.bandit]&lt;br&gt;&lt;br&gt;
exclude_dirs = ['tests']&lt;/p&gt;

&lt;p&gt;pip install 'bandit[toml]'&lt;br&gt;&lt;br&gt;
bandit -c pyproject.toml -r .&lt;/p&gt;
&lt;h2&gt;
  
  
  4. Resultados del escaneo
&lt;/h2&gt;

&lt;p&gt;El reporte de nuestro pipeline (generado el 3 de octubre de 2026 con Bandit 1.9.4) analizó &lt;strong&gt;3 936 líneas de código&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;Valor&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Hallazgos totales&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;467&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Severidad alta&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Severidad media&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Severidad baja&lt;/td&gt;
&lt;td&gt;466&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Confianza alta / media&lt;/td&gt;
&lt;td&gt;427 / 40&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Regla&lt;/th&gt;
&lt;th&gt;Nombre&lt;/th&gt;
&lt;th&gt;Cantidad&lt;/th&gt;
&lt;th&gt;Severidad&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;B101&lt;/td&gt;
&lt;td&gt;assert_used&lt;/td&gt;
&lt;td&gt;410&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B105&lt;/td&gt;
&lt;td&gt;hardcoded_password_string&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B106&lt;/td&gt;
&lt;td&gt;hardcoded_password_funcarg&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B110&lt;/td&gt;
&lt;td&gt;try_except_pass&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B603&lt;/td&gt;
&lt;td&gt;subprocess_without_shell_equals_true&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B607&lt;/td&gt;
&lt;td&gt;start_process_with_partial_path&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B404&lt;/td&gt;
&lt;td&gt;blacklist (import de subprocess)&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Baja&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B310&lt;/td&gt;
&lt;td&gt;blacklist (urllib.urlopen)&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Media&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;h3&gt;
  
  
  El dato que cambia la lectura
&lt;/h3&gt;

&lt;p&gt;De los 467 hallazgos, &lt;strong&gt;461 (98,7 %) están dentro de tests/&lt;/strong&gt;. Solo 6 tocan otro código: 2 en app/engine/executor.py, 3 en una migración de Alembic y 1 en un script de validación. No hay ningún hallazgo de severidad alta.&lt;/p&gt;

&lt;p&gt;Eso no significa que lo demás se ignore; significa que hay que &lt;strong&gt;priorizar&lt;/strong&gt;. Estos son los hallazgos que pedíamos entender mejor.&lt;/p&gt;
&lt;h3&gt;
  
  
  B110: excepciones silenciadas (5 casos)
&lt;/h3&gt;

&lt;p&gt;Bandit marcó cinco bloques try/except: pass, dos de ellos en el motor de ejecución, app/engine/executor.py:&lt;/p&gt;

&lt;p&gt;try:&lt;br&gt;&lt;br&gt;
cursor.close()&lt;br&gt;&lt;br&gt;
except Exception:&lt;br&gt;&lt;br&gt;
pass&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué es un riesgo en producción:&lt;/strong&gt; un except Exception: pass convierte un fallo en silencio. Si el cierre de un cursor o de una conexión falla de forma repetida, nadie lo sabrá hasta que se agoten las conexiones disponibles, y entonces el síntoma aparecerá lejos de la causa. En un motor cuya promesa es ejecutar sin dejar rastro, la trazabilidad de los errores es parte del producto. (Los otros tres casos están en la migración 001, alrededor de drop_constraint: ahí un fallo ignorado puede dejar el esquema a medio camino sin avisar.)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cómo lo corregiríamos:&lt;/strong&gt; capturar la excepción específica del driver y dejar constancia.&lt;/p&gt;

&lt;p&gt;import logging&lt;br&gt;&lt;br&gt;
logger = logging.getLogger(_&lt;em&gt;name&lt;/em&gt;_)&lt;br&gt;&lt;br&gt;
&lt;br&gt;try:&lt;br&gt;&lt;br&gt;
cursor.close()&lt;br&gt;&lt;br&gt;
except oracledb.Error:&lt;br&gt;&lt;br&gt;
logger.warning('No se pudo cerrar el cursor', exc_info=True)&lt;/p&gt;
&lt;h3&gt;
  
  
  B310: urlopen sin validar el esquema (1 caso, severidad media)
&lt;/h3&gt;

&lt;p&gt;Es el único hallazgo de severidad media, y está en scripts/validar_flujo_oracle.py, que llama a la API con urllib.request.urlopen(req).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué es un riesgo:&lt;/strong&gt; urlopen acepta esquemas como file://. Si la URL llegara a ser controlable por un tercero, podría leerse un archivo local en lugar de hacer una petición web (CWE-22). En nuestro caso es un script interno, así que el riesgo real es bajo, pero la corrección cuesta dos líneas:&lt;/p&gt;

&lt;p&gt;from urllib.parse import urlparse&lt;br&gt;&lt;br&gt;
&lt;br&gt;if urlparse(url).scheme not in {'http', 'https'}:&lt;br&gt;&lt;br&gt;
raise ValueError('Solo se permiten URLs http o https')&lt;/p&gt;
&lt;h3&gt;
  
  
  B105 y B106: contraseñas escritas en el código (40 casos)
&lt;/h3&gt;

&lt;p&gt;Son los que más asustan. Bandit encontró 25 cadenas y 15 argumentos con aspecto de contraseña, por ejemplo:&lt;/p&gt;

&lt;p&gt;executor = TargetDatabaseExecutor(dsn='localhost/xe', user='user', password='secret_password')&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué es un riesgo en producción:&lt;/strong&gt; una credencial real escrita en el código termina en el historial de Git para siempre, y en un repositorio público queda expuesta a cualquiera (CWE-259). Es una de las fallas más comunes y más fáciles de explotar.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Pero aquí el contexto manda:&lt;/strong&gt; los 40 casos están en archivos de pruebas y son datos ficticios (secret_password, super_secret_password_999). Bandit no puede distinguir una credencial real de un valor de ejemplo; esa es la razón por la que siempre hay que revisar a mano. Lo correcto es declarar esos valores como constantes o &lt;em&gt;fixtures&lt;/em&gt; y, cuando sean ficticios, documentarlo con # nosec B105 y un comentario que explique por qué.&lt;/p&gt;
&lt;h3&gt;
  
  
  B603, B607 y B404: procesos del sistema (11 casos)
&lt;/h3&gt;

&lt;p&gt;Los tests lanzan Alembic mediante subprocess:&lt;/p&gt;

&lt;p&gt;subprocess.run(['alembic', 'upgrade', 'head'], env=env, check=True)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué es un riesgo en producción:&lt;/strong&gt; B603 invita a verificar que ninguna entrada no confiable llegue al comando (inyección de comandos, CWE-78); B607 advierte que se invoca un ejecutable solo por nombre, de modo que, si alguien manipula el PATH, podría ejecutarse otro programa. En nuestro caso los argumentos son constantes y no se usa shell=True, de modo que el riesgo es bajo, y el código vive en tests/. Aun así, una mejora simple es fijar el intérprete:&lt;/p&gt;

&lt;p&gt;import sys&lt;br&gt;&lt;br&gt;
subprocess.run([sys.executable, '-m', 'alembic', 'upgrade', 'head'], env=env, check=True)&lt;/p&gt;

&lt;p&gt;Conviene, además, verificar que tests/ no se copie a la imagen de producción (.dockerignore).&lt;/p&gt;
&lt;h3&gt;
  
  
  B101: los 410 assert (el ruido)
&lt;/h3&gt;

&lt;p&gt;Bandit avisa de que los assert desaparecen al ejecutar Python con -O, y eso sería grave si protegieran una regla de seguridad. En tests/ es el mecanismo normal de pytest. Son el 88 % del reporte y no aportan información accionable.&lt;/p&gt;
&lt;h3&gt;
  
  
  Resumen de priorización
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Prioridad&lt;/th&gt;
&lt;th&gt;Hallazgo&lt;/th&gt;
&lt;th&gt;Acción&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;B110 en executor.py&lt;/td&gt;
&lt;td&gt;Registrar el error y capturar oracledb.Error&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;B310 en el script de validación&lt;/td&gt;
&lt;td&gt;Validar el esquema de la URL&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;B110 en la migración&lt;/td&gt;
&lt;td&gt;Revisar si el fallo ignorado es intencional&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;B105/B106 en tests&lt;/td&gt;
&lt;td&gt;Constantes o fixtures; # nosec justificado&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;B603/B607/B404 en tests&lt;/td&gt;
&lt;td&gt;Usar sys.executable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;B101 en tests&lt;/td&gt;
&lt;td&gt;Excluir del escaneo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;h2&gt;
  
  
  5. Conclusión y aprendizajes
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Automatizar el escaneo cambia la conversación.&lt;/strong&gt; Con Bandit en cada push la seguridad dejó de ser una revisión final y pasó a ser parte del flujo normal.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El número de hallazgos no es el riesgo.&lt;/strong&gt; 467 hallazgos y cero de severidad alta es un resultado muy distinto de lo que sugiere el titular. Leer la severidad, la confianza y, sobre todo, la ubicación es lo que convierte un reporte en decisiones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bloquear por severidad, informar por todo lo demás.&lt;/strong&gt; Una puerta que falla por cualquier hallazgo bajo se termina desactivando; una que falla solo por severidad alta se respeta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Definir bien el alcance.&lt;/strong&gt; Escanear tests/ sin ajustes llenó el reporte de ruido. La alternativa razonable es que la puerta de seguridad revise el código de producción y que los tests se escaneen solo de forma informativa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SAST es una capa, no la defensa.&lt;/strong&gt; Bandit no revisa dependencias, no ve la lógica de negocio de nuestra política SQL y no sustituye pruebas negativas ni permisos mínimos en Oracle.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Próximos pasos:&lt;/strong&gt; corregir los B110 y el B310, auditar dependencias (por ejemplo, con pip-audit), fijar el alcance de Bandit en pyproject.toml y publicar los resultados en la pestaña de seguridad de GitHub.&lt;/p&gt;
&lt;h2&gt;
  
  
  6. Video demostrativo
&lt;/h2&gt;

&lt;p&gt;Mostramos el pipeline en acción, desde el push hasta el despliegue automático:   &lt;iframe src="https://www.youtube.com/embed/hDyOvQJL2pE" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Aplicación: &lt;a href="https://frameworksql.sytes.net/login" rel="noopener noreferrer"&gt;https://frameworksql.sytes.net/login&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Repositorio: &lt;a href="https://github.com/Geraldzvallos/framework-pruebas-sql-publico" rel="noopener noreferrer"&gt;https://github.com/Geraldzvallos/framework-pruebas-sql-publico&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cicd</category>
      <category>github</category>
      <category>python</category>
      <category>security</category>
    </item>
  </channel>
</rss>
