Criar e testar projetos do Go

Azure DevOps Services

Use um pipeline para compilar e testar automaticamente seus projetos do Go.

Criar seu primeiro pipeline

Novo no Azure Pipelines? Nesse caso, recomendamos que você experimente esta seção antes de passar para outras seções.

Bifurque o seguinte repositório no GitHub:

https://github.com/MicrosoftDocs/pipelines-go

Entre no Azure Pipelines. Depois de entrar, o navegador vai para https://dev.azure.com/my-organization-name e exibe o painel do Azure DevOps.

Em um navegador, acesse dev.azure.com e entre.
Selecione sua organização.
Crie um novo projeto selecionando Novo projeto ou Criar projeto se estiver criando o primeiro projeto na organização.
Insira um nome de projeto.
Selecione a Visibilidade do seu projeto.
Selecione Criar.

Criar o pipeline

Em seu projeto do Azure DevOps, selecione Pipelines no menu de navegação à esquerda.
Selecione Novo pipeline ou Criar pipeline se esse pipeline for o primeiro no projeto.
Na tela Onde está o código , selecione GitHub.
Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.
Na tela Selecionar um repositório , selecione o repositório em que seu aplicativo .NET está.
Você poderá ser redirecionado ao GitHub para instalar o aplicativo do Azure Pipelines. Se for o caso, selecione Aprovar e instalar.

Quando a guia Configurar for exibida, selecioneIr. O novo pipeline é exibido, com o azure-pipelines.yml arquivo YAML pronto para ser configurado. Confira as seções a seguir para saber algumas das maneiras mais comuns de personalizar seu pipeline.

Ambiente de build

Você pode usar o Azure Pipelines para criar seus projetos do Go sem configurar nenhuma infraestrutura própria. Você pode usar agentes linux, macOS ou Windows para executar seus builds.

Atualize o snippet de código a seguir em seu azure-pipelines.yml arquivo para selecionar a imagem apropriada.

pool:
  vmImage: 'ubuntu-latest'

As versões modernas do Go são pré-instaladas em agentes hospedados pela Microsoft. Para versões exatas do Go pré-instalado, consulte os agentes hospedados pela Microsoft no Azure Pipelines.

A partir do Go 1.11, você não precisa mais definir um $GOPATH ambiente, configurar um layout de workspace ou usar o dep módulo. O gerenciamento de dependência agora está integrado.

Esse YAML implementa o comando para baixar pacotes go get Go e suas dependências. Em seguida, ele usa go build para gerar o conteúdo publicado com PublishBuildArtifacts@1 a tarefa.

trigger: 
 - main

pool:
   vmImage: 'ubuntu-latest'

steps: 
- task: GoTool@0
  inputs:
    version: '1.13.5'
- task: Go@0
  inputs:
    command: 'get'
    arguments: '-d'
    workingDirectory: '$(System.DefaultWorkingDirectory)'
- task: Go@0
  inputs:
    command: 'build'
    workingDirectory: '$(System.DefaultWorkingDirectory)'
- task: CopyFiles@2
  inputs:
    TargetFolder: '$(Build.ArtifactStagingDirectory)'
- task: PublishBuildArtifacts@1
  inputs:
     artifactName: drop

Como a documentação go descreve, um workspace Go consiste em um diretório raiz para o qual a variável de $GOPATH ambiente aponta. Dentro desse diretório, estão os seguintes subdiretórios padrão:

bin para conter comandos executáveis
pkg para conter pacotes compilados (.a arquivos)
srcpara conter arquivos de origem go (.go, , .c.g, ) .s

Quando um build do Azure Pipelines busca código de um repositório remoto, ele coloca o código no diretório de trabalho padrão do build. Para corresponder à estrutura esperada de um workspace Go, adicione o snippet a seguir ao arquivo azure-pipelines.yml . Esse script é executado em bash em agentes linux e macOS, mas deve ser modificado para Windows.

variables:
  GOBIN:  '$(GOPATH)/bin' # Go binaries path
  GOPATH: '$(system.defaultWorkingDirectory)/gopath' # Go workspace path
  modulePath: '$(GOPATH)/src/github.com/$(build.repository.name)' # Path to the module's code

