¿Qué es la integración continua (CI)??

La integración continua es el siguiente paso lógico después de tener un sistema de control de versiones como Git y un sistema de control de versiones remoto como GitLab o GitHub para esfuerzos colaborativos. El problema al que se enfrentan los grandes proyectos es el siguiente: a medida que llegan nuevas solicitudes de extracción, deben probarse y luego integrarse a la rama maestra y este esfuerzo puede llevar fácilmente desde unas pocas horas hasta algunas semanas, dependiendo del tamaño del proyecto. la ubicación de los miembros del equipo, etc.

Como cualquier problema de este tipo, el paso lógico es automatizar todo el galimatías de las pruebas. Lo hacemos configurando un disparador de modo que cada vez que se fusionan nuevas confirmaciones en una rama, un agente (GitLab Runner, por ejemplo) construye automáticamente el entorno y el código, ejecuta todas las pruebas unitarias y las pruebas de integración en él. Si se encuentra algún error, da una advertencia y un informe de bloqueo; de lo contrario, recibe una señal verde que dice que todo funciona.

Por supuesto, llevado al extremo lógico, también puede automatizar la implementación, configurar las pruebas A / B automatizadas y eliminar por completo la intervención humana del proceso. Eso se denomina Entrega continua y / o Implementación continua según el nivel de automatización. Pero solo nos enfocaremos en la Integración Continua en este tutorial.

Prerrequisitos

Nos centraremos en configurar un flujo de CI simple en el tutorial usando una instancia de GitLab sobre HTTPS que cubrimos en una publicación anterior.

Además, también asumimos que ha configurado una cuenta de usuario en esta instancia de GitLab y tiene un repositorio (clonado en su máquina local) administrado con su nombre de usuario. Este es el repositorio que usaremos para demostrar el flujo de trabajo de CI. En el tutorial, su nombre será mi proyecto.

Para enumerarlo todo:

1. Instancia de GitLab
2. Repositorio en blanco, llamado my-project
3. Clon local de este repositorio
4. Su instancia de Git local configurada para insertar cambios en remoto.

Crear una aplicación simple

En este repositorio, creemos un nodo simple.aplicación js. Esta aplicación es un expreso simple.js servidor que está destinado a implementarse en un contenedor Docker. El servidor proporciona una carga útil HTTP que dice "Hola mundo" en su navegador.

En la raíz de su repositorio local, cree un archivo aplicación.js y agregue las siguientes líneas:

'uso estricto';
const express = require ('express');
// Constantes
PUERTO constante = 8080;
const HOST = '0.0.0.0 ';
// Aplicación
aplicación constante = express ();
aplicación.get ('/', (req, res) =>
res.send ('Hola mundo \ n');
);
aplicación.escuchar (PUERTO, HOST);
consola.log ('Ejecutando en http: // $ HOST: $ PORT');

Luego crea otro archivo paquete.json y agregue lo siguiente:

"nombre": "docker_web_app",
"versión 1.0.0 ",
"descripción": "Nodo.js en Docker ",
"author": "John Doe",
"Servidor principal.js ",
"guiones":
"inicio": "servidor de nodo.js "
,
"dependencias":
"express": "^ 4.dieciséis.1 "

Por último, cree un Dockerfile y agregue el siguiente contenido:

DESDE el nodo: 8
# Crear directorio de aplicaciones
WORKDIR / usr / src / app
# Instalar dependencias de aplicaciones
# Se utiliza un comodín para garantizar que tanto el paquete.json Y paquete-bloqueo.json se copian
COPIA paquete *.json ./
EJECUTAR npm install
# Si está creando su código para producción
# RUN npm install --only = producción
# Fuente de la aplicación del paquete
COPIAR…
EXPONER 8080
CMD ["nodo", "aplicación"]

El proceso de compilación de esta aplicación implicaría crear un contenedor de nodos e instalar las dependencias (como Express.módulo js). Este proceso debería ocurrir sin errores. En aras de la simplicidad, no vamos a discutir ninguna prueba en este tutorial.

Canalización de GitLab Runner

Ahora agregaríamos otro archivo a nuestro repositorio que se llamaría .gitlab-ci.yml . Este archivo contendría las instrucciones para construir nuestro proyecto. Ahora, cada vez que enviamos una confirmación a nuestra instancia de GitLab, GitLab invocaría un Runner para compilar y probar el proyecto.

Asignamos a esta canalización varios trabajos que pueden ejecutarse todos independientemente unos de otros, lo que hace que el proceso de compilación sea más flexible. Para el repositorio anterior, este es un .gitlab-ci.yml crea este archivo en la raíz de tu repositorio:

imagen: nodo: último
etapas:
- construir
cache:
rutas:
- módulos_nodo /
install_dependencies:
etapa: construir
texto:
- npm install

Solo tenemos una etapa construir y tiene solo npm install como un guión. Este es un comando que tendría que ejecutar manualmente cada vez que se produzca un cambio en su proyecto. El corredor de GitLab haría esto por ti. Runner podría instalarse en un clúster de Kubernetes, un VPS en la nube o en su estación de trabajo local y, si está activo, estará esperando instrucciones del servidor de GitLab para ejecutar una compilación.

