Compilación y prueba de proyectos de Go

Artículo
11/30/2021
5 minutos para leer

Azure Pipelines

Use una canalización para compilar y probar automáticamente los proyectos de Go.

Cree su primera canalización

¿No está Azure Pipelines? Si es así, se recomienda probar esta sección antes de pasar a otras secciones.

Bifurcar este repositorio en GitHub:

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

Inicie sesión en Azure Pipelines. Una vez que haya iniciado sesión, el explorador accederá a https://dev.azure.com/my-organization-name y aparecerá el panel de Azure DevOps.

En la organización seleccionada, cree un proyecto. Si no tiene ningún proyecto en la organización, aparecerá la pantalla Cree un proyecto para empezar. De lo contrario, seleccione el botón Crear proyecto en la esquina superior derecha del panel.

Creación de la canalización

Inicie sesión en su organización de Azure DevOps y vaya a su proyecto.
Vaya a Pipelinesy, a continuación, seleccione Nueva canalización.
Siga los pasos del asistente y seleccione primero GitHub como ubicación del código fuente.
Puede que se le redirija a GitHub para iniciar sesión. Si es así, escriba sus credenciales de GitHub.
Cuando aparezca la lista de repositorios, seleccione el que corresponda.
Es posible que se le redirija a GitHub para instalar la aplicación Azure Pipelines. Si es así, seleccione Aprobar instalación.

Cuando aparezca la pestaña Configurar, seleccione Ir.

Cuando aparezca la nueva canalización, echa un vistazo a YAML para ver lo que hace. Cuando esté listo, seleccione Guardar y ejecute.
Se le pedirá que confirme un nuevo archivo azure-pipelines.yml en el repositorio. Una vez satisfecho con el mensaje, seleccione Guardar y ejecutar de nuevo.

Si desea ver la canalización en acción, seleccione el trabajo de compilación.

Acaba de crear y ejecutó una canalización que creamos automáticamente, porque el código parece ser una buena coincidencia para la plantilla de Go.

Ahora tiene una canalización YAML en funcionamiento ( ) en el repositorio que azure-pipelines.yml está lista para personalizar.
Cuando esté listo para realizar cambios en la canalización, selecciónelo en la página de Pipelines y, a continuación, edite el archivo.

Consulte las secciones siguientes para obtener información sobre algunas de las formas más comunes de personalizar la canalización.

Sugerencia

Para realizar cambios en el archivo YAML como se describe en este tema, seleccione la canalización en Pipelines y, a continuación, seleccione Editar para abrir un editor para el archivo.

Entorno de compilación

Puede usar Azure Pipelines para compilar los proyectos de Go sin necesidad de configurar ninguna infraestructura propia. Puede usar Linux, macOS o Windows para ejecutar las compilaciones.

Actualice el siguiente fragmento de código azure-pipelines.yml en el archivo para seleccionar la imagen adecuada.

pool:
  vmImage: 'ubuntu-latest'

Las versiones modernas de Go están preinstaladas en agentes hospedados por Microsoft en Azure Pipelines. Para obtener las versiones exactas de Go que están preinstaladas, consulte Agentes hospedados por Microsoft.

Configuración de Go

Go 1.11+
Go 1.11

A partir de Go 1.11, ya no es necesario definir un entorno, configurar un diseño de área de $GOPATH trabajo ni usar el dep módulo. La administración de dependencias ahora está integrada.

Este YAML implementa el comando go get para descargar paquetes de Go y sus dependencias. A go build continuación, usa para generar el contenido que se publica con la tarea PublishBuildArtifacts@1 .

trigger: 
 - master

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 se describe en la documentación deGo, un área de trabajo de Go consta de un directorio raíz al que apunta la variable de entorno. Dentro de ese directorio hay subdirectorios estándar:

bin para contener comandos ejecutables
pkg para contener paquetes compilados .a (archivos)
src para contener archivos de código fuente de Go ( .go , .c , , .g.s )

Cuando una Azure Pipelines compilación captura código de un repositorio remoto, coloca el código en el directorio de trabajo predeterminado de la compilación. Esto no coincide con la estructura esperada de un área de trabajo de Go. Para solucionar este problema, agregue el siguiente fragmento de código al azure-pipelines.yml archivo. Nota: Este script se ejecuta en bash en agentes de Linux y macOS, pero debe modificarse 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'

Si el código no está en GitHub, cambie el uso de la variable por modulePath un valor adecuado para el github.com módulo.

Este fragmento de código hace lo siguiente:

Establece $GOROOT en la versión de Go que se debe usar.
Establece otras variables de entorno conocidas de Go en sus valores adecuados.
Crea un área de trabajo de Go en un subdirectorio denominado gopath con directorios secundarios bin , y pkgsrc .
Mueve el código que se ha obtenido del repositorio remoto al directorio del área de src trabajo.
Agrega la versión de Go y el directorio del área de bin trabajo a la ruta de acceso.

Instalar dependencias

go get

Use go get para descargar el código fuente de un proyecto de Go o para instalar una herramienta en el área de trabajo Go. Agregue el siguiente fragmento de código al azure-pipelines.yml archivo:

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

dep ensure

Use dep ensure si el proyecto usa dep para descargar las dependencias importadas en el código. La dep ensure ejecución de clona repositorios importados en el directorio del proveedor del proyecto. Sus Gopkg.lock archivos y garantizan que todos los usuarios que trabajan en el proyecto usan la misma versión de Gopkg.toml dependencias que la compilación. Agregue el siguiente fragmento de código al azure-pipelines.yml archivo.

Nota

Este script se ejecuta en agentes de Linux y macOS y se puede usar para versiones anteriores de Go que requieren una estructura de carpetas específica. El script se escribe para los shells de Unix y, como resultado, no puede funcionar con Windows agentes.

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

Build

Use go build para compilar el proyecto de Go. Agregue el siguiente fragmento de código al azure-pipelines.yml archivo:

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

Prueba

Use go test para probar el módulo go y sus subdirectorios ( ./... ). Agregue el siguiente fragmento de código al azure-pipelines.yml archivo:

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

Compilación de una imagen e inserción en el registro de contenedor

Para la aplicación Go, también puede compilar una imagen e insertarla en un registro de contenedor.

Extensión go para Visual Studio Code (Microsoft)