Skapa och testa Go-projekt

2025-08-15

Azure DevOps-tjänster

Använd en pipeline för att automatiskt skapa och testa dina Go-projekt.

Skapa din första pipeline

Är du ny på Azure Pipelines? I så fall rekommenderar vi att du provar det här avsnittet innan du går vidare till andra avsnitt.

Förgrena följande lagringsplats på GitHub:

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

Logga in på Azure Pipelines. När du har loggat in går webbläsaren till https://dev.azure.com/my-organization-name och visar din Azure DevOps-instrumentpanel.

I en webbläsare går du till dev.azure.com och loggar in.
Välj din organisation.
Skapa ett nytt projekt genom att välja Nytt projekt eller Skapa projekt om du skapar det första projektet i organisationen.
Ange ett projektnamn.
Välj Synlighet för projektet.
Välj Skapa.

Skapa pipelinen

I ditt Azure DevOps-projekt väljer du Pipelines på den vänstra navigeringsmenyn.
Välj Ny pipeline eller Skapa pipeline om den här pipelinen är den första i projektet.
På skärmen Var är din kod väljer du GitHub.
Du kan omdirigeras till GitHub för att logga in. I så fall anger du dina GitHub-autentiseringsuppgifter.
På skärmen Välj en lagringsplats väljer du den lagringsplats som .NET-appen finns i.
Du kan omdirigeras till GitHub för att installera Azure Pipelines-appen. I så fall väljer du Godkänn och installera.

När fliken Konfigurera visas väljer du Gå. Din nya pipeline visas med azure-pipelines.yml YAML-filen färdig att konfigureras. Se följande avsnitt för att lära dig några av de vanligaste sätten att anpassa din pipeline.

Skapa miljö

Du kan använda Azure Pipelines för att skapa dina Go-projekt utan att konfigurera någon egen infrastruktur. Du kan använda Linux-, macOS- eller Windows-agenter för att köra dina versioner.

Uppdatera följande kodfragment i azure-pipelines.yml filen för att välja lämplig bild.

pool:
  vmImage: 'ubuntu-latest'

De senaste versionerna av Go är förinstallerade på Microsoft-värdhanterade agenter. De exakta versionerna av förinstallerade Go hittas på Microsoft-värdbaserade agenter i Azure Pipelines.

Från och med Go 1.11 behöver du inte längre definiera en $GOPATH miljö, konfigurera en arbetsytelayout eller använda modulen dep . Beroendehantering är nu inbyggt.

Denna YAML implementerar go get kommandot för att ladda ned Go-paket och deras beroenden. Den använder go build sedan för att generera det innehåll som publiceras med PublishBuildArtifacts@1 uppgiften.

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

Som beskrivs i Go-dokumentationen består en Go-arbetsyta av en rotkatalog som miljövariabeln pekar på $GOPATH . I den katalogen finns följande standardunderkataloger:

bin för att innehålla körbara kommandon
pkg som ska innehålla kompilerade paket (.a filer)
src för att innehålla Go-källfiler (.go, .c, .g, .s)

När en Azure Pipelines-version hämtar kod från en fjärrlagringsplats placerar den koden i standardarbetskatalogen för bygget. Om du vill matcha den förväntade strukturen för en Go-arbetsyta lägger du till följande kodfragment i azure-pipelines.yml filen. Det här skriptet körs i bash på Linux- och macOS-agenter, men måste ändras för 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'

Om koden inte finns på GitHub ändrar du modulePath variabelns användning av github.com till ett lämpligt värde för din modul.

Det här kodfragmentet utför följande åtgärder:

Anger $GOROOT den version av Go som ska användas.
Anger andra välkända Go-miljövariabler till rätt värden.
Skapar en Go-arbetsyta i en underkatalog med namnet gopath med underordnade kataloger bin, pkgoch src.
Flyttar kod som hämtades från fjärrlagringsplatsen till arbetsytans src katalog
Lägger till versionen av Go och arbetsytekatalogen bin i sökvägen.

Installera beroenden

Använd go get

Använd go get för att ladda ned källkoden för ett Go-projekt eller för att installera ett verktyg på Go-arbetsytan. Lägg till följande kodfragment i azure-pipelines.yml filen:

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

Se till att använda dep

Använd dep ensure om projektet använder dep för att ladda ned beroenden som importerats i koden. När kloner körs dep ensure importerade lagringsplatser till projektets leverantörskatalog. Dess Gopkg.lock filer och Gopkg.toml filer garanterar att alla som arbetar med projektet använder samma version av beroenden som din version. Lägg till följande kodfragment i azure-pipelines.yml filen.

Anmärkning

Följande skript körs på Linux- och macOS-agenter och kan användas för äldre versioner av Go som kräver en specifik mappstruktur. Skriptet är skrivet för Unix-gränssnitt och kan därför inte fungera med Windows-agenter.

- 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`'

Skapa

Använd go build för att skapa ditt Go-projekt. Lägg till följande kodfragment i azure-pipelines.yml filen:

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

Test

Använd go test för att testa Go-modulen och dess underkataloger (./...). Lägg till följande kodfragment i azure-pipelines.yml filen:

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

När du är klar checkar du in en ny azure-pipelines.yml fil till lagringsplatsen och uppdaterar incheckningsmeddelandet. Välj Spara och kör.

Om du vill se din pipeline i praktiken väljer du alternativet Skapa i jobb på instrumentpanelen för Azure Pipelines. Byggandet av pipeline i praktiken när alternativet Azure Pipelines Jobs har valts.

Eftersom koden verkade vara en bra matchning för Go-mallen skapade vi automatiskt din pipeline.

Nu har du en fungerande YAML-pipeline (azure-pipelines.yml) på din lagringsplats som är redo att anpassas!

När du är redo att göra ändringar i din pipeline väljer du den på Pipelines-sidan och sedan redigerar du den azure-pipelines.yml filen.

Tips/Råd

Om du vill göra ändringar i YAML-filen enligt beskrivningen i den här artikeln väljer du pipelinen på sidan Pipelines och väljer sedan Redigera för att öppna en redigerare för azure-pipelines.yml filen. Skärmbild som visar hur du redigerar Azure Pipeline från instrumentpanelen med fler alternativ markerade och Redigera markerade.

Skapa en avbildning och skicka till containerregistret

För din Go-app kan du också skapa en avbildning och push-överföra den till ett containerregister.

Go-tillägg för Visual Studio Code

Feedback

Var den här sidan till hjälp?