# app/tests/test_unitarios.py
import pytest
from datetime import date
from src.dominio import calcular_disponibilidad, validar_reserva, ErrorValidacion

class TestDisponibilidad:
    """La regla de negocio central: nunca más reservas que capacidad."""

    def test_refugio_vacio_ofrece_toda_la_capacidad(self):
        assert calcular_disponibilidad(capacidad=40, ocupadas=0) == 40

    def test_descuenta_las_plazas_ocupadas(self):
        assert calcular_disponibilidad(capacidad=40, ocupadas=15) == 25

    def test_refugio_lleno_ofrece_cero(self):
        assert calcular_disponibilidad(capacidad=40, ocupadas=40) == 0

    def test_nunca_devuelve_negativo(self):
        """Caso límite: si por un error hubiera sobreventa en los datos,
        la función debe devolver 0, no un número negativo que la interfaz
        mostraría como '-3 plazas libres'."""
        assert calcular_disponibilidad(capacidad=40, ocupadas=45) == 0

class TestValidacion:
    @pytest.mark.parametrize("plazas", [0, -1, 13, 999])
    def test_rechaza_plazas_fuera_de_rango(self, plazas):
        with pytest.raises(ErrorValidacion):
            validar_reserva(plazas=plazas, fecha=date(2026, 8, 15))

    def test_rechaza_fecha_pasada(self):
        with pytest.raises(ErrorValidacion, match="pasado"):
            validar_reserva(plazas=2, fecha=date(2020, 1, 1))

    @pytest.mark.parametrize("correo", ["", "sin-arroba", "a@", "@b.com"])
    def test_rechaza_correo_invalido(self, correo):
        with pytest.raises(ErrorValidacion):
            validar_reserva(plazas=2, fecha=date(2026, 8, 15), email=correo)

# Emuladores locales, gratis y sin tocar la nube
gcloud emulators firestore start --host-port=localhost:8080
gcloud emulators pubsub    start --host-port=localhost:8085

# Las bibliotecas cliente los detectan por variable de entorno
export FIRESTORE_EMULATOR_HOST=localhost:8080
export PUBSUB_EMULATOR_HOST=localhost:8085

# app/tests/conftest.py
import pytest, subprocess, time, os
import psycopg

@pytest.fixture(scope="session")
def bd_efimera():
    """PostgreSQL en un contenedor, creado y destruido por la sesión de pruebas.
    Coste: 0 €. No toca la nube."""
    subprocess.run([
        "docker", "run", "-d", "--name", "pg-pruebas",
        "-e", "POSTGRES_PASSWORD=pruebas",
        "-e", "POSTGRES_DB=reservas",
        "-p", "55432:5432", "postgres:16-alpine",
    ], check=True)

    dsn = "postgresql://postgres:pruebas@localhost:55432/reservas"
    for _ in range(30):                       # espera a que acepte conexiones
        try:
            psycopg.connect(dsn).close()
            break
        except Exception:
            time.sleep(1)

    # Aplicar las MISMAS migraciones que en producción
    with psycopg.connect(dsn) as con:
        for f in sorted(os.listdir("data/migraciones")):
            with open(f"data/migraciones/{f}") as fh:
                con.execute(fh.read())
        con.commit()

    yield dsn

    subprocess.run(["docker", "rm", "-f", "pg-pruebas"], check=True)

# app/tests/test_integracion.py
import pytest, psycopg
from concurrent.futures import ThreadPoolExecutor
from src.repositorio import crear_reserva, ErrorSinPlazas

