Saltar al contenido

Acelere Go en GitHub Actions

Última actualización

Para acelerar Go en GitHub Actions, use actions/setup-go con su caché integrada, mantenga GOCACHE caliente para que los paquetes sin cambios no se vuelvan a compilar, ejecute los paquetes en paralelo con go test -p y ejecute el detector de carreras en un job aparte. Go compila rápido, así que la mayor parte del tiempo perdido se debe a volver a descargar módulos y reconstruir lo que no ha cambiado.

Esta guía es la versión para Go de nuestra guía general para acelerar GitHub Actions.

Caché de módulos y de compilación

actions/setup-go usa caché por defecto. Su README indica que la entrada cache tiene como valor predeterminado true, y que la clave de caché se basa en su archivo de dependencias (go.sum o go.mod), salvo que defina cache-dependency-path con otros archivos (acepta globs). La caché guarda tanto la caché de descarga de módulos como la caché de compilación de Go, por lo que go mod download y los paquetes compilados se recuperan al acertar.

- uses: actions/checkout@v7
- uses: actions/setup-go@v7
  with:
    go-version-file: go.mod
    cache-dependency-path: |
      go.sum
      tools/go.sum

go-version-file lee la versión de go.mod, go.work o .go-version, así que CI y su portátil se mantienen sincronizados. Si define también go-version, esta última tiene prioridad.

En GitHub Actions las entradas de caché son inmutables, y esta clave solo cambia cuando cambia go.sum. Eso significa que los cambios en el código fuente no actualizan la caché de compilación tras el primer guardado para un mismo go.sum. En un repositorio grande, es una limitación real: la caché de compilación restaurada se vuelve obsoleta con las semanas. Una solución es usar cache: false y gestionar ~/.cache/go-build usted mismo con una clave que incluya el commit y un prefijo en restore-keys:

- uses: actions/setup-go@v7
  with:
    go-version-file: go.mod
    cache: false
- uses: actions/cache@v6
  with:
    path: |
      ~/go/pkg/mod
      ~/.cache/go-build
    key: go-${{ runner.os }}-${{ hashFiles('**/go.sum') }}-${{ github.sha }}
    restore-keys: |
      go-${{ runner.os }}-${{ hashFiles('**/go.sum') }}-
      go-${{ runner.os }}-

Eso crea una entrada nueva por commit, así que vigile su cuota; consulte los límites de caché. Guarde solo en main con actions/cache/save si el almacenamiento es limitado, y restaure en el resto de casos.

Paralelismo de tests: -p y -parallel

Dos opciones distintas:

  • go test -p N define cuántos paquetes se prueban al mismo tiempo. Su valor predeterminado es GOMAXPROCS, es decir, el número de CPU. Los paquetes se ejecutan como procesos separados.
  • go test -parallel N define cuántos tests dentro de un mismo paquete pueden ejecutarse a la vez, pero solo los tests que llaman a t.Parallel(). También tiene como valor predeterminado GOMAXPROCS.

Por tanto, añadir núcleos acelera automáticamente una suite de Go si tiene muchos paquetes. Si la mayoría de sus tests están en un único paquete grande sin t.Parallel(), los núcleos adicionales no sirven de nada para ese paquete. Añada t.Parallel() a los tests independientes, y nunca a los tests que comparten una fila de base de datos o una variable global.

Flags útiles en CI:

go test ./... -count=1 -shuffle=on -timeout=10m

-count=1 desactiva la caché de resultados de tests de Go, que normalmente conviene en CI para tests que interactúan con el exterior. Si sus tests son puros, dejar la caché activa permite que una GOCACHE caliente omita por completo los paquetes sin cambios, lo que supone un gran ahorro.

El coste de -race

El detector de carreras instrumenta los accesos a memoria. La documentación del detector de carreras de Go indica que puede aumentar el tiempo de ejecución entre 2 y 20 veces y el uso de memoria entre 5 y 10 veces, así que una suite de tests con -race suele ser varias veces más lenta. No lo elimine, porque detecta errores reales, pero tampoco lo ejecute tres veces en una matriz.

Una configuración habitual es un job rápido sin -race para cada push, y un job con -race que se ejecuta en paralelo y es obligatorio para fusionar:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-go@v7
        with:
          go-version-file: go.mod
      - run: go test ./... -count=1
  race:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-go@v7
        with:
          go-version-file: go.mod
      - run: go test ./... -race -count=1

Ambos jobs terminan al ritmo del más lento, pero obtiene una respuesta rápida en los logs del primero. Las compilaciones con race necesitan cgo, así que usan una compilación distinta a las normales y una caché de compilación separada; la caché del job sin race no le servirá.

Análisis con golangci-lint

golangci-lint puede tardar más que los tests en repositorios grandes. Use la acción oficial golangci/golangci-lint-action, consulte su README para conocer las entradas y la versión actuales, y ejecútela como job propio para que se solape con los tests. Esa acción guarda en caché los resultados de análisis por defecto.

Compile una vez, distribuya una vez

Para imágenes Docker, compile con un cache mount en el Dockerfile (RUN --mount=type=cache,target=/root/.cache/go-build go build ...) y construya con la caché de capas de BuildKit. Consulte caché de capas de Docker en CI. ¿Compila de forma cruzada para varios destinos? Use una matriz de GOOS/GOARCH en lugar de emulación, ya que Go realiza la compilación cruzada de forma nativa.

Lo que aportan más núcleos de CPU

Go usa todos los núcleos tanto para compilar como para ejecutar pruebas, por lo que es una de las opciones más adecuadas para un runner más grande. Nuestros benchmarks incluyen una pila React + Go + Postgres con go test -race: 6m13s en un runner alojado en GitHub y 2m42s en compiler.dev (2.3x), una ejecución completa de CI con 10 particiones de pruebas y una base de datos real, medida el 8 de octubre de 2026. Una pila Next.js + Go + Kafka + Redis pasó de 1m16s a 0m44s (1.7x). Son pipelines completos, así que su proporción depende de cuánto tiempo de su ejecución corresponde a la compilación y las pruebas de Go.

Para cambiar un job a compiler.dev, use runs-on: [self-hosted, Linux, compiler-ci]. Los tamaños de máquina y los precios están en la página de precios, y el selector de tamaño de runner le ayuda a elegir uno. Consulte también la plantilla para Go y el sharding de tests.

Preguntas frecuentes

¿setup-go guarda automáticamente en caché los módulos de Go?

Sí. La entrada cache tiene como valor predeterminado true y guarda las cachés de módulos y de compilación, indexadas por su archivo de dependencias, salvo que defina cache-dependency-path.

¿Cuál es la diferencia entre go test -p y -parallel?

-p es cuántos paquetes se prueban a la vez. -parallel es cuántos tests t.Parallel() se ejecutan a la vez dentro de un paquete. Ambos tienen como valor predeterminado el número de CPU.

¿Cuánto más lento es go test -race?

La documentación de Go indica que es entre 2 y 20 veces más lento. En la práctica, una suite con esperas de I/O notará una mejora menor. Ejecútela en su propio job.

¿Debo usar -count=1 en CI?

Úselo cuando los tests accedan a bases de datos o a la red, para que no se reutilicen resultados en caché. Para tests unitarios puros, deje la caché activa.

Ejecute esta compilación de Go en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis