# Compilación y prueba de Go

Aprende a crear un flujo de trabajo de integración continua (CI) para compilar y probar tu proyecto de Go.

> \[!NOTE]
> Actualmente los ejecutores hospedados por GitHub Enterprise Server no se admiten en GitHub.

## Introducción

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

GitHubLos ejecutores hospedados tienen una caché de herramientas con software preinstalado, que incluye las dependencias de Go. Para obtener una lista completa de software actualizado y las versiones preinstaladas de Go, consulta [Ejecutores hospedados en GitHub](/es/enterprise-server@3.22/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images).

## Requisitos previos

Ya debería estar familiarizado con la sintaxis de YAML y cómo se usa con GitHub Actions. Para más información, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax).

Te recomendamos que tengas un entendimiento básico del lenguaje Go. Para más información, ve [Introducción a Go](https://golang.org/doc/tutorial/getting-started).

## Uso de una plantilla de flujo de trabajo de Go

Para comenzar rápidamente, agregue una plantilla de flujo de trabajo al directorio `.github/workflows` del repositorio.

GitHub proporciona una plantilla de flujo de trabajo de Go que debe funcionar para la mayoría de los proyectos de Go. En las secciones siguientes de esta guía se proporcionan ejemplos de cómo puede personalizar esta plantilla de flujo de trabajo.

1. En GitHub, navegue hasta la página principal del repositorio.

2. En el nombre del repositorio, haz clic en **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-play" aria-label="play" role="img"><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path></svg> Actions**.

   ![Captura de pantalla de las pestañas del repositorio "github/docs". La pestaña "Proyectos" aparece resaltada con un contorno naranja.](/assets/images/help/repository/actions-tab-global-nav-update.png)

3. Si ya tiene un flujo de trabajo en su repositorio, haga clic en **New workflow** (Nuevo flujo de trabajo).

4. En la página "Elegir un flujo de trabajo" se muestra una selección de plantillas de flujo de trabajo recomendadas. Busca «Go».

5. Filtra la selección de flujos de trabajo con un clic en **Integración continua**.

6. En el flujo de trabajo "Go - by GitHub Actions", haga clic en **Configurar**.

   ![Captura de pantalla de la página «Elegir un flujo de trabajo». El botón «Configurar» en el flujo de trabajo «Go» está resaltado con un contorno naranja.](/assets/images/help/actions/starter-workflow-go.png)
   Si no encuentra la plantilla de flujo de trabajo "Go - by GitHub Actions", copie el siguiente código de flujo de trabajo en un nuevo archivo llamado `go.yml` en el `.github/workflows` directorio del repositorio.

   ```yaml copy
   name: Go

   on:
     push:
       branches: [ "main" ]
     pull_request:
       branches: [ "main" ]

   jobs:
     build:

       runs-on: self-hosted
       steps:
         - uses: actions/checkout@v6

         - name: Set up Go
           uses: actions/setup-go@v5
           with:
             go-version: '1.20'

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

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

7. Edita el flujo de trabajo según sea necesario. Por ejemplo, cambia la versión de Go.

8. Haga clic en **Commit changes** (Confirmar cambios).

## Especificación de una versión de Go

La manera más fácil de especificar una versión de Go es mediante la `setup-go` acción proporcionada por GitHub. Para obtener más información, ve la [acción`setup-go`](https://github.com/actions/setup-go/).

Para usar una versión preinstalada de Go en un runner hospedado en GitHub, pase la versión correspondiente en la propiedad `go-version` de la acción `setup-go`. Esta acción busca una versión específica de Go en la caché de herramientas en cada ejecutor y agrega los binarios necesarios a `PATH`. Estos cambios persistirán para el resto del trabajo.

La `setup-go` acción es la forma recomendada de usar Go con GitHub Actions, ya que ayuda a garantizar un comportamiento coherente entre diferentes ejecutores y versiones diferentes de Go. Si vas a usar un ejecutor auto hospedado, tienes que instalar Go y agregarlo a `PATH`.

### Uso de varias versiones de Go

```yaml copy
name: Go

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

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

### Uso de una versión específica de Go

Puedes configurar el trabajo para que use una versión específica de Go, como `1.20.8`. Como alternativa, puedes utilizar una sintaxis de versión semántica para obtener el último lanzamiento menor. Este ejemplo usa la versión de revisión más reciente de Go 1.21:

```yaml copy
      - name: Setup Go 1.21.x
        uses: actions/setup-go@v5
        with:
          # Semantic version range syntax or exact version of Go
          go-version: '1.21.x'
```

## Instalación de dependencias

Puedes usar `go get` para instalar dependencias:

```yaml copy
    steps:
      - uses: actions/checkout@v6
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.21.x'
      - name: Install dependencies
        run: |
          go get .
          go get example.com/octo-examplemodule
          go get example.com/octo-examplemodule@v1.3.4
```

### Almacenar dependencias en caché

Puedes almacenar en caché las dependencias y restaurarlas mediante la [acción `setup-go`](https://github.com/actions/setup-go). El almacenamiento en caché está habilitado de manera predeterminada cuando se usa la acción `setup-go`.

La acción `setup-go` busca el archivo de dependencia, `go.sum`, en la raíz del repositorio y usa el hash del archivo de dependencia como parte de la clave de caché.

Puede susar el parámetro `cache-dependency-path` para los casos en los que se usan varios archivos de dependencia o cuando se encuentran en distintos subdirectorios.

```yaml copy
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.17'
          cache-dependency-path: subdir/go.sum
```

Si tiene una necesidad específica o necesita controles más precisos para el almacenamiento en caché, puede usar la [acción `cache`](https://github.com/marketplace/actions/cache). Para más información, consulta [Referencia de almacenamiento en caché de dependencias](/es/enterprise-server@3.22/actions/reference/workflows-and-actions/dependency-caching).

## Construir y probar tu código

Puedes usar los mismos comandos que usas de forma local para construir y probar tu código. En este flujo de trabajo de ejemplo se muestra cómo usar `go build` y `go test` en un trabajo:

```yaml copy
name: Go
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v6
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.21.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. En el ejemplo siguiente se muestra cómo puede usar la acción `upload-artifact` para cargar los resultados de la prueba.

Para más información, consulta [Almacenamiento y uso compartido de datos con artefactos de flujo de trabajo](/es/enterprise-server@3.22/actions/tutorials/store-and-share-data).

```yaml copy
name: Upload Go test results

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

    steps:
      - uses: actions/checkout@v6
      - name: Setup Go
        uses: actions/setup-go@v5
        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
```