def test_no_hay_sobreventa_con_concurrencia(bd_efimera):
    """El caso que rompe los sistemas de reservas mal hechos:
    veinte personas intentan reservar la última plaza a la vez."""
    with psycopg.connect(bd_efimera) as con:
        con.execute("INSERT INTO refugio (nombre, altitud_m, capacidad) "
                    "VALUES ('Refugio Prueba', 2000, 1)")
        con.commit()

    def intentar():
        try:
            with psycopg.connect(bd_efimera) as c:
                crear_reserva(c, refugio_id=1, fecha="2026-08-15", plazas=1,
                              titular="Ficticio", email="[email protected]")
            return "ok"
        except ErrorSinPlazas:
            return "sin_plazas"

    with ThreadPoolExecutor(max_workers=20) as ex:
        resultados = list(ex.map(lambda _: intentar(), range(20)))

    # EXACTAMENTE una debe triunfar. Ni cero, ni dos.
    assert resultados.count("ok") == 1, f"Sobreventa: {resultados.count('ok')} reservas"
    assert resultados.count("sin_plazas") == 19

    with psycopg.connect(bd_efimera) as con:
        total = con.execute("SELECT COALESCE(SUM(plazas),0) FROM reserva "
                            "WHERE refugio_id=1 AND estado='confirmada'").fetchone()[0]
    assert total == 1

def crear_reserva(con, refugio_id, fecha, plazas, titular, email):
    with con.transaction():
        # El bloqueo de fila serializa los intentos concurrentes
        cap = con.execute(
            "SELECT capacidad FROM refugio WHERE id = %s FOR UPDATE",
            (refugio_id,)).fetchone()[0]
        ocupadas = con.execute(
            "SELECT COALESCE(SUM(plazas),0) FROM reserva "
            "WHERE refugio_id=%s AND fecha=%s AND estado='confirmada'",
            (refugio_id, fecha)).fetchone()[0]
        if ocupadas + plazas > cap:
            raise ErrorSinPlazas()
        con.execute("INSERT INTO reserva (refugio_id, fecha, plazas, "
                    "nombre_titular, email_titular) VALUES (%s,%s,%s,%s,%s)",
                    (refugio_id, fecha, plazas, titular, email))

# app/tests/test_e2e.py
import os, time, uuid, pytest, requests
from google.cloud import bigquery

BASE = os.environ["URL_DEV"]

@pytest.mark.e2e
def test_flujo_completo_reserva_llega_a_analitica():
    """Camino crítico entero: reservar → evento → BigQuery."""
    marca = str(uuid.uuid4())[:8]
    r = requests.post(f"{BASE}/api/reservas", timeout=30, json={
        "refugio_id": 1, "fecha": "2027-01-15", "plazas": 1,
        "nombre_titular": f"E2E {marca}",          # dato FICTICIO
        "email_titular": f"e2e-{marca}@example.com",
    })
    assert r.status_code == 201
    reserva_id = r.json()["id"]

    # La propagación por Pub/Sub no es instantánea: se sondea con límite
    bq = bigquery.Client()
    consulta = """
      SELECT COUNT(*) AS n
      FROM `refugio-datos.refugio_analitica.reservas_eventos`
      WHERE reserva_id = @rid AND DATE(ocurrido_en) = CURRENT_DATE()
    """
    cfg = bigquery.QueryJobConfig(query_parameters=[
        bigquery.ScalarQueryParameter("rid", "STRING", reserva_id)])

    for _ in range(12):                     # hasta 2 minutos
        n = list(bq.query(consulta, job_config=cfg).result())[0].n
        if n == 1:
            return
        time.sleep(10)
    pytest.fail("El evento no llegó a BigQuery en 2 minutos")

@pytest.mark.e2e
def test_sondas_de_salud_responden():
    assert requests.get(f"{BASE}/salud/vivo", timeout=10).status_code == 200
    assert requests.get(f"{BASE}/salud/arranque", timeout=10).status_code == 200

steps:
  - id: unitarias-e-integracion
    name: python:3.12-slim
    entrypoint: bash
    args:
      - -c
      - |
        pip install --no-cache-dir -r app/requirements.txt -r app/requirements-dev.txt
        cd app && python -m pytest tests/ -v -m "not e2e" --tb=short \
          --junitxml=/workspace/resultados.xml

  # ... construir, publicar, desplegar ...

  - id: e2e
    name: python:3.12-slim
    entrypoint: bash
    args:
      - -c
      - |
        pip install --no-cache-dir -r app/requirements-dev.txt
        export URL_DEV=$(gcloud run services describe refugio-web \
          --region=europe-west1 --format='value(status.url)')
        cd app && python -m pytest tests/ -v -m e2e
    waitFor: [desplegar]

terraform fmt -check -recursive        # formato consistente
terraform validate                     # sintaxis y referencias
terraform plan -detailed-exitcode      # 0=sin cambios, 2=hay cambios, 1=error

# .github/workflows/plan.yml
name: Terraform plan
on: pull_request

permissions:
  contents: read
  id-token: write
  pull-requests: write

jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ vars.WIF_PROVIDER }}
          service_account: ${{ vars.SA_PLAN }}      # SA de SOLO LECTURA
      - uses: hashicorp/setup-terraform@v3
      - run: terraform -chdir=infra/envs/dev init
      - id: plan
        run: terraform -chdir=infra/envs/dev plan -no-color -out=plan.tfplan
      - name: Publicar el plan como comentario
        uses: actions/github-script@v7
        with:
          script: |
            const salida = `#### Terraform plan
            \`\`\`
            ${{ steps.plan.outputs.stdout }}
            \`\`\``;
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner, repo: context.repo.repo, body: salida
            });

# tflint: errores de sintaxis, argumentos inválidos, buenas prácticas del proveedor
tflint --init && tflint --recursive

# checkov: comprobaciones de seguridad y cumplimiento sobre el código
checkov -d infra/ --framework terraform --compact

# checkov:skip=CKV_GCP_79:Alta disponibilidad no aplicable; proyecto de portafolio
# con presupuesto de 12 €/mes. Ver docs/adr/ADR-002.

  - id: analisis-iac
    name: bridgecrew/checkov:latest
    args: ["-d", "infra/", "--compact", "--soft-fail"]

#!/usr/bin/env bash
# scripts/prueba-reconstruccion.sh
set -euo pipefail

ENTORNO="dev"
INICIO=$(date +%s)

echo "=== 1. Estado inicial ==="
terraform -chdir="infra/envs/${ENTORNO}" state list | wc -l

echo "=== 2. DESTRUIR ==="
terraform -chdir="infra/envs/${ENTORNO}" destroy -auto-approve

echo "=== 3. Verificar que no queda nada ==="
gcloud run services list      --project="refugio-${ENTORNO}" --format="value(name)"
gcloud sql instances list     --project="refugio-${ENTORNO}" --format="value(name)"
gcloud compute networks list  --project="refugio-${ENTORNO}" --format="value(name)"

echo "=== 4. RECONSTRUIR ==="
terraform -chdir="infra/envs/${ENTORNO}" apply -auto-approve

echo "=== 5. Migraciones y datos ==="
./scripts/migrar.sh "${ENTORNO}"
python data/seed/generar.py --entorno="${ENTORNO}"

echo "=== 6. Desplegar la última imagen conocida ==="
./scripts/desplegar.sh "${ENTORNO}" "$(git rev-parse --short HEAD)"

echo "=== 7. Verificar que funciona ==="
URL=$(gcloud run services describe refugio-web --region=europe-west1 \
      --project="refugio-${ENTORNO}" --format='value(status.url)')
CODIGO=$(curl -s -o /dev/null -w '%{http_code}' "${URL}/salud/arranque")
test "${CODIGO}" = "200" || { echo "FALLO: la app no responde"; exit 1; }

echo "=== 8. Prueba de extremo a extremo ==="
URL_DEV="${URL}" python -m pytest app/tests/ -m e2e -q

FIN=$(date +%s)
echo "✅ RECONSTRUCCIÓN COMPLETA en $(( (FIN-INICIO)/60 )) minutos"

gcloud artifacts docker images scan \
  "europe-west1-docker.pkg.dev/refugio-dev/refugio-imagenes/web:latest" \
  --format="value(response.scan)"

# Y para listar los hallazgos
gcloud artifacts docker images list-vulnerabilities <RESULTADO_DEL_SCAN> \
  --format="table(vulnerability.effectiveSeverity, vulnerability.shortDescription)"

