Skip to main content

Como criar e testar projetos com o Go

É possível criar um fluxo de trabalho de CI (integração contínua) para criar e testar um projeto Go.

Observação: no momento, não há suporte para os executores hospedados no GitHub no GitHub Enterprise Server. Você pode ver mais informações sobre o suporte futuro planejado no GitHub public roadmap.

Introdução

Este guia mostra como criar, testar e publicar um pacote Go.

Os executores hospedados no GitHub têm um cache de ferramentas com programas de software pré-instalados, incluindo as dependências do Go. Para ver a lista completa de programas de software atualizados e as versões pré-instaladas do Go, confira "Sobre os executores hospedados no GitHub".

Pré-requisitos

Você já deve estar familiarizado com a sintaxe YAML e como é usado com GitHub Actions. Para obter mais informações, confira "Sintaxe de fluxo de trabalho do GitHub Actions".

Recomendamos que você tenha um entendimento básico da linguagem Go. Para obter mais informações, confira Introdução ao Go.

Como usar o fluxo de trabalho inicial do Go

O GitHub oferece um fluxo de trabalho inicial do Go que deve funcionar na maioria dos projetos Go. Este guia inclui exemplos que você pode usar para personalizar o fluxo de trabalho inicial. Para obter mais informações, confira o fluxo de trabalho inicial do Go.

Para experimentar uma introdução rápida, adicione o fluxo de trabalho inicial ao diretório .github/workflows do repositório.

YAML
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 ./...

Como especificar uma versão do Go

A maneira mais fácil de especificar uma versão do Go é usando a ação setup-go fornecida pelo GitHub. Para obter mais informações, confira a ação setup-go.

Para usar uma versão pré-instalada do Go em um executor hospedado no GitHub, passe a versão relevante para a propriedade go-version da ação setup-go. Essa ação localiza uma versão específica do Go no cache de ferramentas em cada executor e adiciona os binários necessários a PATH. Estas alterações persistirão para o resto do trabalho.

A ação setup-go é a maneira recomendada de usar o Go com o GitHub Actions, pois garante um comportamento consistente entre diferentes executores e diferentes versões do Go. Se você estiver usando um executor auto-hospedado, precisará instalar o Go e adicioná-lo a PATH.

Como usar várias versões do Go

YAML
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

Como usar uma versão específica do Go

Você pode configurar o trabalho para usar uma versão específica do Go, como 1.16.2. Como alternativa, você pode usar a sintaxe da versão semântica para obter a última versão secundária. Este exemplo usa a última versão de patch do Go 1.16.

YAML
      - 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 dependências

Você pode usar go get para instalar dependências:

YAML
    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.com/octo-examplemodule
          go get example.com/octo-examplemodule@v1.3.4

Memorizar dependências

Você pode armazenar em cache e restaurar as dependências usando a ação setup-go. Por padrão, o cache está desabilitado, mas você pode definir o parâmetro cache como true para habilitá-lo.

Quando o cache está habilitado, a ação setup-go procura o arquivo de dependência, go.sum, na raiz do repositório e usa o hash do arquivo de dependência como parte da chave de cache.

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

Como alternativa, você pode usar o parâmetro cache-dependency-path para casos em que vários arquivos de dependência são usados ou quando eles estão localizados em diferentes subdiretórios.

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

Se você tiver um requisito personalizado ou precisar ter controles mais refinados para o cache, use a ação cache. Para obter mais informações, confira "Como armazenar dependências em cache para acelerar os fluxos de trabalho".

Criar e testar seu código

Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Este fluxo de trabalho de exemplo demonstra como usar go build e go test em um trabalho:

YAML
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

Empacotar dados do fluxo de trabalho como artefatos

Após a conclusão de um fluxo de trabalho, você poderá fazer o upload dos artefatos resultantes para análise. Por exemplo, é possível que você precise salvar os arquivos de registro, os despejos de núcleo, os resultados de teste ou capturas de tela. O exemplo a seguir demonstra como você pode usar a ação upload-artifact para carregar os resultados do teste.

Para obter mais informações, confira "Como armazenar dados de fluxo de trabalho como artefatos".

YAML
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