name: Integración continua

on:
  push:
    branches: [main]
  pull_request:

# Sin secretos de larga vida: id-token permite pedir un token OIDC
# efímero para autenticarse contra la nube y firmar con Cosign.
permissions:
  contents: read
  packages: write
  id-token: write
  pull-requests: write

env:
  REGISTRO: registry.rutasnorte.example
  IMAGEN: rutasnorte/api-reservas

# Cancela ejecuciones antiguas de la misma rama: no gastamos corredores
# validando commits que ya han quedado obsoletos.
concurrency:
  group: ci-${{ github.ref }}
  cancel-in-progress: true

jobs:

  # ---------------------------------------------------------------
  # 1. Pruebas unitarias: rápidas, sin red, sin base de datos real.
  # ---------------------------------------------------------------
  pruebas:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '22'
          cache: npm

      - name: Instalar dependencias exactas
        # npm ci respeta el fichero de bloqueo: reproducible, a diferencia de npm install.
        run: npm ci

      - name: Análisis estático
        run: npm run lint

      - name: Pruebas unitarias con cobertura
        run: npm test -- --coverage --coverageThreshold='{"global":{"lines":80}}'

      - name: Auditoría de dependencias
        run: npm audit --audit-level=high

  # ---------------------------------------------------------------
  # 2-6. Construcción, escaneo, publicación y firma.
  # ---------------------------------------------------------------
  imagen:
    needs: pruebas
    runs-on: ubuntu-latest
    outputs:
      # El digest es la salida que consumen los trabajos siguientes
      # y, finalmente, el repositorio de manifiestos.
      digest: ${{ steps.construir.outputs.digest }}
      etiqueta: ${{ steps.meta.outputs.etiqueta }}
    steps:
      - uses: actions/checkout@v4

      - name: Calcular etiqueta a partir del commit
        id: meta
        run: |
          # SHA corto: identificador único, trazable y ordenable.
          ETIQUETA="$(git rev-parse --short=12 HEAD)"
          echo "etiqueta=${ETIQUETA}" >> "$GITHUB_OUTPUT"

      - uses: docker/setup-buildx-action@v3

      - name: Autenticarse en el registro por OIDC
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRO }}
          username: ${{ github.actor }}
          # Token efímero de la propia ejecución, no una credencial guardada.
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Construir imagen multietapa
        id: construir
        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
          tags: ${{ env.REGISTRO }}/${{ env.IMAGEN }}:${{ steps.meta.outputs.etiqueta }}
          # Caché de capas en el propio registro: una construcción típica
          # baja de 4 min a unos 50 s reutilizando node_modules.
          cache-from: type=registry,ref=${{ env.REGISTRO }}/${{ env.IMAGEN }}:cache
          cache-to: type=registry,ref=${{ env.REGISTRO }}/${{ env.IMAGEN }}:cache,mode=max
          provenance: true    # atestación de procedencia SLSA
          sbom: true          # inventario de componentes

      - name: Escaneo con Trivy
        uses: aquasecurity/[email protected]
        with:
          image-ref: ${{ env.REGISTRO }}/${{ env.IMAGEN }}@${{ steps.construir.outputs.digest }}
          format: table
          # Rompe la construcción solo con CRITICAL. Las HIGH se registran
          # y se revisan semanalmente: si rompes con HIGH, el equipo aprende
          # a saltarse el control en vez de a arreglarlo.
          severity: CRITICAL
          exit-code: '1'
          ignore-unfixed: true    # sin parche disponible no hay nada que hacer hoy

      - name: Instalar Cosign
        uses: sigstore/cosign-installer@v3

      - name: Firmar sin claves con la identidad del flujo de trabajo
        # No hay clave privada en ningún sitio: Cosign obtiene un certificado
        # efímero de Fulcio a partir del token OIDC de esta ejecución y
        # registra la firma en el log público Rekor. La identidad firmante es
        # el propio flujo de trabajo, verificable en la política de admisión.
        run: |
          cosign sign --yes \
            "${REGISTRO}/${IMAGEN}@${{ steps.construir.outputs.digest }}"

      - name: Resumen de la ejecución
        run: |
          {
            echo "### Imagen publicada"
            echo "- Etiqueta: \`${{ steps.meta.outputs.etiqueta }}\`"
            echo "- Digest: \`${{ steps.construir.outputs.digest }}\`"
            echo "- Firmada por: \`${{ github.workflow_ref }}\`"
          } >> "$GITHUB_STEP_SUMMARY"

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: exigir-firma-rutasnorte
spec:
  validationFailureAction: Enforce
  rules:
    - name: verificar-firma
      match:
        any:
          - resources:
              kinds: [Pod]
              namespaces: ["rutas-norte-*"]
      verifyImages:
        - imageReferences: ["registry.rutasnorte.example/rutasnorte/*"]
          attestors:
            - entries:
                - keyless:
                    subject: "https://github.com/rutasnorte/*/.github/workflows/integracion.yml@refs/heads/main"
                    issuer: "https://token.actions.githubusercontent.com"

