TL;DR — Una base de datos en la nube no debería crearse a mano. En este artículo describo cómo Terraform crea una base Apache Cassandra en DataStax Astra DB, un token de aplicación con mínimo privilegio, descarga el Secure Connect Bundle y crea el servicio web en Render; y cómo GitHub Actions prueba cada cambio contra un Cassandra 5.0 real, publica la imagen en GitHub Packages, la despliega y verifica que la URL pública corre el commit exacto.

🔗 Repositorio: https://github.com/keylalopezz/cassandra-astra-app
🌐 App publicada: https://pulso-tacna.onrender.com
🎥 Video (menos de 5 min): https://youtu.be/6Cq9YjIz8pg
✍️ Artículo complementario (modelado de datos en Cassandra): https://dev.to/keylalopezz/modelado-orientado-a-consultas-en-apache-cassandra-series-de-tiempo-con-particiones-ttl-y-40hj

Pulso Tacna en Render, conectada a Astra DB

1. El objetivo: cero clics en consolas

La app (Pulso Tacna) registra series de tiempo de estaciones meteorológicas en Apache Cassandra. El modelo de datos lo explica Keyla en su artículo; aquí me enfoco en otra pregunta: ¿cómo llega todo eso a la nube sin tocar una consola web?

Las reglas que me puse:

  1. Toda la infraestructura se describe en Terraform y vive en el repositorio.
  2. Todo cambio se prueba contra Cassandra real antes de publicarse.
  3. El despliegue termina solo cuando la URL pública responde con el commit nuevo.
  4. El repositorio es público: ningún secreto puede quedar expuesto, ni en el código ni en los artefactos.

2. Arquitectura

git push ──► GitHub Actions ─┬─ ci-cd.yml : pruebas (Cassandra 5.0) ─► imagen ghcr.io ─► deploy Render ─► verifica versión ├─ infra.yml : Terraform ─► Astra DB + token + bundle ─► Render Web Service └─ ingesta.yml: cada hora ─► POST /api/simular ─► nuevas lecturas en Astra DB 
Workflow Disparador Qué hace
ci-cd.yml push en src/, tests/, Dockerfile Pruebas → imagen → despliegue → verificación
infra.yml push en infra/ terraform plan y apply (estado cifrado)
ingesta.yml cron cada hora Envía lecturas y mantiene activa la base serverless

3. Terraform: Astra DB, un token propio y el bundle

El proveedor oficial datastax/astra crea la base serverless con su keyspace:

resource "astra_database" "pulso" { name = "pulso-tacna" keyspace = "pulso" cloud_provider = "aws" regions = ["us-east-2"] db_type = "vector" # tipo serverless actual; admite CQL completo } 

El token que usa Terraform es de administrador de la organización, pero la app no debería tenerlo. Por eso Terraform crea un token propio con el rol Database Administrator, buscando el ID del rol por su nombre:

data "astra_roles" "roles" {} locals { rol_db_admin = one([for r in data.astra_roles.roles.results : r.role_id if r.role_name == "Database Administrator"]) } resource "astra_token" "app" { roles = [local.rol_db_admin] } 

El driver de Cassandra necesita el Secure Connect Bundle, un zip con el host y los certificados mTLS. Astra entrega una URL firmada que caduca; con el proveedor http lo descargo y lo paso a Render en base64:

data "astra_secure_connect_bundle_url" "scb" { database_id = astra_database.pulso.id } data "http" "scb" { url = data.astra_secure_connect_bundle_url.scb.secure_bundles[0].url } # en el Web Service de Render: "ASTRA_SCB_B64" = { value = data.http.scb.response_body_base64 } 

La app decodifica esa variable a un archivo temporal al arrancar. Como la URL firmada cambia en cada plan, el servicio ignora ese cambio para no redesplegarse sin motivo:

lifecycle { ignore_changes = [env_vars["ASTRA_SCB_B64"], runtime_source] } 

runtime_source también se ignora porque la imagen la cambia el pipeline, no Terraform: así ambos no se pisan.

Resultado de la primera ejecución: la base serverless tardó 7 min 23 s en quedar activa, el servicio de Render 28 s, y Apply complete! Resources: 4 added.

terraform apply en GitHub Actions

La base pulso-tacna activa en Astra DB

4. Estado de Terraform cifrado en un repositorio público

El estado de Terraform contiene el secreto del token de la app. Lo guardo como artefacto de Actions para reutilizarlo, pero en un repositorio público cualquier usuario autenticado puede descargar los artefactos. Por eso se cifra con AES-256 antes de subirlo:

- name: Cifrar el estado con AES-256 run: | gpg --batch --yes --pinentry-mode loopback --passphrase "$TF_STATE_PASSPHRASE" \ --symmetric --cipher-algo AES256 --output terraform.tfstate.gpg terraform.tfstate 

La frase de paso vive en secrets.TF_STATE_PASSPHRASE; la ejecución siguiente descarga el .gpg y lo descifra antes de terraform plan.

5. El pipeline: pruebas contra Cassandra real

Nada de mocks: el job de pruebas levanta cassandra:5.0 como service container y espera a que cqlsh responda:

services: cassandra: image: cassandra:5.0 ports: [ "9042:9042" ] env: MAX_HEAP_SIZE: 512M HEAP_NEWSIZE: 128M options: >- --health-cmd "cqlsh -e 'describe keyspaces'" --health-interval 10s --health-timeout 10s --health-retries 20 

Las 14 pruebas (unitarias y de integración con WebApplicationFactory) escriben y leen en ese Cassandra, y el resumen del job publica el resultado: "Pruebas: 14 de 14 superadas contra Cassandra 5.0".

Después, docker/build-push-action publica la imagen en GitHub Packages con tres etiquetas (latest, sha-<commit> completo y corto), pasando el commit como argumento de construcción para que la app lo exponga en /api/info:

build-args: GIT_SHA=${{ github.sha }} 

6. Desplegar y verificar la versión

El job de despliegue busca el servicio por nombre en la API de Render, crea un deploy con la imagen exacta y espera el estado live. Pero "live" no garantiza que la URL pública ya sirva la versión nueva, así que el último paso lo comprueba:

for i in $(seq 1 30); do V=$(curl -fsS "$URL/api/info" | jq -r '.version' || true) [ "$V" = "$GITHUB_SHA" ] && break sleep 10 done test "$V" = "$GITHUB_SHA" 

Si la app publicada no responde con el commit del push, el pipeline falla. En la ejecución del cambio "Historial de 24 horas" el ciclo completo tardó 3 min 49 s: pruebas 2 min 16 s, imagen 43 s y despliegue 38 s.

Pipeline completo en GitHub Actions

El servicio pulso-tacna en Render

7. Ingesta programada

Un tercer workflow simula a las estaciones: cada hora despierta la app (el plan gratuito de Render se suspende) y envía una ronda de lecturas. Así la serie de tiempo crece sola y la base serverless de Astra no se hiberna por inactividad.

on: schedule: - cron: "15 * * * *" 

Resumen de una ejecución de ingesta

8. Lecciones

  1. Mínimo privilegio también en la nube: el token de organización solo lo usa Terraform; la app recibe uno de base de datos.
  2. Repositorio público = artefactos públicos. Todo lo que se sube como artefacto debe ir cifrado si contiene secretos.
  3. "Desplegado" no es "verificado". Comparar el commit que responde la URL pública con el del push evita falsos positivos.
  4. Valida los workflows antes de subirlos. Mi primer push falló por un error de sintaxis YAML (una comilla invertida con : dentro de un run: de una sola línea). actionlint lo detecta en local en un segundo.
  5. Terraform y el pipeline no deben pisarse. ignore_changes delimita qué gestiona cada uno.

Autores: Adrian Fabricio Salas Acuña y Keyla Noelia Lopez Ojeda — Base de Datos II, Escuela Profesional de Ingeniería de Sistemas, Universidad Privada de Tacna.

🔗 Repositorio: https://github.com/keylalopezz/cassandra-astra-app · 🌐 App: https://pulso-tacna.onrender.com