#!/usr/bin/env bash
# scripts/auditoria-seguridad.sh
set -uo pipefail
PROY="${1:?Uso: $0 <proyecto>}"
FALLOS=0
ok()   { echo "  ✅ $1"; }
falla(){ echo "  ❌ $1"; FALLOS=$((FALLOS+1)); }
avisa(){ echo "  ⚠️  $1"; }

echo "=== AUDITORÍA DE SEGURIDAD: ${PROY} ==="

echo "[1] Roles primitivos en cuentas de servicio"
N=$(gcloud projects get-iam-policy "$PROY" --format=json |
    jq '[.bindings[] | select(.role|test("roles/(owner|editor)")) |
         .members[] | select(startswith("serviceAccount:"))] | length')
[ "$N" -eq 0 ] && ok "Ninguna SA con owner/editor" || falla "$N cuentas con rol primitivo"

echo "[2] Claves de cuenta de servicio gestionadas por el usuario"
TOTAL=0
for SA in $(gcloud iam service-accounts list --project="$PROY" --format="value(email)"); do
  K=$(gcloud iam service-accounts keys list --iam-account="$SA" --managed-by=user \
      --format="value(name)" 2>/dev/null | wc -l)
  TOTAL=$((TOTAL+K))
  [ "$K" -gt 0 ] && echo "     · $SA tiene $K clave(s)"
done
[ "$TOTAL" -eq 0 ] && ok "Cero claves JSON" || falla "$TOTAL claves descargables"

echo "[3] Buckets accesibles públicamente"
PUB=0
for B in $(gcloud storage buckets list --project="$PROY" --format="value(name)"); do
  if gcloud storage buckets get-iam-policy "gs://$B" --format=json |
     jq -e '.bindings[]?.members[]? | select(. == "allUsers" or . == "allAuthenticatedUsers")' >/dev/null 2>&1; then
    echo "     · gs://$B es PÚBLICO"; PUB=$((PUB+1))
  fi
done
[ "$PUB" -eq 0 ] && ok "Ningún bucket público" || falla "$PUB bucket(s) público(s)"

echo "[4] Bases de datos con IP pública"
for I in $(gcloud sql instances list --project="$PROY" --format="value(name)"); do
  IPV4=$(gcloud sql instances describe "$I" --project="$PROY" \
         --format="value(settings.ipConfiguration.ipv4Enabled)")
  [ "$IPV4" = "False" ] && ok "$I sin IP pública" || falla "$I TIENE IP PÚBLICA"
done

echo "[5] Secretos en el repositorio"
if git log -p --all 2>/dev/null | grep -Ei '(password|api[_-]?key|secret|BEGIN (RSA|PRIVATE))' \
   | grep -v 'secret_id\|secretAccessor\|SecretManager\|secret_key_ref\|refugio-db-password' \
   | head -5 | grep -q .; then
  falla "Posibles secretos en el historial de git — REVISAR"
else
  ok "Sin secretos evidentes en el historial"
fi

echo "[6] Ficheros de credenciales en el árbol"
if find . -name "*.json" -not -path "./node_modules/*" -not -path "./.git/*" \
   -exec grep -l '"type": *"service_account"' {} \; 2>/dev/null | grep -q .; then
  falla "Hay ficheros de clave de cuenta de servicio en el repositorio"
else
  ok "Sin ficheros de credenciales"
fi

echo "[7] Servicios de Cloud Run sin autenticación"
for S in $(gcloud run services list --project="$PROY" --region=europe-west1 --format="value(name)"); do
  if gcloud run services get-iam-policy "$S" --project="$PROY" --region=europe-west1 \
     --format=json | jq -e '.bindings[]?.members[]? | select(. == "allUsers")' >/dev/null 2>&1; then
    avisa "$S es público (correcto si es la web; revisar si no)"
  else
    ok "$S requiere autenticación"
  fi
done

echo "[8] Logs de auditoría de actividad de administrador"
gcloud logging read 'logName:"cloudaudit.googleapis.com%2Factivity"' \
  --project="$PROY" --limit=1 --format="value(timestamp)" | grep -q . \
  && ok "Hay logs de auditoría" || avisa "Sin actividad reciente registrada"

