Crie e teste projetos Go

Serviços de DevOps do Azure

Use um pipeline para criar e testar automaticamente seus projetos Go.

Crie o seu primeiro pipeline

É novo no Azure Pipelines? Em caso afirmativo, recomendamos que experimente esta secção antes de passar para outras secções.

Fork o seguinte repo no GitHub:

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

Inicie sessão no Azure Pipelines. Depois de iniciar sessão, o seu navegador vai para https://dev.azure.com/my-organization-name e exibe o seu painel do Azure DevOps.

Num browser, aceda a dev.azure.com e inicie sessão.
Selecione a 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 a linha de produção

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

Quando a aba Configurar aparecer, selecione Ir. Seu novo pipeline é exibido, com o arquivo YAML azure-pipelines.yml pronto para ser configurado. Consulte as seções a seguir para aprender algumas das maneiras mais comuns de personalizar seu pipeline.

Ambiente de construção

Você pode usar o Azure Pipelines para criar seus projetos Go sem configurar nenhuma infraestrutura própria. Você pode usar agentes Linux, macOS ou Windows para executar suas compilações.

Atualize o seguinte trecho no arquivo azure-pipelines.yml 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 obter as 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 ambiente $GOPATH, configurar um layout de espaço de trabalho ou usar o módulo dep. O gerenciamento de dependência agora está incorporado.

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

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 descrito na documentação do Go , um espaço de trabalho do Go é constituído por um diretório raiz para o qual a variável de ambiente $GOPATH aponta. Dentro desse diretório, estão os seguintes subdiretórios padrão:

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

Quando uma compilação do Azure Pipelines busca código de um repositório remoto, ela coloca o código no diretório de trabalho padrão da compilação. Para corresponder à estrutura esperada de um espaço de trabalho Go, adicione o seguinte trecho ao seu arquivo azure-pipelines.yml. Este 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 seu código não estiver no GitHub, altere o uso de modulePath da variável github.com para um valor apropriado para seu módulo.

Este trecho executa as seguintes ações:

Define $GOROOT para a versão do Go que deve ser usada.
Define outras variáveis de ambiente Go bem conhecidas para seus valores adequados.
Cria um espaço de trabalho Go num subdiretório chamado gopath, com diretórios filhos bin, pkge src.
Move o código que foi obtido do repositório remoto para o diretório src do espaço de trabalho
Adiciona a versão do Go e o diretório do bin do espaço de trabalho ao caminho.

Instalar dependências

Utilize go get

Use go get para baixar o código-fonte de um projeto Go ou para instalar uma ferramenta no espaço de trabalho Go. Adicione o seguinte trecho ao seu azure-pipelines.yml arquivo:

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

Use dep ensure

Use dep ensure se seu projeto usa dep para baixar dependências importadas em seu código. A execução dep ensure clona repositórios importados para o diretório de fornecedores do projeto. Os seus ficheiros Gopkg.lock e Gopkg.toml garantem que todos os que trabalham no projeto utilizem a mesma versão das dependências que o seu build. Adicione o seguinte trecho ao seu azure-pipelines.yml arquivo.

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 pastas 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 seguinte trecho ao seu azure-pipelines.yml arquivo:

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

Test

Use go test para testar seu módulo Go e seus subdiretórios (./...). Adicione o seguinte trecho ao seu azure-pipelines.yml arquivo:

- 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 Guardar e executar.

Se quiser ver o seu pipeline em ação, selecione a compilação na opção Jobs no painel do Azure Pipelines. Construção de Pipeline em ação quando a opção Tarefas de Pipelines do Azure estiver selecionada.

Visto que seu código parecia corresponder bem ao modelo Go, criámos automaticamente o seu pipeline.

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

Quando estiver pronto para fazer alterações ao seu pipeline, selecione-o na página Pipelines e edite o azure-pipelines.yml ficheiro.

Tip

Para fazer alterações no arquivo YAML conforme descrito neste artigo, selecione a opção "Pipeline" na página Pipelines e, em seguida, clique em "Editar" para abrir um editor para o arquivo azure-pipelines.yml. Captura de tela mostrando como editar o Pipeline do Azure a partir do painel com a opção Mais selecionada e Editar realçado.

Criar uma imagem e enviar para o registo de contentores

Para a sua aplicação Go, você também pode criar uma imagem e enviá-la para um registo de contêineres.

Extensão Go para Visual Studio Code

Feedback

Esta página foi útil?

Last updated on 2025-08-15