steps:
- script: |
    mkdir -p '$(GOBIN)'
    mkdir -p '$(GOPATH)/pkg'
    mkdir -p '$(modulePath)'
    shopt -s extglob
    shopt -s dotglob
    mv !(gopath) '$(modulePath)'
    echo '##vso[task.prependpath]$(GOBIN)'
  displayName: 'Set up the Go workspace'

- script: |
    go version
    go get -v -t -d ./...
    if [ -f Gopkg.toml ]; then
        curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
        dep ensure
    fi
    go build -v .
  workingDirectory: '$(modulePath)'
  displayName: 'Get dependencies, then build'

Se o código não estiver no GitHub, altere o modulePath uso github.com da variável para um valor apropriado para o módulo.

Este snippet faz as seguintes ações:

Define $GOROOT a versão do Go que deve ser usada.
Define outras variáveis de ambiente go conhecidas para seus valores adequados.
Cria um workspace Go em um subdiretório nomeado com diretórios binfilho e srcpkg.gopath
Move o código que foi buscado do repositório remoto para o diretório do workspace src
Adiciona a versão do Go e o diretório do workspace bin ao caminho.

Instalar dependências

Use go get

Use go get para baixar o código-fonte de um projeto Go ou instalar uma ferramenta no workspace Go. Adicione o snippet de código a seguir ao seu arquivo azure-pipelines.yml:

- script: go get -v -t -d ./...
  workingDirectory: '$(modulePath)'
  displayName: 'go get dependencies'

Usar dep ensure

Use dep ensure se o projeto usar dep para baixar dependências importadas em seu código. A execução dep ensure clona repositórios importados no diretório do fornecedor do projeto. Seus Gopkg.lock arquivos e Gopkg.toml seus arquivos garantem que todos que trabalham no projeto usem a mesma versão de dependências que o build. Adicione o snippet a seguir ao arquivo azure-pipelines.yml .

Observação

O script a seguir é executado em agentes linux e macOS e pode ser usado para versões mais antigas do Go que exigem uma estrutura de pasta específica. O script é escrito para shells unix e, como resultado, não pode funcionar com agentes do Windows.

- script: |
    if [ -f Gopkg.toml ]; then
        curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
        dep ensure
    fi
  workingDirectory: '$(modulePath)'
  displayName: 'Download dep and run `dep ensure`'

Construir

Use go build para criar seu projeto Go. Adicione o snippet de código a seguir ao seu arquivo azure-pipelines.yml:

- task: Go@0
  inputs:
    command: 'build'
    workingDirectory: '$(System.DefaultWorkingDirectory)'

Teste

Use go test para testar o módulo Go e seus subdiretórios (./...). Adicione o snippet de código a seguir ao seu arquivo azure-pipelines.yml:

- task: Go@0
  inputs:
    command: 'test'
    arguments: '-v'
    workingDirectory: '$(System.DefaultWorkingDirectory)'

Quando estiver pronto, confirme um novo arquivo de azure-pipelines.yml no repositório e atualize a mensagem de confirmação. Selecione Salvar e executar.

Se você quiser observar o pipeline em ação, selecione a compilação na opção Trabalhos no painel do Azure Pipelines. Compilação de pipeline em ação quando a opção Trabalhos do Azure Pipelines é selecionada.

Como seu código parecia ser uma boa correspondência para o modelo Go , criamos automaticamente seu pipeline.

Agora você tem um pipeline YAML funcional (azure-pipelines.yml) em seu repositório que está pronto para personalização!

Quando estiver pronto para fazer as alterações no pipeline, selecione-o na página Pipelines e Edite o arquivo azure-pipelines.yml.

Dica

Para fazer alterações no arquivo YAML, conforme descrito neste artigo, selecione o pipeline na página Pipelines e selecione Editar para abrir um editor para o azure-pipelines.yml arquivo. Captura de tela mostrando como editar o Pipeline do Azure no painel com mais opções selecionadas e Editar realçado.

Compilar uma imagem e enviar por push para o registro de contêiner

Para seu aplicativo Go, você também pode criar uma imagem e efetuá-la por push para um registro de contêiner.

Extensão go para Visual Studio Code

Comentários

Esta página foi útil?

Last updated on 2025-08-15