Saltar al contenido

CI más rápido para monorepos de Bazel en GitHub Actions

Última actualización

Bazel ya es incremental, así que una CI rápida depende sobre todo de dos cosas: una caché remota compartida, para que un runner nuevo no reconstruya lo que ya construyó otra ejecución, y, en repositorios grandes, ejecutar solo los targets que un cambio puede afectar. La caché de Bazel está diseñada para ser correcta, lo que permite compartirla con seguridad. El trabajo consiste en integrarla en GitHub Actions.

Por qué la CI sigue siendo lenta aunque use Bazel

Un runner nuevo de GitHub Actions tiene un output base vacío y una caché de disco vacía. Bazel reconstruye entonces todos los targets la primera vez. La incrementalidad solo ayuda si el estado se conserva entre ejecuciones. Tiene tres lugares donde guardarlo:

UbicaciónSe conserva entre ejecucionesCompartido entre runnersNotas
Disco del runnerNoNoUna VM nueva en cada job
actions/cache de la caché de discoSíSí, con límites de alcanceLimitado por 10 GB y por el alcance de la rama
Servidor de caché remotaSíSíLa mejor opción a escala

Caché remota

La documentación de caché remota de Bazel (revisada en octubre de 2026) usa --remote_cache para definir el endpoint (HTTP, HTTPS, gRPC o gRPCS) y describe las credenciales en la URL para configuraciones sencillas, lo cual solo es seguro sobre HTTPS. Coloque los flags en .bazelrc bajo una configuración ci para que los desarrolladores y la CI compartan una única definición:

# .bazelrc
build:ci --remote_cache=https://cache.example.com
build:ci --remote_upload_local_results=false

La documentación describe --remote_upload_local_results=false como un modo en el que la compilación solo lee de la caché remota, y recomienda que solo el sistema de CI tenga acceso de escritura. Vaya un paso más allá: permita escribir solo a las compilaciones de confianza en main.

# passed from the workflow for main only
build:ci-write --config=ci
build:ci-write --remote_upload_local_results=true

Así, los pull requests leen lo que construyó main y no pueden contaminarlo. Existen servidores de caché alojados y autoalojados; elija el que se ajuste a sus necesidades de seguridad. No recomendamos un proveedor concreto, porque la elección depende de la ubicación de sus datos y de su escala.

Alternativa con caché de disco

Si todavía no tiene un servidor, --disk_cache apunta Bazel a un directorio local. Guárdelo con actions/cache:

- uses: actions/cache@v6
  with:
    path: ~/.cache/bazel-disk
    key: bazel-${{ runner.os }}-${{ hashFiles('MODULE.bazel', 'MODULE.bazel.lock', '.bazelversion') }}-${{ github.sha }}
    restore-keys: |
      bazel-${{ runner.os }}-${{ hashFiles('MODULE.bazel', 'MODULE.bazel.lock', '.bazelversion') }}-
- run: bazel build --disk_cache=~/.cache/bazel-disk //...

La caché de disco crece sin límite por defecto. La documentación de Bazel menciona los flags de recolección de basura --experimental_disk_cache_gc_max_size y --experimental_disk_cache_gc_max_age a partir de Bazel 7.4. Configure uno de ellos, o alcanzará el límite de 10 GB del repositorio y se producirán desalojos; consulte límites de caché.

Ejecuciones solo de lo afectado: determinación de targets

En un monorepo grande, bazel test //... en cada PR desperdicia tiempo incluso con caché, porque el análisis y las búsquedas en caché de miles de targets se acumulan. La determinación de targets identifica qué targets cambiaron entre dos commits.

El Target Determinator de código abierto (bazel-contrib/target-determinator, revisado en octubre de 2026) recibe una revisión anterior e imprime los targets afectados por stdout, uno por línea, en relación con la revisión actualmente extraída. Se distribuye como binarios publicados. Su README también describe un binario driver que ejecuta directamente las pruebas de los targets afectados, y omite por defecto las pruebas afectadas etiquetadas como manual.

- uses: actions/checkout@v6
  with:
    fetch-depth: 0
- name: Find affected targets
  run: |
    BASE=$(git merge-base origin/${{ github.base_ref }} HEAD)
    ./tools/target-determinator -bazel bazel "$BASE" > affected.txt
- name: Test affected
  run: |
    if [ -s affected.txt ]; then
      bazel test --config=ci --target_pattern_file=affected.txt
    fi

