Compilare e testare progetti Go

Servizi di Azure DevOps

Usare una pipeline per compilare e testare automaticamente i progetti Go.

Creare la prima pipeline

Novità di Azure Pipelines? In tal caso, è consigliabile provare questa sezione prima di passare ad altre sezioni.

Creare una copia tramite fork del repository seguente in GitHub:

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

Accedere ad Azure Pipelines

Accedere ad Azure Pipelines. Dopo l'accesso, il browser passa a https://dev.azure.com/my-organization-name e visualizza il dashboard di Azure DevOps.

1. In un browser passare a dev.azure.com e accedere.
2. Selezionare l'organizzazione.
3. Creare un nuovo progetto selezionando Nuovo progetto o Crea progetto se si crea il primo progetto nell'organizzazione.
4. Immettere il nome del progetto.
5. Selezionare visibilità per il progetto.
6. Seleziona Crea.

1. In un browser passare al server Azure DevOps.
2. Selezionare la raccolta.
3. Creare un nuovo progetto selezionando Nuovo progetto o Crea progetto se si crea il primo progetto nella raccolta.
4. Immettere il nome del progetto.
5. Selezionare visibilità per il progetto.
6. Seleziona Crea.

Creare la pipeline

1. Accedere all'organizzazione di Azure DevOps e passare al progetto.

2. Passare a Pipeline e quindi selezionare Nuova pipeline o Crea pipeline se si crea la prima pipeline.

3. Eseguire i passaggi della procedura guidata selezionando prima di tutto GitHub come posizione del codice sorgente.

4. Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.

5. Quando si vede l’elenco dei repository, selezionarne uno.

6. È possibile che si venga reindirizzati a GitHub per installare l'app Azure Pipelines. In tal caso, selezionare Approva e installa.

Quando viene visualizzata la scheda Configura , selezionare Vai. Viene visualizzata la nuova pipeline, con il azure-pipelines.yml file YAML pronto per la configurazione. Vedere le sezioni seguenti per informazioni su alcuni dei modi più comuni per personalizzare la pipeline.

Ambiente di compilazione

È possibile usare Azure Pipelines per compilare i progetti Go senza configurare alcuna infrastruttura personalizzata. È possibile usare agenti Linux, macOS o Windows per eseguire le compilazioni.

Aggiornare il frammento di codice seguente nel azure-pipelines.yml file per selezionare l'immagine appropriata.

pool:
  vmImage: 'ubuntu-latest'

Le versioni moderne di Go sono preinstallate in agenti ospitati da Microsoft. Per le versioni esatte di Go preinstallate, vedere Agenti ospitati da Microsoft in Azure Pipelines.

Configurare Go

Vai 1.11+

A partire da Go 1.11, non è più necessario definire un $GOPATH ambiente, configurare un layout dell'area di lavoro o usare il dep modulo. La gestione delle dipendenze è ora incorporata.

Questo YAML implementa il go get comando per scaricare i pacchetti Go e le relative dipendenze. Viene quindi usato go build per generare il contenuto pubblicato con PublishBuildArtifacts@1 l'attività.

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

Vai < 1.11

Come descritto nella documentazione di Go, un'area di lavoro Go è costituita da una directory radice a cui punta la $GOPATH variabile di ambiente. All'interno di tale directory sono riportate le sottodirectory standard seguenti:

• bin per contenere comandi eseguibili
• pkg per contenere pacchetti compilati (.a file)
• src per contenere file di origine Go (.go, .c, .g, .s)

Quando una compilazione di Azure Pipelines recupera il codice da un repository remoto, inserisce il codice nella directory di lavoro predefinita della compilazione. Per corrispondere alla struttura prevista di un'area di lavoro Go, aggiungere il frammento di codice seguente al azure-pipelines.yml file. Questo script viene eseguito in bash negli agenti Linux e macOS, ma deve essere modificato per 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 il codice non si trova in GitHub, modificare l'uso modulePath della variabile in github.com un valore appropriato per il modulo.

Questo frammento di codice esegue le azioni seguenti:

1. Imposta $GOROOT la versione di Go che deve essere usata.
2. Imposta le altre variabili di ambiente Go note ai valori appropriati.
3. Crea un'area di lavoro Go in una sottodirectory denominata gopath con directory binfiglio , pkge src.
4. Sposta il codice recuperato dal repository remoto nella directory dell'area di lavoro src
5. Aggiunge la versione di Go e la directory dell'area di lavoro bin al percorso.

Installare le dipendenze

Usare go get

Usare go get per scaricare il codice sorgente per un progetto Go o per installare uno strumento nell'area di lavoro Go. Aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

Usare dep ensure

Usare dep ensure se il progetto usa dep per scaricare le dipendenze importate nel codice. Esecuzione dep ensure di cloni importati nella directory del fornitore del progetto. I file Gopkg.lock e Gopkg.toml garantiscono che tutti gli utenti che lavorano sul progetto usino la stessa versione delle dipendenze della compilazione. Aggiungere il frammento di codice seguente al azure-pipelines.yml file.

Nota

Lo script seguente viene eseguito negli agenti Linux e macOS e può essere usato per le versioni precedenti di Go che richiedono una struttura di cartelle specifica. Lo script viene scritto per le shell Unix e di conseguenza non può funzionare con gli agenti 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`'

Compilazione

Usare go build per compilare il progetto Go. Aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

  Test

Usare go test per testare il modulo Go e le relative sottodirectory (./...). Aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

Quando si è pronti, eseguire il commit di un nuovo file azure-pipelines.yml nel repository e aggiornare il messaggio di commit. Seleziona Salva ed Esegui.

Se si vuole controllare la pipeline in azione, selezionare l'opzione Compilazione nell'opzione Processi nel dashboard di Azure Pipelines.

Poiché il codice sembrava essere una corrispondenza valida per il modello Go , la pipeline è stata creata automaticamente.

È ora disponibile una pipeline YAML funzionante (azure-pipelines.yml) nel repository che è pronta per la personalizzazione.

Quando si è pronti per apportare modifiche alla pipeline, selezionarla nella pagina Pipeline e quindi Modificare il azure-pipelines.yml file.

Suggerimento

Per apportare modifiche al file YAML come descritto in questo articolo, selezionare la pipeline nella pagina Pipeline e quindi selezionare Modifica per aprire un editor per il azure-pipelines.yml file.

Creare un'immagine ed eseguire il push nel registro contenitori

Per l'app Go, è anche possibile compilare un'immagine ed eseguirne il push in un registro contenitori.

Estensioni correlate

Estensione Go per Visual Studio Code (Microsoft)