how-i-build
Hormigas rojas en fila india sobre hojas verdes, varias de ellas sujetando los bordes de una hoja doblada
Infraestructura

Las puertas que había dejado abiertas

Un deploy que salió con un test en rojo, una API que le respondía a cualquiera, un error que moría en un log y un monitor que decía que todo estaba bien. Lo que encontré al cerrar cada una.

6 min de lectura


Pasé una tarde cerrando las puertas que Orbit había dejado abiertas en producción. Ninguna era un bug. Todas eran cosas que yo nunca había decidido, y por eso se quedaron en el valor por defecto; y el valor por defecto de casi todo es "abierto".

Cinco puertas, cinco hallazgos. Los hallazgos son más interesantes que las puertas.

Exigir los tests no es exigir los jobs

El primer punto parecía trivial: impedir que un commit con un test en rojo llegara a producción. GitHub tiene protección de ramas; solo marcas qué checks son obligatorios.

Salvo que mi CI se salta lo que no cambió. Si un pull request solo toca el frontend, el job del backend nunca corre. Y esta es la parte que yo no sabía: un job saltado no reporta ningún estado. No es verde ni rojo: simplemente no existe para quien está esperando. Marcar "backend" como obligatorio bloquearía para siempre cada pull request que no toque el backend, esperando un resultado que nunca llega.

La salida es un job final que siempre corre, depende de todos los demás, y falla si alguno de ellos falló:

ci-ok:
  needs: [changes, backend, web, docker]
  if: always()
  steps:
    - run: |
        for r in "${{ needs.backend.result }}" "${{ needs.web.result }}"; do
          case "$r" in
            success|skipped) ;;
            *) exit 1 ;;
          esac
        done

skipped cuenta como éxito. Es la única forma de que un check condicional pueda ser obligatorio.

Después descubrí que la protección de ramas en un repositorio privado es una función paga en GitHub. Está bien: el candado que importa no es el del merge, es el del deploy. El host de la API tiene una opción para publicar solo después de que pasen los checks, y esa es gratis. Un commit malo todavía puede caer en la rama, pero no llega a producción, que era el problema real.

El rollback devuelve el código, no la base de datos

El segundo punto era una regla, no código. El panel del host tiene un botón de rollback que vuelve a la imagen anterior en más o menos un minuto. Yo confiaba en él.

Lo que el botón no hace es revertir la base de datos. Las migraciones corren al arrancar, así que después de un rollback el código viejo corre contra el esquema nuevo. Si la migración solo agregó una columna, bien: el código viejo ignora lo que no conoce. Si eliminó o renombró una, el código viejo se rompe en la primera consulta, y ningún botón arregla eso.

De ahí la regla que escribí y puse en el checklist del pull request: un release solo agrega. Eliminar y renombrar esperan a un release posterior, cuando ninguna versión en ejecución los use más. Cambiar el tipo de una columna pasó a ser cinco pasos en lugar de uno. Es más tedioso, y es lo que mantiene al botón de rollback como un botón de verdad.

La puerta trasera que la CDN nunca vio

La API tiene su propio dominio, pero el host también entrega una dirección pública que apunta directo a ella. Cualquiera que encontrara esa dirección hablaba con la API sin nada en medio.

El plan era el estándar: la CDN le pone un header secreto a cada petición que pasa por ella, y la API rechaza a cualquiera sin el sello. Escribí el middleware, lo probé, y solo entonces fui a mirar el DNS.

El registro de la API apuntaba al host sin proxy. La CDN solo resolvía el nombre: el tráfico pasaba directo, y nunca veía la petición. No había nada sobre lo cual poner sello alguno. El server: cloudflare que yo veía todo el tiempo en la respuesta era la CDN del propio host, no la mía.

El paso cero, que no aparecía en ningún plan, fue activar el proxy para ese registro. Treinta segundos de clics, después de tres horas escribiendo la parte difícil.

La segunda lección fue sobre el orden. Activados en el orden equivocado, los dos lados se tumban entre sí: una API que exige un sello que nadie pone es una API que rechaza a todos. Así que el middleware nació apagado:

func OriginSecret(secret string) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		if secret == "" {
			return next
		}
		...

Secreto vacío, middleware transparente. Puedes publicar la API primero, crear la regla en la CDN después, y llenar el secreto al final. Y para apagarlo en una emergencia basta con vaciar el valor, sin deploy.

Las rutas de health quedan fuera de la verificación, porque la sonda de salud del propio host le pega al servicio directamente, sin pasar por la CDN. Si me hubiera olvidado de eso, la plataforma habría concluido que la API estaba muerta y la habría reiniciado para siempre.

Un error que nadie ve

La tercera puerta era la más silenciosa: un 500 moría en el log del host. Solo me enteraría si iba a buscarlo, y no iba a ir a buscarlo.

Conectar un rastreador de errores fue el punto más simple de todos, y el que más cambió la sensación de estar en producción. Un panic ahora llega con el stack, la ruta y el request id, en lugar de volverse una línea que nadie lee.

La única decisión real fue qué no activar. El plan gratuito da cinco mil eventos al mes, y el tracing de rendimiento y el session replay se comen esa cuota rápido para responder preguntas que el log ya responde. Dejé los dos en cero. Un monitor que agota su cuota el día 12 es peor que no tener monitor.

El monitor que decía 200

La última puerta fue la que más me enseñó.

Yo ya tenía un vigilante propio: un worker que hace ping a mis servicios y me avisa cuando uno se cae. El problema es que no puede reportar sobre sí mismo. Si se detiene, el silencio es idéntico a "todo está bien".

Así que le puse un monitor externo, en un servicio que no comparte nada con mi infraestructura, apuntando a la página de estado del worker. Responde 200, el monitor está contento, y me sentí cubierto.

Error. La página se sirve desde un estado en caché: responde 200 aunque no haya habido ningún ping en las últimas seis horas. Mostraría datos viejos, con aspecto perfecto, y el monitor externo no notaría nada. Había construido un vigilante para el vigilante que estaba mirando para el lado equivocado.

El arreglo son veinte líneas: una ruta de health que devuelve 500 cuando el último ciclo pasó su plazo.

{
  "ok": true,
  "crons": {
    "fast":  { "ageMinutes": 3,   "limitMinutes": 30 },
    "daily": { "ageMinutes": 862, "limitMinutes": 1560 }
  }
}

El monitor externo ahora apunta a esa ruta. Dejó de preguntar "¿el servidor responde?" y empezó a preguntar "¿el trabajo está ocurriendo?". Son preguntas distintas, y solo la segunda importa.

Lo que quedó

La regla que me llevo de esas cinco puertas es una: el valor por defecto nunca es seguro, porque el valor por defecto no lo eligió nadie. El deploy sale sin preguntar, la puerta trasera queda abierta, el error va a un log que nadie lee, y el monitor responde la pregunta más fácil en lugar de la correcta.

Y una segunda, aprendida a la mala: revisa el paso antes del paso. Tres horas de middleware antes de descubrir que el tráfico ni siquiera iba a donde yo creía. Media hora leyendo la configuración habría cambiado el orden de todo el trabajo.

Las hormigas de la foto pasan el día sosteniendo el borde de una hoja para cerrar el nido. Ninguna la sostiene sola, y ninguna eligió la hoja: cierran lo que está abierto, una a la vez.