Instalaríamos y configuraríamos un Runner localmente para automatizarlo.

Obtener el token de corredor

Abra su repositorio en GitLab y visite su configuración de CD / CI. Esa es Configuración → CD / CI dentro de su repositorio de prueba.

Deje la configuración de Auto DevOps a su valor predeterminado y haga clic en EXPANDIR para expandir la configuración general de la canalización y se le mostrará un token de corredor. Copie su valor y, por supuesto, manténgalo en privado si valora su proyecto.

Con este token, su ejecutable local de GitLab Runner podrá registrarse de forma segura con su instancia de GitLab.

Instalación de GitLab Runner

GitLab-Runner es un pequeño programa ligero escrito en Go que ejecuta CI relacionado trabajos en su máquina local y envía los resultados a GitLab para que considere los cambios. Es un único binario ejecutable que se puede instalar en cualquier sistema operativo principal. Siga las instrucciones aquí, para su sistema operativo particular. Estas instalaciones varían enormemente, por lo que enumerarlas todas es inviable.

Alternativamente, puede usar Runner como un servicio de Docker, pero sigamos con la instalación tradicional, ya que los comandos son más fáciles de leer y comprender para el lector. Una vez que lo tenga instalado en su estación de trabajo local, debe ejecutar el comando:

$ gitlab-runner register

Esto le hará varias preguntas comenzando con su coordinador de GitLab-CI, que sería su instancia de GitLab:

$ gitlab-runner register
Ingrese la URL del coordinador de gitlab-ci (e.gramo. https: // gitlab.com /):
https: // gitlab.ejemplo.com

Luego te pedirá tu Runner Token, que obtuvimos en la sección anterior:

Ingrese el token de gitlab-ci para este corredor:

Your_Secret_Token

Luego, para obtener una descripción de identificación, puede omitir la adición de etiquetas presionando :

Ingrese la descripción de gitlab-ci para este corredor:

[Nombre de host]: demostración para configurar CI usando Runner

Ingrese las etiquetas gitlab-ci para este corredor (separadas por comas):

Registrando corredor ... realizado correctamente

Lo más importante es que le pedirá un ejecutor (más sobre esto en un momento), elegiremos Docker por el bien de nuestro ejemplo.

Ingrese el ejecutor: docker-ssh + máquina, kubernetes, paralelos, shell, ssh, virtualbox, docker + máquina, docker, docker-ssh:

estibador

La imagen de la ventana acoplable Base dentro de la cual se llevaría a cabo la compilación debe especificarse, nuestra aplicación de muestra usa el nodo, por lo que especificaremos una imagen de nodo:

Ingrese la imagen predeterminada de Docker (e.gramo. rubí: 2.1):

nodo: último

Corredor registrado con éxito. No dude en iniciarlo, pero si ya se está ejecutando, la configuración debería recargarse automáticamente!

Ahora, algo que necesita una pequeña explicación aquí es qué son exactamente ejecutores? La forma en que fluye el trabajo de CI es que la construcción de módulos, sus pruebas, etc. se conocen como trabajos y los ejecutores ejecutan esos trabajos. Si elige VirtualBox como ejecutor, entonces el corredor de GitLab se integrará con VirtualBox instalado localmente y ejecutará los trabajos de CI en una VM, si selecciona kubernetes, entonces sucedería en su clúster de Kubernetes, en la nube, si selecciona ssh puede delegar las tareas de CI a un servidor remoto.

Nuestro proyecto de muestra se basa en Docker, por lo que tiene sentido usar Docker como nuestro ejecutor. Necesitas tener Docker instalado localmente para esto.

Tener múltiples opciones para ejecutores hace que Runner sea más flexible. Es posible que desee compilar localmente porque los archivos del proyecto son demasiado grandes o puede querer ejecutar en un servidor remoto con 20 núcleos y medio terabyte de RAM porque el proceso de compilación es computacionalmente intensivo, especificar una opción de ejecutor le brinda esa flexibilidad.

Por último, en su shell querrá iniciar el servicio Runner:

$ gitlab-runner start

Vidente .gitlab-ci.yml en acción

Ahora hemos realizado todos estos cambios en nuestro repositorio local creado toda la aplicación.js, paquete.json, Dockerfile y .gitlab-ci.archivos yml. Presumiblemente, confirmó los cambios en su repositorio local ejecutando:

$ git stage nombre_archivo
$ git commit -m "Mensaje de confirmación"

Empujemos los cambios a nuestro GitLab remoto.

$ git push -u origen

Luego puede abrir su proyecto en GitLab, vaya a mi-proyecto → Pipeline y verá esta etiqueta que dice "aprobado" junto a la confirmación que realizó. Las confirmaciones posteriores también tendrán etiquetas.

Entonces esos son los conceptos básicos de CI usando GitLab y Runner. Espero que hayas disfrutado de la publicación y hayas aprendido algo nuevo de ella.