Compilar y probar 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

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 un explorador, vaya a dev.azure.com e inicie sesión.
Seleccione su organización.
Para crear un nuevo proyecto, seleccione Nuevo proyecto o Crear proyecto si va a crear el primer proyecto de la organización.
Escriba un nombre de proyecto.
Seleccione la visibilidad del proyecto.
Selecciona Crear.

Creación de la canalización

En el proyecto de Azure DevOps, seleccione Canalizaciones en el menú de navegación izquierdo.
Seleccione Nueva canalización o Crear canalización si esta canalización es la primera del proyecto.
En la pantalla Where is your code (Dónde está el código ), seleccione GitHub.
Puede que se le redirija a GitHub para iniciar sesión. Si es así, escriba sus credenciales de GitHub.
En la pantalla Seleccionar un repositorio , seleccione el repositorio en el que se encuentra la aplicación .NET.
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 Ir. Aparece la nueva canalización, con el azure-pipelines.yml archivo YAML 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 azure-pipelines.yml el archivo 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.

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

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

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 se describe en la documentación de Go, un área de trabajo de Go consta de un directorio raíz al que apunta la $GOPATH variable de entorno. Dentro de ese directorio, son los siguientes 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 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 azure-pipelines.yml archivo. 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 a github.com un valor adecuado para el modulePath módulo.

Este fragmento de código realiza las siguientes acciones:

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

Instalación de 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. La ejecución dep ensure de clones repositorios importados en el directorio del proveedor del proyecto. Sus Gopkg.lock archivos 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 al azure-pipelines.yml archivo.

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

Construir

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 en el panel de Azure Pipelines. Compilación de canalización en acción cuando se selecciona la opción Trabajos 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 en funcionamiento (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 azure-pipelines.yml archivo. Captura de pantalla que muestra cómo editar Azure Pipeline desde el panel con más opción seleccionada y Editar resaltada.

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.

Extensión go para Visual Studio Code

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-08-15