echo
echo "=== RESULTADO: ${FALLOS} fallo(s) ==="
exit $((FALLOS > 0))

DOMINIO="refugioreserva.example"

# Certificado: emisor y validez
echo | openssl s_client -connect "${DOMINIO}:443" -servername "${DOMINIO}" 2>/dev/null |
  openssl x509 -noout -subject -issuer -dates

# Versiones de TLS: 1.2 y 1.3 sí; 1.0 y 1.1 deben fallar
for V in tls1 tls1_1 tls1_2 tls1_3; do
  printf "%-8s " "$V"
  echo | openssl s_client -"$V" -connect "${DOMINIO}:443" 2>/dev/null | \
    grep -q "Verify return code: 0" && echo "acepta" || echo "rechaza"
done

# Cabeceras de seguridad
curl -sI "https://${DOMINIO}" | grep -iE \
  'strict-transport|x-content-type|x-frame|content-security|referrer-policy'

# HTTP debe redirigir
curl -sI "http://${DOMINIO}" | head -1

# ¿Qué puede hacer realmente mi cuenta de servicio de la aplicación?
gcloud projects get-iam-policy refugio-prod --format=json |
  jq -r --arg sa "serviceAccount:[email protected]" \
     '.bindings[] | select(.members[]? == $sa) | .role'

# Comprobar un permiso concreto que NO debería tener
gcloud policy-troubleshoot iam \
  "//cloudresourcemanager.googleapis.com/projects/refugio-prod" \
  --principal-email="[email protected]" \
  --permission="resourcemanager.projects.setIamPolicy"
# Esperado: NOT_GRANTED

// pruebas/carga.js  —  ejecutar con: k6 run pruebas/carga.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';

const erroresNegocio = new Rate('errores_negocio');

export const options = {
  stages: [
    { duration: '1m', target: 10 },   // calentamiento
    { duration: '2m', target: 50 },   // carga esperada
    { duration: '2m', target: 100 },  // el doble
    { duration: '1m', target: 0 },    // enfriamiento
  ],
  thresholds: {
    http_req_duration:  ['p(95)<1000', 'p(99)<2000'],
    http_req_failed:    ['rate<0.01'],
    errores_negocio:    ['rate<0.05'],
  },
};

const BASE = __ENV.URL;

export default function () {
  // 80% consultas, 20% reservas: perfil realista, no todo escrituras
  if (Math.random() < 0.8) {
    const r = http.get(`${BASE}/api/disponibilidad?refugio_id=1&fecha=2027-01-15`);
    check(r, { 'consulta 200': (x) => x.status === 200 });
    erroresNegocio.add(r.status >= 500);
  } else {
    const r = http.post(`${BASE}/api/reservas`, JSON.stringify({
      refugio_id: Math.ceil(Math.random() * 12),
      fecha: '2027-01-15', plazas: 1,
      nombre_titular: 'Carga Ficticia',
      email_titular: `carga-${__VU}-${__ITER}@example.com`,
    }), { headers: { 'Content-Type': 'application/json' } });
    // 409 (sin plazas) es correcto, no un error del sistema
    check(r, { 'reserva 201 o 409': (x) => x.status === 201 || x.status === 409 });
    erroresNegocio.add(r.status >= 500);
  }
  sleep(Math.random() * 2);
}

# ENSAYO EN DESARROLLO, con la hora anotada
echo "Inicio del ensayo: $(date)" | tee -a docs/evidencias/ensayo-bd.log

# Detener la base de datos
gcloud sql instances patch refugio-db --project=refugio-dev \
  --activation-policy=NEVER --quiet

# Observar el comportamiento
curl -s -o /dev/null -w "Portada: %{http_code} en %{time_total}s\n"  "${URL}/"
curl -s -o /dev/null -w "API:     %{http_code} en %{time_total}s\n"  "${URL}/api/refugios"
curl -s -w "Salud: %{http_code}\n" "${URL}/salud/arranque"
curl -s "${URL}/api/refugios" | head -c 300

