Introducción

En este artículo vamos a continuar donde dejamos el proyecto forward la última vez. En este artículo vamos a usar gitlab-ci para testear, construir y empujar la imagen de nuestro operador a dockerhub.

Gitlab ofrece una solución bastante completa, pero solo vamos a sincronizar nuestro repo desde github y configurar un pipeline básico para testear, construir y empujar nuestra imagen de docker al registro. Notá que no tengo ninguna afiliación con gitlab, pero me gusta su plataforma. Este artículo también demuestra que podés usar github y gitlab de manera sencilla usando el nivel gratuito en ambos, confiamos en los “shared runners” gratuitos para construir nuestro sistema de CI personalizado.

Si querés revisar el artículo anterior andá acá para saber de qué se trata el proyecto.

Prerequisitos

• Un proyecto en github en este caso
• Una cuenta en gitlab.com
• Una cuenta en dockerhub

Crear el proyecto

Una vez que tengas tus cuentas configuradas, vamos a crear un proyecto. La página debería verse algo así: Queremos crear un repo o sincronizar uno en este caso, así que seleccionamos Create a project y continuamos.

Tipo de proyecto

En este paso tenemos algunas opciones y como tenemos nuestro código en Github y queremos trabajar ahí, solo queremos sincronizarlo, así que necesitamos elegir CI/CD for external repo. Notá que si el repo es público, podés hacer fetch/clone usando la URL del repo, pero como también quiero probar con repos privados, elegí la alternativa del token de github. Una vez que seleccionás github, te pedirá el token y luego te mostrará la lista completa de repos en tu cuenta.

Token de Github

Elegí usar un token personal para poder obtener los repos privados, etc., así que tendrás que ir a tu cuenta de github, Settings->Developer settings y luego crear un nuevo token o hacé clic acá.

Ahora solo necesitás darle acceso a los repos y hacer clic en guardar o crear nuevo token personal. Asegurate de no exponer ni publicar ese token de ninguna manera, de lo contrario alguien podría obtener acceso a tu cuenta.

(Volviendo a gitlab) Seleccionar el repositorio a sincronizar

Acá necesitamos seleccionar el repo que queremos sincronizar y hacer clic en conectar, se sincronizará automáticamente todo desde github periódicamente.

Token de Dockerhub

Ahora necesitaremos crear un token para dockerhub para poder empujar nuestra imagen desde el build runner. Vamos a tu cuenta de dockerhub y creamos un token. Básicamente tenés que ir a Account settings->Security->New Access Token o hacé clic acá.

Luego necesitamos guardar ese token como DOCKERHUB_TOKEN, en este caso, como una variable de entorno en el proyecto de gitlab, Settings->CI/CD->Variables. Asegurate de que esté marcado como “masked” pero no como “protected”. “Protected” solo se usa cuando querés usar ese secreto en ramas específicas.

Config de Gitlab-CI

Después de eso, solo necesitamos agregar el código al repo y eso desencadenará una construcción. El archivo debe llamarse .gitlab-ci.yml.

image: golang:1.13.7-alpine3.11

stages:
- test
- build

variables:
  PKG_PATH: gitlab.com/kainlite/forward
  IMAGE_NAME: "kainlite/forward"

before_script:
  - apk update && apk add curl make musl-dev gcc build-base
  - BUILD_DIR=$(pwd)
  - export GOPATH=${BUILD_DIR}/_build
  - export PATH=${GOPATH}/bin:${PATH}
  - export PATH=$PATH:/usr/local/bin
  - mkdir -p "${GOPATH}/src/${PKG_PATH}" && cd "${GOPATH}/src/${PKG_PATH}"
  - curl -L https://github.com/kubernetes-sigs/kubebuilder/releases/download/v2.2.0/kubebuilder_2.2.0_linux_amd64.tar.gz > /tmp/kubebuilder.tar.gz
  - tar -zxvf /tmp/kubebuilder.tar.gz
  - chmod +x kubebuilder_2.2.0_linux_amd64/bin/* && mkdir -p /usr/local/kubebuilder && mv kubebuilder_2.2.0_linux_amd64/bin/ /usr/local/kubebuilder/
  - export PATH=$PATH:/usr/local/kubebuilder/bin
  - curl -L https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize%2Fv3.5.4/kustomize_v3.5.4_linux_amd64.tar.gz > /tmp/kustomize.tar.gz
  - tar -zxvf /tmp/kustomize.tar.gz
  - mv kustomize /usr/local/bin
  - curl -L https://github.com/kubernetes-sigs/kind/releases/download/v0.7.0/kind-linux-amd64 > /usr/local/bin/kind
  - chmod +x /usr/local/bin/kind /usr/local/bin/kustomize
  - curl -L https://download.docker.com/linux/static/stable/x86_64/docker-19.03.5.tgz > /tmp/docker.tar.gz
  - tar -xzvf /tmp/docker.tar.gz -C /tmp/
  - chmod +x /tmp/docker/* && cp /tmp/docker/docker* /usr/local/bin && rm -rf /tmp/docker

test:
  stage: test
  script:
    - cd ${BUILD_DIR} && make test
  cache:
    key: "$CI_COMMIT_REF_SLUG"
    paths:
      - _build/pkg

build:
  stage: build
  variables:
    DOCKER_DRIVER: overlay2
    DOCKER_HOST: tcp://docker:2375
  services:
    - docker:dind
  script:
    - cd ${BUILD_DIR}
    - docker login -u "kainlite" -p "${DOCKERHUB_TOKEN}"
    - docker pull "$IMAGE_NAME:${CI_COMMIT_SHA}" || true
    - make docker-build docker-push IMG="${IMAGE_NAME}:${CI_COMMIT_SHA}"
    - docker tag "kainlite/forward:${CI_COMMIT_SHA}" "$IMAGE_NAME:latest"
    - make docker-push IMG="${IMAGE_NAME}:latest"
  cache:
    key: "$CI_COMMIT_REF_SLUG"
    paths:
      - _build/pkg

Básicamente, solo instalamos todo lo que necesitamos, ejecutamos las pruebas y, si todo va bien, sigue el proceso de construcción y empuje. Hay mucho espacio para mejorar esa configuración inicial, pero por ahora solo nos interesa tener algún tipo de sistema de CI.

Entonces veremos algo como esto en la pestaña CI/CD->Pipelines. Después de cada commit, se disparará un test, build y push.

Verificando los resultados

Y podemos validar que las imágenes están en dockerhub.

Links útiles

Algunos links útiles:

• Variables y Variables predefinidas
• Usar imágenes de docker
• Construir imágenes de docker

Notas finales

¡Espero que te haya gustado y espero verte en twitter o github!

Errata

Si ves algún error o tenés alguna sugerencia, por favor mandame un mensaje así lo arreglo.

También podés ver el código fuente y cambios en el código generado y en las fuentes acá.