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 Ndefine cuántos paquetes se prueban al mismo tiempo. Su valor predeterminado esGOMAXPROCS, es decir, el número de CPU. Los paquetes se ejecutan como procesos separados.go test -parallel Ndefine cuántos tests dentro de un mismo paquete pueden ejecutarse a la vez, pero solo los tests que llaman at.Parallel(). También tiene como valor predeterminadoGOMAXPROCS.
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.
Relacionado
- Acelere un monorepo de TypeScript en GitHub ActionsAcelere la comprobación de tipos y el linting en un monorepo TypeScript con GitHub Actions: tsc incremental, referencias de proyecto y cachés.
- Acelere Playwright en un monorepo con GitHub ActionsAcelere las pruebas e2e de Playwright en un monorepo Node con GitHub Actions: compile la app una vez y omita e2e si no cambió.
- Añada una insignia de velocidad de CI a su READMEMuestre la velocidad de su CI con una insignia en el README: el tiempo mediano de ejecución en GitHub Actions, actualizado automáticamente. Gratis.
- Acelere .NET en GitHub ActionsAcelere las compilaciones de .NET en GitHub Actions: caché de NuGet con setup-dotnet, --no-restore, --no-build, dotnet test en paralelo y servicios SQL.