Skip to main content

Criando e testando o Go

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

Introdução

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

Os executores hospedados em GitHub têm um cache de ferramentas com software pré-instalado, que inclui as dependências do Go. Para obter uma lista completa de software atualizado e as versões pré-instaladas do Go, consulte "Sobre os executores hospedados em GitHub."

Pré-requisitos

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

Recomendamos que você tenha um entendimento básico da linguagem Go. Para obter mais informações, consulte Primeiros passos com o Go.

Usando o fluxo de trabalho inicial do Go

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

Para iniciar rapidamente, adicione o fluxo de trabalho inicial para o diretório .github/workflows do seu 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 ./...

Especificando uma versão do Go

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

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

A ação setup-go é a forma recomendada de usar Go com GitHub Actions, porque ajuda a garantir um comportamento consistente em executores diferentes e versões diferentes do Go. Se você estiver usando um executor auto-hospedado, você deverá instalar o Go e adicioná-lo ao PATH.

Usando 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

Usando uma versão específica do Go

Você pode configurar o seu 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. Esse exemplo usa a última versão de patch 1.16 do Go:

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 as 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.lab/octo-examplemodule
          go get example.lab/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 verdadeiro para habilitá-lo.

Quando o cache está habilitado, a ação setup-go pesquisa 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 são usados vários arquivos de dependências ou quando estão localizados em subdiretórios diferentes.

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 de melhores controles para cache, você poderá usar a ação cache. Para obter mais informações, consulte "Memorizar dependências para acelerar 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 exemplo de fluxo de trabalho demonstra como usar go build and 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-artefato para fazer o upload de resultados de testes.

Para obter mais informações, consulte "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