Crear y probar Go

Introducción

Esta guía te muestra cómo compilar, probar y publicar un paquete de Go.

Los ejecutores hospedados en GitHub tienen un caché de herramientas con software preinstalado, el cual incluye las dependencias para Go. Para encontrar una lista completa de software actualizado y las versiones preinstaladas de Go, consulta la sección "Acerca de los ejecutores hospedados en GitHub".

Prerrequisitos

Ya debes estar familiarizado con la sintaxis de YAML y con cómo se utiliza con GitHub Actions. Para obtener más información, consulta la sección "Sintaxis de flujo de trabajo para las GitHub Actions".

Te recomendamos que tener un entendimiento básico del lenguaje de Go. Para obtener más información, consulta la sección Iniciar con Go.

Utilizar el flujo de trabajo inicial de Go

GitHub proporciona un flujo de trabajo inicial de Go que debería funcionar con la mayoría de los proyectos de Go. Esta guía incluye ejemplos que puedes utilizar para personalizar los flujos de trabajo iniciales. Para obtener más información, consulta el flujo de trabajo inicial de Go.

Para comenzar rápidamente, agrega el flujo de trabajo inicial al directorio de .github/workflows de tu repositorio.

name: Go package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Go
        uses: actions/setup-go@v3
        with:
          go-version: 1.15

      - name: Build
        run: go build -v ./...

      - name: Test
        run: go test -v ./...

Especificar una versión de Go

La forma más fácil de especificar una versión de Go es utilizando la acción setup-go que proporciona GitHub. Para obtener más información, consulta la acción de setup-go.

Para utilizar una versión preinstalada de Go en un ejecutor hospedado en GitHub, pasa la versión relevante a la propiedad go-version de la acción setup-go. Esta acción encuentra una versión específica de Go desde el caché de herramientas en cada ejecutor y agrega los binarios necesarios a PATH. Estos cambios persistirán para el recordatorio del job.

La acción setup-go es la forma recomendada de utilizar Go con las GitHub Actions, ya que esta ayuda a garantizar el comportamiento consistente a lo largo de los diferentes ejecutores y versiones de Go. Si estás utilizando un ejecutor auto-hospedado, debes instalar Go y agregarlo a PATH.

Utilizar versiones múltiples de Go

name: Go

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.14', '1.15', '1.16.x' ]

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go ${{ matrix.go-version }}
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      # You can test your matrix by printing the current Go version
      - name: Display Go version
        run: go version

Utilizar una versión específica de Go

Puedes configurar tu job para utilizar una versión específica de Go, tal como la 1.16.2. Como alternativa, puedes utilizar una sintaxis de versión semántica para obtener el último lanzamiento menor. Este ejemplo utiliza el último lanzamiento de parche de Go 1.16:

      - name: Setup Go 1.16.x
        uses: actions/setup-go@v3
        with:
          # Semantic version range syntax or exact version of Go
          go-version: '1.16.x'

Instalar dependencias

Puedes utilziar go get para instalar dependencias:

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
      - name: Install dependencies
        run: |
          go get .
          go get example.lab/octo-examplemodule
          go get example.lab/octo-examplemodule@v1.3.4

Almacenar dependencias en caché

Puedes almacenar en caché y restaurar las dependencias utilizando la acción setup-go. El almacenamiento en caché se encuentra inhabilitado predeterminadamente, pero puedes configurar el parámetro cache en true para habilitarlo.

Cuando se habilita el almacenamiento en caché, la acción setup-go busca el archivo de dependencia, go.sum, en la raíz del repositorio y utiliza el hash del archivo de dependencia como parte de la llave del caché.

      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
          cache: true

Como alternativa, puedes utilizar el parámetro cache-dependency-path para los casos en donde se utilizan archivos de dependencias múltiples o cuando se ubican en subdirectorios diferentes.

      - uses: actions/setup-go@v3
        with:
          go-version: '1.17'
          cache: true
          cache-dependency-path: subdir/go.sum

Si tienes un requisito personalizado o necesitas controles más exactos para almacenar en caché, puedes utilizar la acción cache. Para obtener más información, consulta la sección "Almacenar las dependencias en caché para agilizar los flujos de trabajo".

Construir y probar tu código

Puedes usar los mismos comandos que usas de forma local para construir y probar tu código. Este flujo de trabajo de ejemplo demuestra cómo utilizar go build y go test en un job:

name: Go
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
      - name: Install dependencies
        run: go get .
      - name: Build
        run: go build -v ./...
      - name: Test with the Go CLI
        run: go test

Empaquetar datos de flujo de trabajo como artefactos

Después de que se completa un flujo de trabajo, puedes cargar los artefactos que se den como resultado para su análisis. Por ejemplo, es posible que debas guardar los archivos de registro, los vaciados de memoria, los resultados de las pruebas o las capturas de pantalla. El siguiente ejemplo demuestra cómo puedes utilizar la acción upload-artifact para cargar los resultados de las pruebas.

Para obtener más información, consulta la sección "Almacenar los datos de los flujos de trabajo como artefactos".

name: Upload Go test results

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.14', '1.15', '1.16.x' ]

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      - name: Install dependencies
        run: go get .
      - name: Test with Go
        run: go test -json > TestResults-${{ matrix.go-version }}.json
      - name: Upload Go test results
        uses: actions/upload-artifact@v3
        with:
          name: Go-results-${{ matrix.go-version }}
          path: TestResults-${{ matrix.go-version }}.json