Cómo redujimos el tiempo de espera de nuestra CI de 30 minutos a 5 minutos
La CI lenta es una de esas cosas que sacan de quicio a los equipos de ingeniería. Los ingenieros esperan más para recibir feedback, aumenta el cambio de contexto y crece la tentación de agrupar cambios, lo que solo empeora las cosas. Pasamos unas semanas optimizando nuestros workflows de GitHub Actions y redujimos nuestras comprobaciones de PR de 30 minutos a 5 minutos. Eso supone una reducción del 83 % en el tiempo de espera, lograda sin sacrificar cobertura de pruebas ni quality gates. No hubo una única solución mágica. Miramos adónde se iba realmente el tiempo y aplicamos tres principios: dependencias de trabajos inteligentes, caché agresiva y sharding de pruebas. Esto es lo que aprendimos.



La base: migrar a Blacksmith
De hecho ya habíamos intentado migrar a Blacksmith antes, pero nos encontramos con problemas. Con una rama main tan activa como la nuestra, no queríamos lidiar con inestabilidad en la CI. Esta vez, la migración fue sencilla (#26247): sustituir los runners buildjet-*vcpu-ubuntu-2204 por blacksmith-*vcpu-ubuntu-2404 en 28 archivos de workflow, cambiar las acciones cache y setup-node, y ajustar las asignaciones de vCPU. El único problema real que tuvimos fue el de la caché corrupta con archivos .next (más sobre esto en la sección de caché).
Una vez actualizado, notamos al instante una mejora de 2x en la velocidad al descargar la caché. Como yarn install ocupa 1,2 GB, eso ahorra alrededor de 22 segundos en cada trabajo que necesita ejecutar yarn install, que son la mayoría. También estamos aprovechando el container caching de Blacksmith para servicios usados en muchos trabajos (Postgres, Redis, Mailhog). El trabajo Initialize containers ahora se ha reducido en más de un 50 %, de 20 segundos a 9 segundos.
jobs:
build:
name: Build Web App
runs-on: blacksmith-4vcpu-ubuntu-2404
steps:
- uses: actions/checkout@v4
- uses: ./.github/actions/yarn-install
- uses: ./.github/actions/cache-build
Lo que tuvimos que arreglar
Los runners de Blacksmith exponen el número de CPU de la máquina anfitriona en lugar de las vCPU asignadas (normalmente 4). Playwright, muy servicial, lanzaba workers para coincidir con eso, lo que provocaba contención de recursos y fallos intermitentes en las pruebas. Solo tuvimos que limitar explícitamente los workers con --workers=4 para que coincidiera con nuestra asignación real.
También descubrimos que una mayor paralelización exponía condiciones de carrera en nuestra lógica de limpieza de pruebas. Las pruebas de integración que funcionaban bien en secuencia chocaban al ejecutarse en paralelo y producían errores de idempotencyKey. La solución exigió replantear cómo limpian las pruebas después de ejecutarse: consultar las reservas por eventTypeId en lugar de rastrear IDs de reserva individuales, algo que se estaba perdiendo reservas creadas indirectamente por el código bajo prueba (#26269, #26278, #26283).
Incluso nuestras pruebas de capturas de pantalla necesitaban ajustes (#26247). Distintos runners tienen diferencias sutiles en el renderizado de fuentes, así que añadimos deviceScaleFactor: 1 para un renderizado consistente y aumentamos ligeramente nuestro umbral de diferencias de 0.05 a 0.07 para tener en cuenta variaciones de antialiasing sin ocultar regresiones reales.
Moverse más rápido suele sacar a la luz acoplamientos ocultos en tu sistema. El acoplamiento siempre estaba ahí; simplemente no podías verlo a menor velocidad. Corregir estos problemas es lo que permite mejoras de velocidad sostenibles.
Principio 1: acorta la ruta crítica con diseño de dependencias
Para nosotros, un gran problema era que lint estaba bloqueando cosas que no debería bloquear. Cuando tus pruebas E2E tardan entre 7 y 10 minutos, frenarlas por 2 o 3 minutos de lint y comprobaciones de tipos solo hace que todo el workflow dure más. El lint terminará mucho antes que las E2E, así que ¿por qué no dejar que se ejecuten en paralelo?
Desacopla suites de pruebas que no dependan entre sí
Nuestras pruebas de integración y la suite principal de E2E no necesitan la compilación de API v2, así que eliminamos esa dependencia (#26170). Al contrario, las pruebas E2E de API v2 no necesitan la compilación principal de la web. Ahora cada suite de pruebas depende solo de lo que realmente necesita, lo que permite la máxima paralelización.
Consolida los trabajos de preflight
Teníamos trabajos separados para detectar cambios en archivos (changes) y para comprobar la etiqueta E2E (check-label). Cada trabajo tiene un coste de arranque: levantar un runner, hacer checkout del código, restaurar el contexto. Al fusionarlos en un único trabajo prepare, eliminamos sobrecostes redundantes (#26101). Fuimos más allá y también movimos los pasos de instalación de dependencias al trabajo prepare, ahorrando otros 20 segundos por workflow al eliminar otro límite entre trabajos (#26320).
Haz que los informes no bloqueen
Los informes de pruebas E2E son útiles, pero no deberían estar en la ruta crítica. Trasladamos los trabajos merge-reports, publish-report y cleanup-report a un workflow separado activado por workflow_run (#26157). Ahora los ingenieros pueden volver a ejecutar inmediatamente los trabajos fallidos sin esperar a que termine la generación del informe.
name: E2E Report
on:
workflow_run:
workflows: ["PR Update"]
types:
- completed
La regla es sencilla: sé flexible a la hora de dejar que los trabajos E2E empiecen antes, no después. No bloquees trabajos de larga duración con prerequisitos de corta duración salvo que exista una dependencia real. El tiempo de pared de tu CI lo determina la ruta crítica, y cada dependencia innecesaria alarga esa ruta.
Principio 2: la caché es clave (pero solo si acierta)
Una caché eficaz necesita claves que se invaliden cuando deben, se mantengan estables cuando deben, y un almacén de caché que siga sano con el tiempo.
Aprovecha lookup-only
Nuestra mejora más drástica en caché vino de una observación sencilla: estábamos descargando aproximadamente 1,2 GB de datos en caché incluso cuando no necesitábamos instalar nada. La caché existía, el acierto era correcto, pero seguíamos pagando el coste de descarga antes de descubrir que podíamos saltarnos el paso de instalación.
La solución fue usar comprobaciones de caché lookup-only (#26314). Tenemos pasos dedicados que se ejecutan antes de todos los trabajos para asegurarse de que las dependencias están instaladas, así que cuando se ejecutan los trabajos individuales ya sabemos que la caché existe. Antes de intentar restaurar la caché completa, primero comprobamos si existe sin descargarla. Si todas las cachés aciertan, nos saltamos todo el flujo de restauración e instalación. Sin descargas, sin instalaciones, solo seguimos con el trabajo real. Solo esto ya ahorró bastante tiempo en cada escenario con acierto de caché, que, con un diseño correcto de claves de caché, debería ser la mayoría de ejecuciones.
- name: Check yarn cache (lookup-only)
if: ${{ inputs.skip-install-if-cache-hit == 'true' }}
uses: actions/cache/restore@v4
id: yarn-download-cache-check
with:
path: ${{ steps.yarn-config.outputs.CACHE_FOLDER }}
key: yarn-download-cache-${{ hashFiles('yarn.lock') }}
lookup-only: true
Aplicamos la misma lógica a la instalación del navegador de Playwright (#26060). Como tenemos un paso dedicado que garantiza que los navegadores de Playwright estén en caché antes de que se ejecuten los trabajos de prueba, podemos usar el mismo enfoque lookup-only. Si la caché de Playwright acierta, se omite la instalación por completo. Ahora primero comprobamos y luego decidimos si descargar o no.
Extendimos este patrón a nuestra caché de base de datos también (#26344). Usando comprobaciones lookup-only, podemos saltarnos la reconstrucción de la caché de la BD cuando ya existe. También simplificamos la clave de caché eliminando el número de PR y el SHA, lo que la hace mucho más reutilizable entre ejecuciones.
Corrección de la caché
La corrección de la caché importa tanto como su velocidad. Descubrimos que nuestro patrón glob **/node_modules/ estaba capturando apps/web/.next/node_modules/, que es salida de compilación de Next.js con enlaces simbólicos y archivos generados que cambian durante las compilaciones. Esto provocaba archivos de caché corruptos con errores al extraer tar (#26268). La solución fue un patrón de exclusión sencillo, pero encontrarlo requería entender exactamente qué se estaba almacenando en caché y por qué.
También implementamos limpieza automática de la caché (#26312). Cuando se fusiona o se cierra un PR, ahora borramos sus cachés de compilación asociadas. Esto mantiene nuestro almacén de caché ligero y evita la acumulación de entradas obsoletas que ya no se volverían a usar. En el proceso simplificamos el formato de nuestra clave de caché, eliminando segmentos innecesarios como runner.os y node_version, que añadían complejidad sin mejorar la tasa de aciertos.
delete-cache-build-on-pr-close:
if: github.event_name == 'pull_request' && github.event.action == 'closed'
runs-on: blacksmith-2vcpu-ubuntu-2404
env:
CACHE_NAME: prod-build
steps:
- name: Delete cache-build cache
uses: useblacksmith/cache-delete@v1
with:
key: ${{ env.CACHE_NAME }}-${{ github.event.pull_request.head.ref }}
prefix: "true"
Turbo Remote Caching
Actualizamos a Next.js 16 (#26093), lo que redujo nuestras compilaciones de más de 6 minutos a ~1 minuto (gracias al equipo de Next.js por las enormes mejoras). Con Turbo Remote Caching activado, las compilaciones posteriores tardan solo 7 segundos en descargarse desde la caché, frente a ~1 minuto de una compilación completa.
También activamos Turbo Remote Caching para nuestras pruebas E2E de API v2 (#26331). Antes, cada shard de E2E recompilaba los paquetes de la plataforma desde cero. Ahora cada shard se beneficia de la caché remota de Turbo, y optimizamos la compilación TypeScript de Jest habilitando isolatedModules y desactivando los diagnósticos en CI, lo que acelera notablemente el inicio de las pruebas.
Principio 3: escala las pruebas con sharding
Cuando tienes más de 1.100 casos de prueba repartidos en 82 archivos de pruebas E2E, ejecutarlos en secuencia es dejar rendimiento sobre la mesa. El sharding de pruebas, que divide tu suite de pruebas entre varios runners en paralelo, es la forma más directa de reducir el tiempo de pared para suites grandes. Ya teníamos sharding en nuestra suite principal de E2E, pero lo aumentamos de 4 a 8 shards (#26342), lo que redujo otro minuto el tiempo total de la suite E2E. Nuestras pruebas E2E de API v2 seguían ejecutándose como un único trabajo.
Dividimos nuestras pruebas E2E de API v2 en 4 trabajos paralelos usando la opción integrada --shard de Jest (#26183). Cada shard se ejecuta de forma independiente con sus propios servicios de Postgres y Redis, y los artefactos se nombran de forma única por shard. Lo que antes tardaba más de 10 minutos como un único trabajo ahora termina bastante más rápido con la carga repartida entre cuatro runners.
- name: Run Tests
working-directory: apps/api/v2
run: |
yarn test:e2e:ci --shard=${{ matrix.shard }}/${{ strategy.job-total }}
EXIT_CODE=$?
echo "yarn test:e2e:ci --shard=${{ matrix.shard }}/${{ strategy.job-total }} command exit code: $EXIT_CODE"
exit $EXIT_CODE
El sharding a gran escala también saca a la luz problemas de infraestructura que podrías no notar con una ejecución secuencial. Cuando varios trabajos intentan poblar la misma caché de base de datos al mismo tiempo, aparecen condiciones de carrera. Lo solucionamos creando un trabajo dedicado setup-db que se ejecuta antes de todos los trabajos de pruebas E2E e integración (#26171). Este único trabajo llena la caché de la base de datos una sola vez, y todos los trabajos posteriores la restauran desde ahí. Sin carreras, sin trabajo duplicado.
También creamos un workflow dedicado para las pruebas unitarias de API v2, separándolas de la suite principal de pruebas (#26189). Esto les permite ejecutarse en paralelo con otras comprobaciones en lugar de competir por recursos dentro de un trabajo de pruebas monolítico.
El efecto acumulativo
Ninguno de estos cambios por separado habría reducido nuestro tiempo de CI un 83 %. Las mejoras vienen de su combinación.
Las dependencias inteligentes permiten que los trabajos empiecen antes. Una caché eficaz significa que esos trabajos pasan menos tiempo en la preparación. El sharding hace que la ejecución real de las pruebas ocurra en paralelo. Juntos, comprimen la ruta crítica desde todos los ángulos.
La inversión se acumula con el tiempo. Cada PR ahora recibe feedback más rápido. Los ingenieros se mantienen más tiempo en flujo. La tentación de agrupar cambios disminuye, lo que significa diffs más pequeños y más fáciles de revisar. La calidad del código mejora porque el ciclo de feedback es más corto.
Seguiremos invirtiendo en el rendimiento de la CI porque los resultados son reales y medibles. El objetivo no es la velocidad por sí misma; es permitir que los ingenieros entreguen software de calidad más rápido. Cuando la CI es rápida, avanzar deprisa y mantener estándares altos trabaja a favor, no en contra.
Pull requests citadas
Base: migración de Buildjet a Blacksmith
- #26247 - Migrar los workflows de GitHub de Buildjet a Blacksmith
Estabilidad de las pruebas
-
#26269 - Corregir pruebas e2e inestables con sesiones de usuario aisladas
-
#26278 - Estabilizar pruebas e2e con localizadores acotados y horarios deterministas
-
#26283 - Mejorar el aislamiento de pruebas para las pruebas e2e de managed scheduling link
Turbo Remote Caching
-
#26093 - Actualizar a Next 16 (compilaciones reducidas de más de 6 minutos a ~1 minuto)
-
#26331 - Activar Turbo Remote Caching (las compilaciones posteriores tardan 7 s)
Dependencias de trabajos y optimización del workflow
-
#26101 - Consolidar los trabajos changes y check-label en prepare
-
#26170 - Desacoplar las pruebas no relacionadas con API v2 de la compilación de API v2
-
#26157 - Hacer que los trabajos de informes E2E no bloqueen al moverlos a un workflow separado
-
#26320 - Mover el trabajo de deps al paso del trabajo prepare para ahorrar ~20 s por workflow
Aprovecha lookup-only
-
#26314 - Usar la comprobación de caché
lookup-onlypara saltarse las descargas del trabajo de deps -
#26060 - Saltarse la instalación de Playwright cuando hay acierto de caché
-
#26344 - Usar
lookup-onlypara la caché de la BD y simplificar la clave de caché
Corrección de la caché
-
#26268 - Excluir .next/node_modules de la caché de yarn para evitar corrupción
-
#26312 - Borrar entradas de caché-build al cerrar un PR
Sharding de pruebas e infraestructura
-
#26342 - Aumentar los shards E2E principales de 4 a 8 (ahorra 1 minuto)
-
#26183 - Dividir las pruebas E2E de API v2 en 4 trabajos paralelos
-
#26171 - Añadir un trabajo dedicado setup-db para eliminar la condición de carrera de la caché
-
#26189 - Crear un nuevo workflow para las pruebas unitarias de API v2
