Saltar al contenido

Plantilla de flujo de trabajo de GitHub Actions para Go

Última actualización

Este es un .github/workflows/ci.yml funcional para un módulo de Go. Lee la versión de Go desde go.mod, almacena en caché los módulos y la salida de compilación, y ejecuta go vet, golangci-lint y las pruebas con el detector de carreras.

El flujo de trabajo

name: CI

on:
  push:
    branches: [main]
  pull_request:

permissions:
  contents: read

concurrency:
  group: ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

jobs:
  lint:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version-file: go.mod
      - run: go vet ./...
      - uses: golangci/golangci-lint-action@v8
        with:
          version: latest

  test:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version-file: go.mod
          cache-dependency-path: go.sum
      - run: go build ./...
      - run: go test -race -count=1 -coverprofile=coverage.out ./...

Qué hacen las partes menos evidentes

  • go-version-file: go.mod usa la versión que declara su módulo, de modo que el CI sigue la directiva go sin un segundo lugar que actualizar.
  • La caché es automática. setup-go v4 y posteriores almacenan en caché la caché de descarga de módulos y la caché de compilación, indexadas por go.sum. Por eso no hay un paso actions/cache aparte. cache-dependency-path solo es necesario cuando go.sum no está en la raíz del repositorio, por ejemplo en un monorepo.
  • Dos trabajos. El linting y las pruebas se ejecutan en paralelo en máquinas separadas, así que obtiene como retroalimentación el más rápido de los dos y como tiempo total el más lento.
  • golangci-lint-action gestiona su propia caché y anota las diferencias. Fije una versión de lint, no latest, si necesita resultados repetibles. Consulte el README de la acción para conocer la versión principal actual antes de copiarla.
  • go test -race activa el detector de carreras. Hace las pruebas más lentas y consume más memoria, pero detecta errores reales de concurrencia. Elimínelo si es necesario, pero pruébelo primero.
  • -count=1 desactiva la caché de resultados de pruebas de Go. Los resultados se almacenan en caché solo por máquina, así que en runners de CI nuevos no hace diferencia, pero mantiene las ejecuciones idénticas a las ejecuciones locales con -count=1.

Variantes

Matriz de versiones

Añada matrix.go: ["1.23", "1.24"] y use go-version: ${{ matrix.go }} en lugar de go-version-file. Solo es necesario en librerías; las aplicaciones deben probar la versión que distribuyen. Consulte compilaciones en matriz.

Pruebas con base de datos

Añada un bloque services:. La plantilla de Django muestra un servicio de Postgres con comprobaciones de estado, y el mismo bloque funciona para Go.

Monorepo

Use working-directory: y un filtro paths:, y apunte cache-dependency-path al go.sum de cada módulo.

Compilación y publicación

Añada un trabajo que ejecute go build -trimpath -ldflags="-s -w" y suba el binario como artefacto, o use GoReleaser con etiquetas.

macOS o Windows

Añádalos a una matriz si distribuye binarios para esos sistemas.

Ejecútelo en máquinas más rápidas

Go compila y prueba en paralelo, así que más núcleos ayudan directamente. Cambie una línea en cada trabajo:

    runs-on: [self-hosted, Linux, compiler-ci]

El trabajo se ejecuta en una máquina nueva de 8 vCPU de compiler.dev, con una alternativa a su runner original. La prueba comparativa de compiler.dev de una aplicación React y Go con go test -race pasó de 6m13s a 2m42s; consulte pruebas comparativas. Más información en acelerar Go en GitHub Actions y en precios.

Preguntas frecuentes

¿Necesito actions/cache para los módulos de Go?

No con setup-go v4 o posterior. Almacena en caché los módulos y la salida de compilación por defecto.

¿Por qué la primera ejecución es lenta y las siguientes rápidas?

La primera ejecución llena la caché de compilación. Las siguientes reutilizan los paquetes compilados.

¿Debo ejecutar el detector de carreras en cada push?

Si encaja en su presupuesto de tiempo, sí. Si no, ejecútelo en main y cada noche.

¿Cómo evito que el linting falle por código antiguo?

Establezca only-new-issues: true en la acción de lint.