# Restaurar
gcloud sql instances patch refugio-db --project=refugio-dev \
  --activation-policy=ALWAYS --quiet

INICIO=$(date +%s)

# 1. ¿Qué copias tengo?
gcloud sql backups list --instance=refugio-db --project=refugio-dev \
  --format="table(id, windowStartTime, status)"

BACKUP_ID=$(gcloud sql backups list --instance=refugio-db --project=refugio-dev \
            --format="value(id)" --limit=1)

# 2. Restaurar sobre una instancia NUEVA (nunca sobre la original en un ensayo)
gcloud sql instances create refugio-db-restaurada \
  --project=refugio-dev --region=europe-west1 \
  --database-version=POSTGRES_16 --tier=db-f1-micro

gcloud sql backups restore "${BACKUP_ID}" \
  --restore-instance=refugio-db-restaurada \
  --backup-instance=refugio-db --project=refugio-dev --quiet

# 3. VERIFICAR que los datos están (esto es lo que casi nadie hace)
./cloud-sql-proxy --port 55433 "refugio-dev:europe-west1:refugio-db-restaurada" &
psql -h 127.0.0.1 -p 55433 -U app -d reservas -c "
  SELECT (SELECT count(*) FROM reserva) AS reservas,
         (SELECT count(*) FROM refugio) AS refugios,
         (SELECT max(creada_en) FROM reserva) AS ultima;"

FIN=$(date +%s)
echo "RTO medido: $(( (FIN-INICIO)/60 )) minutos"

# 4. LIMPIAR — no dejes la instancia restaurada encendida
gcloud sql instances delete refugio-db-restaurada --project=refugio-dev --quiet

# Obtener el digest EXACTO de la imagen probada en dev
DIGEST=$(gcloud run services describe refugio-web --region=europe-west1 \
         --project=refugio-dev --format="value(spec.template.spec.containers[0].image)")
echo "Promocionando: ${DIGEST}"

# Desplegar en producción SIN tráfico
gcloud run deploy refugio-web --image="${DIGEST}" \
  --region=europe-west1 --project=refugio-prod \
  --no-traffic --tag=candidata

SERVICIO="refugio-web"; REGION="europe-west1"; PROY="refugio-prod"
NUEVA=$(gcloud run revisions list --service=$SERVICIO --region=$REGION \
        --project=$PROY --limit=1 --format="value(name)")

# Fase 1 — 10% durante 10 minutos
gcloud run services update-traffic $SERVICIO --region=$REGION --project=$PROY \
  --to-revisions="${NUEVA}=10"

# Observar la revisión nueva EN CONCRETO, no el servicio entero
gcloud logging read \
  "resource.type=cloud_run_revision AND
   resource.labels.revision_name=${NUEVA} AND severity>=ERROR" \
  --project=$PROY --limit=20 --freshness=10m

#!/usr/bin/env bash
# scripts/revertir.sh — probado el 2026-10-28, tarda 38 segundos
set -euo pipefail
SERVICIO="${1:-refugio-web}"; REGION="europe-west1"; PROY="refugio-prod"

ANTERIOR=$(gcloud run revisions list --service="$SERVICIO" --region="$REGION" \
  --project="$PROY" --format="value(name)" --sort-by="~metadata.creationTimestamp" \
  | sed -n '2p')

echo "Revirtiendo ${SERVICIO} → ${ANTERIOR}"
gcloud run services update-traffic "$SERVICIO" --region="$REGION" --project="$PROY" \
  --to-revisions="${ANTERIOR}=100"

URL=$(gcloud run services describe "$SERVICIO" --region="$REGION" --project="$PROY" \
      --format='value(status.url)')
sleep 5
curl -s -o /dev/null -w "Verificación: %{http_code}\n" "${URL}/salud/arranque"
echo "✅ Revertido a ${ANTERIOR}"

# Manual de operación — RefugioReserva

## Datos de contacto y accesos
Responsable: <yo>. Proyectos: refugio-dev, refugio-prod, refugio-datos.
Consola: https://console.cloud.google.com/home/dashboard?project=refugio-prod

## P1 — La aplicación devuelve errores 5xx
1. `gcloud logging read 'severity>=ERROR' --project=refugio-prod --limit=20 --freshness=15m`
2. ¿Coincide con un despliegue? `gcloud run revisions list --service=refugio-web --limit=3`
3. Si coincide → **revertir**: `./scripts/revertir.sh refugio-web` (38 s)
4. Si no → comprobar la BD: `gcloud sql instances describe refugio-db --format="value(state)"`
5. Escribir lo ocurrido en `docs/diario.md`

## P2 — La aplicación no responde en absoluto
1. `curl -sI https://refugioreserva.example`
2. ¿Servicio vivo? `gcloud run services describe refugio-web --format="value(status.conditions)"`
3. ¿DNS resuelve? `dig +short refugioreserva.example`
4. ¿Certificado válido? `openssl s_client -connect refugioreserva.example:443`

## P3 — Restaurar la base de datos
Ver `scripts/restaurar.sh`. **RTO medido: 22 minutos. RPO: hasta 24 h.**

## P4 — Coste disparado
1. Informe de facturación → agrupar por servicio y por etiqueta `componente`
2. Sospechosos habituales: instancias olvidadas, jobs en bucle, consultas de BigQuery sin filtro de partición
3. Medida inmediata: bajar `max-instances`; en último extremo, `terraform destroy` de dev

## P5 — Desplegar una versión nueva
`git push` a `main` → dev automático → aprobar en Cloud Build → canario 10/50/100

# 1. Última verificación
./scripts/auditoria-seguridad.sh refugio-prod
terraform -chdir=infra/envs/prod plan          # No changes

# 2. Promocionar la imagen probada
./scripts/promocionar.sh "$(git rev-parse --short HEAD)"

# 3. Canario 10%, esperar, verificar
# 4. 50%, esperar, verificar
# 5. 100%
# 6. Marcar el momento
git tag -a v1.0.0 -m "Lanzamiento del proyecto final"
git push --tags

# El comando que dejas corriendo en una terminal durante la primera hora
gcloud logging tail \
  'resource.type="cloud_run_revision" AND severity>=WARNING' \
  --project=refugio-prod

# Incidente 2026-11-04 — Errores 5xx tras el despliegue de v1.1.0

**Duración:** 19:42 → 19:51 (9 minutos)
**Impacto:** ~40 peticiones con error 500. Sin pérdida de datos.
**Detección:** alerta de tasa de errores (llegó a las 19:47, 5 min después del inicio)

## Qué pasó
El despliegue de v1.1.0 introdujo una consulta que usaba una columna
(`opinion.magnitud`) creada por la migración 003, que no se había aplicado
en producción. La aplicación arrancó bien (la sonda de arranque no toca esa
tabla) y falló solo en las peticiones a `/api/opiniones`.

## Cronología
- 19:42 Despliegue canario al 10 %
- 19:44 Primeros 500 en los logs (no los miré: estaba mirando el panel, que
        con el 10 % de tráfico apenas movió la aguja)
- 19:47 Llega la alerta
- 19:49 Ejecuto `./scripts/revertir.sh`
- 19:51 Verificado: 0 errores

## Causa raíz
El pipeline despliega la aplicación pero **no ejecuta las migraciones**.
En desarrollo las aplico a mano, así que allí funcionaba.

## Qué funcionó
- La reversión: 38 segundos, tal como estaba ensayada.
- El canario limitó el impacto al 10 % del tráfico.

## Qué no funcionó
- La alerta tardó 5 minutos. Con el 10 % de tráfico, el umbral del 5 % sobre
  el total del servicio se alcanza tarde.
- No estaba mirando los logs de la revisión canaria en concreto.

## Acciones
1. ✅ Añadir paso de migraciones al pipeline, antes del despliegue.
2. ✅ Alerta adicional por revisión, no solo por servicio.
3. ⬜ Prueba de humo específica sobre `/api/opiniones` tras desplegar.

     ✓ consulta 200
     ✓ reserva 201 o 409

     checks.........................: 99.31% ✓ 24893  ✗ 172
     http_req_duration..............: avg=241ms min=61ms med=178ms max=8.9s
       { expected_response:true }...: avg=228ms
       p(90)=402ms  p(95)=712ms  p(99)=2.41s
     http_req_failed................: 0.68%  ✓ 172    ✗ 25065
     errores_negocio................: 0.68%
     iterations.....................: 25065
     vus_max........................: 100

     ✗ http_req_duration.............: p(99)<2000  → 2.41s  FALLO
     ✓ http_req_failed...............: rate<0.01   → 0.0068 OK

$ gcloud logging read 'severity>=ERROR' --project=refugio-dev --limit=5 \
    --format="value(jsonPayload.message)"
FATAL: remaining connection slots are reserved for non-replication superuser connections

# Antes
pool = ConnectionPool(dsn, min_size=5, max_size=10)
# Después
pool = ConnectionPool(dsn, min_size=1, max_size=3, timeout=5)

     http_req_duration.....: p(95)=634ms  p(99)=1.82s   ✓
     http_req_failed.......: 0.00%  ✓ 0  ✗ 26102        ✓
     Coste de la prueba: 0,38 €

Síntoma: tras desplegar v1.2.0 al 10 %, la latencia p95 de la revisión
canaria pasó de 680 ms a 1.940 ms. Cero errores 5xx. Cero alertas.

Detección: la estaba mirando yo, comparando la revisión canaria con la
estable en el panel, porque el criterio de promoción incluye
"p95 < 1,2 × la base" y 1.940 no cumple.

Causa: v1.2.0 añadía el sentimiento medio a la respuesta de /api/refugios
con una subconsulta correlacionada sobre `opinion`, sin índice.

Decisión: revertir sin investigar más, a las 22:14. La corrección
(un índice y una consulta reescrita) se desplegó dos días después.

FAILED test_no_hay_sobreventa_con_concurrencia
AssertionError: Sobreventa: 7 reservas

=== AUDITORÍA DE SEGURIDAD: refugio-prod ===
[1] Roles primitivos           ✅ Ninguna SA con owner/editor
[2] Claves de cuenta           ✅ Cero claves JSON
[3] Buckets públicos           ❌ 1 bucket público: gs://refugio-fotos-8f2a
[4] BD con IP pública          ✅ refugio-db sin IP pública
[5] Secretos en git            ✅ Sin secretos evidentes
[6] Credenciales en el árbol   ✅ Sin ficheros de credenciales
[7] Cloud Run sin auth         ⚠️  refugio-web es público (correcto)
[8] Logs de auditoría          ✅ Hay logs

=== RESULTADO: 1 fallo ===

def url_firmada(nombre_objeto: str, minutos: int = 60) -> str:
    blob = _bucket.blob(nombre_objeto)
    return blob.generate_signed_url(version="v4",
                                    expiration=timedelta(minutes=minutos),
                                    method="GET")

tls1     rechaza    ✅
tls1_1   rechaza    ✅
tls1_2   acepta     ✅
tls1_3   acepta     ✅
strict-transport-security: max-age=31536000; includeSubDomains
x-content-type-options: nosniff
x-frame-options: DENY
content-security-policy: default-src 'self'; img-src 'self' data: https://storage.googleapis.com
referrer-policy: strict-origin-when-cross-origin

Portada: 200 en 0.31s          ✅ sigue funcionando (contenido estático)
API:     500 en 30.02s         ❌ 30 segundos y una traza de Python
Salud:   200                   ❌ MIENTE: dice que está listo y no lo está

Portada: 200 en 0.28s          ✅
API:     503 en 1.24s          ✅ {"error":"servicio_no_disponible",
                                   "mensaje":"No podemos consultar la disponibilidad
                                   ahora mismo. Inténtalo en unos minutos."}
Salud:   503                   ✅ Cloud Run deja de enviar tráfico
Fotos:   200                   ✅ el bucket es independiente de la BD
Panel:   200                   ✅ Looker Studio lee de BigQuery