# syntax=docker/dockerfile:1.7

# --- Etapa 1: dependencias --------------------------------------
FROM node:22-bookworm-slim AS deps
WORKDIR /app
COPY package.json package-lock.json ./
# La caché de npm se monta, no se copia: no engorda ninguna capa.
RUN --mount=type=cache,target=/root/.npm npm ci --omit=dev

# --- Etapa 2: construcción --------------------------------------
FROM node:22-bookworm-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN --mount=type=cache,target=/root/.npm npm ci
COPY . .
RUN npm run build

# --- Etapa 3: imagen final --------------------------------------
FROM gcr.io/distroless/nodejs22-debian12:nonroot
WORKDIR /app
# Solo lo imprescindible: sin compiladores, sin shell, sin gestor de paquetes.
COPY --from=deps  /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY package.json ./
USER 10001:10001
EXPOSE 8080 9090
CMD ["dist/server.js"]

  integracion:
    needs: imagen
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Levantar clúster kind
        uses: helm/kind-action@v1
        with:
          cluster_name: ci-rutasnorte
          # Un nodo basta: probamos correcto funcionamiento, no alta disponibilidad.
          config: .github/kind/cluster.yaml
          wait: 120s

      - name: Desplegar dependencias reales
        # PostgreSQL y Redis de verdad, no simuladores: queremos detectar
        # errores de SQL y de conexión, que es donde fallan estas cosas.
        run: |
          helm repo add bitnami https://charts.bitnami.com/bitnami
          helm install pg bitnami/postgresql \
            --set auth.database=reservas \
            --set auth.username=app_reservas \
            --set auth.password=pruebas \
            --set primary.persistence.enabled=false \
            --wait --timeout 5m
          helm install redis bitnami/redis \
            --set auth.enabled=false \
            --set master.persistence.enabled=false \
            --wait --timeout 5m

      - name: Cargar la imagen recién construida en kind
        run: |
          IMG="${REGISTRO}/${IMAGEN}@${{ needs.imagen.outputs.digest }}"
          docker pull "$IMG"
          kind load docker-image "$IMG" --name ci-rutasnorte

      - name: Desplegar el chart de Rutas Norte
        run: |
          helm upgrade --install api-reservas ./chart \
            --values ./chart/valores-ci.yaml \
            --set image.digest='${{ needs.imagen.outputs.digest }}' \
            --set postgres.host=pg-postgresql \
            --set redis.url=redis://redis-master:6379 \
            --wait --timeout 5m

      - name: Migraciones de esquema
        run: kubectl wait --for=condition=complete job/api-reservas-migraciones --timeout=3m

      - name: Pruebas de humo
        run: |
          kubectl port-forward svc/api-reservas 8080:80 &
          sleep 5
          npm run pruebas:humo -- --base-url http://localhost:8080

      - name: Diagnóstico si algo falla
        if: failure()
        run: |
          kubectl get pods -o wide
          kubectl describe pods -l app.kubernetes.io/name=api-reservas
          kubectl logs -l app.kubernetes.io/name=api-reservas --tail=200 --all-containers
          kubectl get events --sort-by=.lastTimestamp | tail -40

// pruebas/humo.spec.js — se ejecutan en kind y también tras cada despliegue real
describe('humo api-reservas', () => {
  test('responde a la sonda de preparación', async () => {
    const r = await fetch(`${base}/preparado`);
    expect(r.status).toBe(200);
  });

  test('expone métricas en formato Prometheus', async () => {
    const t = await (await fetch(`${base}/metricas`)).text();
    expect(t).toMatch(/^api_reservas_peticiones_total/m);
  });

  test('consulta horarios contra la base de datos real', async () => {
    const r = await fetch(`${base}/horarios?linea=BIL-SAN&fecha=2026-08-14`);
    expect(r.status).toBe(200);
    expect(Array.isArray((await r.json()).salidas)).toBe(true);
  });

  test('crea una reserva y es idempotente', async () => {
    const cuerpo = { linea: 'BIL-SAN', fecha: '2026-08-14', plazas: 2 };
    const cab = { 'Idempotency-Key': 'prueba-humo-001', 'Content-Type': 'application/json' };
    const r1 = await fetch(`${base}/reservas`, { method: 'POST', headers: cab, body: JSON.stringify(cuerpo) });
    const r2 = await fetch(`${base}/reservas`, { method: 'POST', headers: cab, body: JSON.stringify(cuerpo) });
    expect(r1.status).toBe(201);
    expect((await r2.json()).id).toBe((await r1.json()).id);  // no duplica
  });
});

  actualizar-manifiestos:
    needs: [imagen, integracion]
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - name: Clonar el repositorio de manifiestos
        uses: actions/checkout@v4
        with:
          repository: rutasnorte/manifiestos
          # Token de una app de GitHub limitada a este repositorio,
          # no un token personal con acceso a toda la organización.
          token: ${{ secrets.TOKEN_MANIFIESTOS }}

      - name: Escribir el nuevo digest en la superposición de dev
        run: |
          cd overlays/dev
          kustomize edit set image \
            "api-reservas=${REGISTRO}/${IMAGEN}@${{ needs.imagen.outputs.digest }}"

      - name: Abrir petición de cambio y fusionarla automáticamente
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.TOKEN_MANIFIESTOS }}
          branch: auto/api-reservas-${{ needs.imagen.outputs.etiqueta }}
          commit-message: "dev: api-reservas ${{ needs.imagen.outputs.etiqueta }}"
          title: "dev: api-reservas ${{ needs.imagen.outputs.etiqueta }}"
          body: |
            Actualización automática desde `rutasnorte/api-reservas`.

            - Commit: ${{ github.sha }}
            - Digest: `${{ needs.imagen.outputs.digest }}`
            - Trivy: sin vulnerabilidades críticas
            - Firma: verificada (sin claves)
            - Pruebas de integración en kind: correctas
          labels: automatico,dev

# Ejecutado por una persona (o por un botón que hace esto mismo)
cd manifiestos
DIGEST=$(yq '.images[] | select(.name=="api-reservas") | .digest' overlays/dev/kustomization.yaml)
git switch -c promocion/api-reservas-pre
cd overlays/pre
kustomize edit set image "api-reservas=registry.rutasnorte.example/rutasnorte/api-reservas@${DIGEST}"
git commit -am "pre: promocionar api-reservas ${DIGEST:0:19}"
gh pr create --title "pre: promocionar api-reservas" --body-file ../.github/plantillas/promocion.md

## Promoción a producción — api-reservas

- **Digest:** `sha256:...`
- **Cambios incluidos:** (enlaces a las peticiones de cambio de código)
- **¿Incluye migración de esquema?** Sí / No — si sí, ¿es compatible hacia atrás?
- **Resultado de k6 en pre:** p95 = ___ ms (umbral 300 ms), errores = ___ % (umbral 0,1 %)
- **Riesgo estimado:** bajo / medio / alto — justificación:
- **Plan de reversión:** `git revert <sha>` + tiempo estimado ___ min
- **Ventana:** ¿hay congelación activa? Sí / No
- **Aprobaciones:** plataforma @____ · producto @____

  entorno-efimero:
    if: github.event_name == 'pull_request'
    needs: imagen
    runs-on: ubuntu-latest
    environment:
      name: pr-${{ github.event.number }}
      url: https://pr-${{ github.event.number }}.dev.rutasnorte.example
    steps:
      - uses: actions/checkout@v4

      - name: Autenticarse en el clúster de desarrollo por OIDC
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::111122223333:role/ci-rutasnorte-efimeros
          aws-region: eu-west-1
      - run: aws eks update-kubeconfig --name rutasnorte-dev

      - name: Desplegar el entorno
        env:
          NS: rutas-norte-pr-${{ github.event.number }}
        run: |
          kubectl create namespace "$NS" --dry-run=client -o yaml | kubectl apply -f -
          # Etiquetas que gobiernan cuotas, políticas y limpieza automática.
          kubectl label namespace "$NS" --overwrite \
            rutasnorte.example/efimero=true \
            rutasnorte.example/pr=${{ github.event.number }} \
            rutasnorte.example/creado=$(date +%Y-%m-%d) \
            pod-security.kubernetes.io/enforce=restricted
          helm upgrade --install api-reservas ./chart \
            --namespace "$NS" \
            --values ./chart/valores-efimero.yaml \
            --set image.digest='${{ needs.imagen.outputs.digest }}' \
            --set ingress.host=pr-${{ github.event.number }}.dev.rutasnorte.example \
            --wait --timeout 8m

      - name: Comentar la URL en la petición de cambio
        uses: peter-evans/create-or-update-comment@v4
        with:
          issue-number: ${{ github.event.number }}
          body: |
            Entorno de pruebas listo: https://pr-${{ github.event.number }}.dev.rutasnorte.example
            Namespace: `rutas-norte-pr-${{ github.event.number }}`

  limpiar-efimero:
    if: github.event.action == 'closed'
    runs-on: ubuntu-latest
    steps:
      - run: kubectl delete namespace "rutas-norte-pr-${{ github.event.number }}" --ignore-not-found

apiVersion: batch/v1
kind: CronJob
metadata:
  name: limpiar-namespaces-efimeros
  namespace: plataforma
spec:
  schedule: "0 2 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          serviceAccountName: limpiador-efimeros
          restartPolicy: OnFailure
          containers:
            - name: limpiar
              image: registry.rutasnorte.example/utiles/kubectl:1.30
              command:
                - /bin/sh
                - -c
                - |
                  LIMITE=$(date -d '7 days ago' +%Y-%m-%d)
                  kubectl get ns -l rutasnorte.example/efimero=true \
                    -o jsonpath='{range .items[*]}{.metadata.name} {.metadata.labels.rutasnorte\.example/creado}{"\n"}{end}' |
                  while read -r NS CREADO; do
                    [ "$CREADO" \< "$LIMITE" ] && kubectl delete ns "$NS"
                  done

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": { "Federated": "arn:aws:iam::111122223333:oidc-provider/token.actions.githubusercontent.com" },
    "Action": "sts:AssumeRoleWithWebIdentity",
    "Condition": {
      "StringEquals": { "token.actions.githubusercontent.com:aud": "sts.amazonaws.com" },
      "StringLike": {
        "token.actions.githubusercontent.com:sub": "repo:rutasnorte/api-reservas:pull_request"
      }
    }
  }]
}

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: ci-efimeros
rules:
  # Puede crear y borrar namespaces (necesario para los efímeros)...
  - apiGroups: [""]
    resources: [namespaces]
    verbs: [get, list, create, delete, patch]
  # ...y gestionar cargas dentro de ellos.
  - apiGroups: ["", apps, networking.k8s.io, batch, autoscaling]
    resources: ["*"]
    verbs: [get, list, create, update, patch, delete]
  # Explícitamente NO: nodes, clusterroles, clusterrolebindings,
  # persistentvolumes ni secretos de otros namespaces.

# Hook de sincronización de Argo CD: se ejecuta DESPUÉS de sincronizar.
apiVersion: batch/v1
kind: Job
metadata:
  name: humo-api-reservas
  namespace: rutas-norte-pro
  annotations:
    argocd.argoproj.io/hook: PostSync
    argocd.argoproj.io/hook-delete-policy: BeforeHookCreation
spec:
  backoffLimit: 2
  activeDeadlineSeconds: 300
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: humo
          image: registry.rutasnorte.example/rutasnorte/pruebas-humo@sha256:e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4
          env:
            - name: BASE_URL
              value: https://api.rutasnorte.example
            - name: MODO
              value: solo-lectura      # en pro no creamos reservas reales

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: api-reservas-pro
  namespace: argocd
spec:
  source:
    repoURL: https://github.com/rutasnorte/manifiestos
    path: overlays/pro
    targetRevision: main
  destination:
    server: https://kubernetes.default.svc
    namespace: rutas-norte-pro
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    retry:
      limit: 2
      backoff: { duration: 30s, factor: 2, maxDuration: 3m }
  revisionHistoryLimit: 20

# El flujo de reversión automática, en esencia
gh workflow run revertir.yml -f entorno=pro -f motivo="humo PostSync fallido"
# ...que hace:
git revert --no-edit "$(git log -1 --format=%H -- overlays/pro)"
git push origin main
argocd app sync api-reservas-pro --prune
argocd app wait api-reservas-pro --health --timeout 300

# Frecuencia de despliegue a pro en los últimos 30 días
git log --since='30 days ago' --oneline -- overlays/pro | wc -l

# Plazo de entrega: diferencia entre el commit de código y el de promoción
git log --since='30 days ago' --format='%H %ct' -- overlays/pro

on: [push]
permissions: write-all
jobs:
  desplegar:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t registry.rutasnorte.example/rutasnorte/promos:latest .
      - run: docker push registry.rutasnorte.example/rutasnorte/promos:latest
      - run: echo "${{ secrets.KUBECONFIG_PRO }}" > /tmp/kc
      - run: KUBECONFIG=/tmp/kc kubectl -n rutas-norte-pro apply -f k8s/
      - run: KUBECONFIG=/tmp/kc kubectl -n rutas-norte-pro rollout restart deploy/promos