GOGITLAB

Integración continua con GitLab y Go

11 sep. 2019|Lectura de 4 minutos

La integración continua permite ejecutar una serie de tests en el código para integrar los cambios de los desarrolladores al proyecto principal evitando errores.

After Effects Desde Cero

Curso: After Effects Desde Cero

Aprende a crear gráficos animados y efectos visuales para video

Todos los días, varias veces al día, los desarrolladores introducen cambios a un repositorio. Por cada uno de ellos en Gitlab puedes definir una serie de scripts que se encarguen de compilar y probar el código automáticamente, disminuyendo la posibilidad de introducir errores en tu código, a esta práctica se le conoce como integración continua.

¿Cómo funciona?

Solo debes crear un archivo .gitlab-ci.yml y ubicarlo en la raíz de tu proyecto y agregarlo a tu repositorio, GitLab detectará el archivo y ejecutará los scripts que definas en este, de forma similar a una terminal. La agrupación de estos scripts se conocen como jobs, y juntos conforman un pipeline.

En el menu CI/CD de tu repositorio de GitLab podrás ver el estado de tus pipelines y de la ejecución de estos.

Gitlab

Construyamos el archivo

Nuestro archivo tendrá una configuración básica para ejecutar los scripts de testing y build de un proyecto de Go, si quieres conocer la referencia completa de configuración visita este enlace.

En la primera línea del archivo definiremos el atributo image para indicar la imagen de docker que usarán nuestros jobs, en nuestro caso usaremos la imagen golang:1.12.9-alpine que es suficiente para nuestro propósitos.

image: golang:1.12.9-alpine

GitLab CI/CD nos permite definir variables que podemos pasar a nuestros jobs, así que definiremos la variable GO_PROJECT para establecer la ruta de nuestro proyecto de GitLab.

variables:
  GO_PROJECT: gitlab.com/AJRDRGZ/test-ci

Los stages definen las etapas que utilizan los jobs, el orden de estas definen el orden de ejecución de los jobs, en nuestro caso definiremos los stages test y build.

  • Los jobs del mismo stage se ejecutan en paralelo.
  • Los jobs del siguiente stage se ejecutan después de que los jobs del stage anterior se completen con éxito, es decir cuando finalicen con éxito los jobs con stage test se ejecutarán los jobs con stage build.
stages:
  - test
  - build

El atributo before_script nos permite definir comandos que se deben ejecutar antes de todos los jobs, lo utilizaremos para crear nuestro directorio del workspace de Go y mover el contenido clonado de nuestro repositorio a esta carpeta.

before_script:
	# crea el directorio en el workspace de Go
  - mkdir -p ${GOPATH}/src/${GO_PROJECT}
	# copia todo el contenido de CI_PROJECT_DIR al workspace de Go.
	# CI_PROJECT_DIR es una variable predefinida de GitLab que contiene
	# la ruta donde el repositorio es clonado y donde el job está corriendo
  - cp -r ${CI_PROJECT_DIR}/* ${GOPATH}/src/${GO_PROJECT}/
  - cd ${GOPATH}/src/${GO_PROJECT} 

Finalmente definiremos nuestros jobs, que pueden ser definidos con cualquier nombre pero no una palabra reservada y deben contener como mínimo la propiedad script, podemos definir tantos como queramos, en nuestro caso definiremos los jobs test-my-example y build-my-example con las siguientes propiedades:

  • script: Es el shell script que queremos se ejecute.
  • stage: Indica el nombre del stage al que pertenece el job y debe coincidir con uno de los jobs definidos en el atributo stages que definimos previamente (test o build)
test-my-example:
  stage: test
  script: go test ./... -v

build-my-example:
  stage: build
  script: 
    - go build -o myapp
    - ./myapp

El contenido de nuestro archivo .gitlab-ci.yml finalmente se verá así:

image: golang:1.12.9-alpine

variables:
  GO_PROJECT: gitlab.com/AJRDRGZ/test-ci

stages:
  - test
  - build

before_script:
	# crea el directorio en el workspace de Go
  - mkdir -p ${GOPATH}/src/${GO_PROJECT}
	# copia todo el contenido de CI_PROJECT_DIR al workspace de Go.
	# CI_PROJECT_DIR es una variable predefinida de GitLab que contiene
	# la ruta donde el repositorio es clonado y donde el job está corriendo
  - cp -r ${CI_PROJECT_DIR}/* ${GOPATH}/src/${GO_PROJECT}/
  - cd ${GOPATH}/src/${GO_PROJECT}

test-my-example:
  stage: test
  script: go test ./... -v

build-my-example:
  stage: build
  script: 
    - go build -o myapp
    - ./myapp

Veámoslo en acción

Ahora cuando enviemos un nuevo Merge Request a nuestro repositorio de GitLab se ejecutarán nuestros pipelines

Gitlab 1

Al dar click sobre la opción status de la tabla de pipelines, veremos el estado de los dos jobs que configuramos (test-my-example y build-my-example) ubicados en cada stage que definimos (test y build)

Gitlab 2

Al dar click sobre el job podemos ver el estado de su ejecución.

Gitlab 3

Finalmente a través del menú CI/CD, opción pipelines podemos ver todos los pipelines ejecutados en cada commit con su respectivo estado.

Gitlab 4

Si quieres saber más del lenguaje de programación Go, te invito a revisar nuestro curso Go desde cero. Nos leemos en el próximo artículo.