Consulte el README para conocer la línea de comandos exacta de la versión que descargue: allí se documentan la lista de flags (-bazel, -bazel-opts, -targets, -working-directory) y el argumento posicional de la revisión anterior. Fije la versión que descargue y verifique la suma de comprobación.

Como la herramienta compara dos revisiones, necesita que el commit base esté presente localmente, así que use fetch-depth: 0. Tenga en cuenta que solo puede ser tan precisa como su grafo de compilación. Un cambio en MODULE.bazel, .bazelrc o en una toolchain afecta legítimamente a todo.

¿Merece la pena ejecutar solo lo afectado? Con una caché remota caliente, los targets no afectados son aciertos de caché y cuestan segundos, así que en repositorios pequeños y medianos bazel test //... es más sencillo y igual de rápido. Añada la determinación de targets cuando el tiempo de análisis sea el problema en sí.

Sharding y paralelismo

Bazel paraleliza las acciones entre núcleos con --jobs, cuyo valor por defecto se calcula según la CPU. Una máquina más grande acelera directamente las compilaciones en frío. Para dividir las pruebas dentro de Bazel, use shard_count en las reglas de test. Para repartir entre varias máquinas:

  1. Matriz por grupos de targets. Consulte los targets de test, divida la lista y ejecute cada porción en su propio job. Todos los jobs comparten la caché remota.
  2. Ejecución remota. Bazel puede ejecutar acciones en un clúster remoto (--remote_executor), lo que escala más allá de una sola máquina, pero requiere infraestructura y compilaciones herméticas.
strategy:
  matrix:
    slice: [0, 1, 2, 3]
steps:
  - run: |
      bazel query 'kind(".*_test", //...)' --output=label | sort > all.txt
      split -n l/4 -d all.txt part-
      bazel test --config=ci --target_pattern_file=part-0${{ matrix.slice }}

Consulte sharding de tests en GitHub Actions para equilibrar las porciones según su duración.

Un workflow completo

name: CI
on:
  push:
    branches: [main]
  pull_request:

jobs:
  bazel:
    runs-on: [self-hosted, Linux, compiler-ci]   # or ubuntu-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Build and test (PR, read-only cache)
        if: github.event_name == 'pull_request'
        run: bazel test --config=ci //...
      - name: Build and test (main, writes cache)
        if: github.event_name == 'push'
        run: bazel test --config=ci-write //...

Bazel consume mucha CPU y memoria. La línea runs-on es el único cambio específico de compiler.dev: ejecuta el mismo workflow en una máquina de 8 vCPU y 16 GB a $0.008 por minuto, con los jobs de Bazel escalando a los núcleos. Hay tamaños mayores (16 y 32 vCPU) disponibles; consulte precios y el selector de tamaño de runner.

Errores comunes

  1. Acciones no herméticas. Las acciones que leen el reloj, la red o el entorno del host generan salidas distintas en cada máquina e impiden compartir la caché. Corrija la acción, no la caché.
  2. Todos escriben en la caché. Una entrada incorrecta se propaga. Restrinja las escrituras.
  3. Clon superficial con determinación de targets. Falta el commit base.
  4. Caché de disco sin límite. Desplazará sus otras cachés.
  5. Toolchains distintas en cada runner. Fije Bazel con .bazelversion y las toolchains en MODULE.bazel.

Compare con Nx y Turborepo si parte de su repositorio es JavaScript.

Preguntas frecuentes

¿Necesito una caché remota para Bazel en CI?

En la práctica, sí. Sin una, cada runner nuevo compila desde cero. Una caché de disco con actions/cache es solo una solución provisional.

¿Es necesaria la determinación de objetivos?

No. Con una caché remota ya caliente, //... resuelve casi todo como aciertos de caché. Compensa cuando el análisis de un grafo de objetivos muy grande es lento.

¿Deberían los PR subir datos a la caché remota?

Es más seguro que no. Deje que las compilaciones de main de confianza escriban y que los PR solo lean.

¿Qué tamaño debe tener la máquina de CI?

Bazel usa todos los núcleos que se le asignan. Más núcleos aceleran casi linealmente las compilaciones en frío hasta que la memoria o la E/S (I/O) se convierten en el límite; mídalo en su repositorio.

Ejecute esta build de monorepo en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis