Compilación y prueba de proyectos de Go

Azure DevOps Services

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

Cree su primera canalización

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

Bifurque el repositorio siguiente en GitHub:

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

Inicio de sesión en Azure Pipelines

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.

1. En un explorador, vaya a dev.azure.com e inicie sesión.
2. Seleccione su organización.
3. Para crear un nuevo proyecto, seleccione Nuevo proyecto o Crear proyecto si va a crear el primer proyecto de la organización.
4. Escriba un nombre de proyecto.
5. Seleccione la visibilidad del proyecto.
6. Seleccione Crear.

1. En un explorador, vaya a Azure DevOps Server.
2. Seleccione la colección.
3. Para crear un nuevo proyecto, seleccione Nuevo proyecto o Crear proyecto si va a crear el primer proyecto de la colección.
4. Escriba un nombre de proyecto.
5. Seleccione la visibilidad del proyecto.
6. Seleccione Crear.

Creación de la canalización

1. Inicie sesión en su organización de Azure DevOps y vaya a su proyecto.

2. Ve a Canalizaciones y selecciona Nueva canalización o Crear canalización si vas a crear tu primera canalización.

3. Siga los pasos del asistente y seleccione primero GitHub como ubicación del código fuente.

4. Puede que se le redirija a GitHub para iniciar sesión. Si es así, escriba sus credenciales de GitHub.

5. Cuando vea la lista de repositorios, seleccione el repositorio.

6. Es posible que se le redirija a GitHub para instalar la aplicación Azure Pipelines. Si es así, seleccione Aprobar e instalar.

Cuando aparezca la pestaña Configurar, seleccione Go. Aparece la nueva canalización, con el archivo YAML azure-pipelines.yml listo para configurarse. Consulte las secciones siguientes para obtener información sobre algunas de las formas más comunes de personalizar la canalización.

Entorno de compilación

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

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

pool:
  vmImage: 'ubuntu-latest'

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

Configuración de Go

Go 1.11+

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

Este CÓDIGO YAML implementa el comando go get para descargar paquetes de Go y sus dependencias. Por tanto, usa go build para generar el contenido que se publica con la tarea 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

Go < 1.11

Como se describe en la documentación de Go, un área de trabajo de Go consta de un directorio raíz al que apunta la variable de entorno $GOPATH. Dentro de ese directorio, son los siguientes subdirectorios estándar:

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

Cuando una compilación de Azure Pipelines captura el código de un repositorio remoto, coloca el código en el directorio de trabajo predeterminado de la compilación. Para que coincida con la estructura esperada de un área de trabajo de Go, agregue el siguiente fragmento de código al archivo azure-pipelines.yml. Este script se ejecuta en bash en agentes de Linux y macOS, pero se debe modificar 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 modulePath de github.com a un valor adecuado para el módulo.

Este fragmento de código realiza las siguientes acciones:

1. Establece $GOROOT en la versión de Go que se debe usar.
2. Establece otras variables de entorno conocidas de Go en sus valores adecuados.
3. Crea un área de trabajo de Go en un subdirectorio denominado gopath con directorios binsecundarios, pkg y src.
4. Mueve el código que se capturó desde el repositorio remoto al directorio del área de trabajo src.
5. Agrega la versión de Go y el directorio del área de trabajo bin a la ruta de acceso.

Instalar dependencias

Uso de 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 de Go. Agregue el siguiente fragmento de código a su archivo azure-pipelines.yml:

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

Uso de la garantía de dep

Use dep ensure si el proyecto usa dep para descargar las dependencias importadas en el código. Al ejecutar dep ensure, se clonan repositorios importados en el directorio del proveedor del proyecto. Sus archivos Gopkg.lock y Gopkg.toml garantizan que todos los usuarios que trabajan en el proyecto usen la misma versión de dependencias que la compilación. Agregue el siguiente fragmento de código a su archivo azure-pipelines.yml.

Nota:

El siguiente 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 shells de Unix y, como resultado, no puede trabajar con agentes de 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`'

Build

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

- 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 a su archivo azure-pipelines.yml:

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

Cuando esté listo, confirme un nuevo archivo azure-pipelines.yml en el repositorio y actualice el mensaje de confirmación. Seleccione Guardar y ejecutar.

Si desea ver la canalización en acción, seleccione la compilación en la opción Trabajos del panel de Azure Pipelines.

Dado que el código parecía ser una buena coincidencia para la plantilla de Go, creamos automáticamente la canalización.

Ahora ya tiene una canalización YAML (azure-pipelines.yml) en el repositorio que está lista para que la personalice.

Cuando esté listo para realizar cambios en la canalización, selecciónela en la página Canalizaciones y, luego, haga clic en Editar para modificar el archivo azure-pipelines.yml.

Sugerencia

Para realizar cambios en el archivo YAML como se describe en este artículo, seleccione la canalización en la página Canalizaciones y, a continuación, seleccione Editar para abrir un editor para el archivo azure-pipelines.yml.

Compilar e insertar imágenes en un registro de contenedor

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

Extensiones relacionadas

Extensión Go para Visual Studio Code (Microsoft)