¿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 que enfrentan los grandes proyectos es este: a medida que llegan las nuevas solicitudes de extracción, deben ser probadas y luego integradas a la rama maestra y este esfuerzo puede tomar fácilmente de unas pocas horas a unas pocas semanas, dependiendo del tamaño del proyecto, la ubicación de los miembros del equipo, etc.

Como cualquier problema, el paso lógico es automatizar todo el rigmarole de las pruebas. Lo hacemos configurando un desencadenante de tal manera que cada vez que las confirmaciones más nuevas se fusionen en una rama, un agente (GitLab Runner, por ejemplo) construya automáticamente el entorno y el código, ejecuta todas las pruebas unitarias y pruebas de integración en su contra. Si hay algún error encontrado, entonces ofrece una advertencia y un informe de bloqueo, de lo contrario, obtienes una señal verde que dice que todo funciona.

Por supuesto, llevado a su extremo lógico, también puede automatizar la implementación, configurar las pruebas A/B automatizadas y eliminar a toda la intervención humana del proceso. Que se denomina entrega continua y/o implementación continua dependiendo del nivel de automatización. Pero nos centraríamos en la integración continua en este tutorial.

Requisitos previos

Nos vamos a centrar en configurar un flujo de CI simple en el tutorial utilizando una instancia de gitlab sobre https que cubrimos en una publicación anterior.

Además, también suponemos que ha configurado una cuenta de usuario en esta instancia de GitLab y tiene un repositorio (clonado en su máquina local) gestionado bajo su nombre de usuario. Es este repositorio el 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 impulsar los cambios en remoto.

Creando una aplicación simple

En este repositorio, creemos un nodo simple.aplicación js. Esta aplicación es un simple expreso.servidor JS que debe implementarse en un contenedor Docker. El servidor ofrece 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:

'Use estricto';
const express = require ('express');
// constantes
Puerto const = 8080;
const host = '0.0.0.0 ';
// aplicación
const app = express ();
aplicación.get ('/', (req, res) =>
resonancia.enviar ('Hola mundo \ n');
);
aplicación.escuchar (puerto, host);
consola.log ('ejecutando http: // $ host: $ puerto');

Luego crea otro archivo paquete.json y agréguelo a continuación:

"Nombre": "docker_web_app",
"versión 1.0.0 ",
"Descripción": "nodo.JS en Docker ",
"Autor": "John Doe",
"Servidor principal.JS ",
"guiones":
"Inicio": "servidor de nodo.JS "
,
"Dependencias":
"Express": "^4.dieciséis.1 "

Por último, cree un Dockfile y agréguelo los siguientes contenidos:

Desde el nodo: 8
# Crear directorio de aplicaciones
WorkDir/USR/SRC/App
# Instalar dependencias de aplicaciones
# Se utiliza un comodín para garantizar ambos paquetes.json y paquete-bloqueo.JSON se copian
Paquete de copia*.json ./
Ejecutar instalación de NPM
# Si está construyendo su código para la producción
# Ejecutar npm instalación -solo = producción
# Fuente de la aplicación de paquete
COPIAR…
Exponer 8080
Cmd ["nodo", "aplicación"]

El proceso de compilación para esta aplicación implicaría crear un contenedor de nodo e instalar las dependencias (como Express.módulo js). Este proceso debería ocurrir sin ningún error. Por el bien de la simplicidad, no vamos a discutir ninguna prueba en este tutorial.

Tubería de corredores de gitlab

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 presionamos un compromiso con nuestra instancia de Gitlab, Gitlab invocaba a un corredor para construir y probar el proyecto.

Asignamos esta tubería varios trabajos que puede ejecutar todo se ejecuta independientemente el uno del otro, haciendo que el proceso de compilación sea más flexible. Para el repositorio anterior, este es un .gitlab-Ci.YML Cree este archivo en la raíz de su repositorio:

Imagen: nodo: Último
etapas:
- construir
cache:
caminos:
- node_modules/
install_dependencies:
Etapa: construir
guion:
- instalación de NPM

Tenemos solo una etapa construir Y tiene solo instalación de NPM Como un guión. Este es un comando que tendría que ejecutar manualmente cada vez que llegue un cambio a su proyecto. El corredor de Gitlab haría esto por ti. El corredor podría instalarse en un clúster Kubernetes, un VPS en la nube o en su estación de trabajo local y, si está activo, esperará instrucciones del servidor GitLab para ejecutar una compilación.

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

Conseguir el token de corredor

Abra su repositorio en gitlab y visite su configuración de CD/CI. Eso es Configuración → CD/CI Dentro de su repositorio de pruebas.

Deje la configuración automática de DevOps a su valor predeterminado y haga clic en EXPANDIR Para expandir la configuración de la tubería general y se le mostrará un token de corredor. Copiar su valor y, por supuesto, mantenerlo privado si valore su proyecto.

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

Instalación de GitLab Runner

Corredor de gitlab es un pequeño programa liviano escrito en GO que ejecuta CI Related trabajos en su máquina local y envía los resultados a GitLab para que considere los cambios. Es un solo binario ejecutable que se puede instalar en cualquier sistema operativo importante. Siga las instrucciones aquí, para su sistema operativo particular. Estas instalaciones varían enormemente, por lo que enumerarlas todas es inviable.

Alternativamente, puede usar el corredor como un servicio Docker, pero vamos a seguir a la instalación tradicional, ya que los comandos son más simples 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 que comienzan con su coordinador de Gitlab-Ci, que sería su instancia de Gitlab:

$ Gitlab-Runner Register
Ingrese la URL del Coordinador Gitlab-Ci (E.gramo. https: // gitlab.com/):
https: // gitlab.ejemplo.comunicarse

Luego pediría su token de corredor, que obtuvimos en la sección anterior:

Ingrese el token Gitlab-Ci para este corredor:

You_secret_token

Luego, para una descripción de identificación y puede omitir agregando cualquier etiqueta al presionar:

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 (coma separada):

Registrando corredor ... tuvo éxito

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

Ingrese el ejecutor: Docker-SSH+Machine, Kubernetes, Parallels, Shell, SSH, Virtualbox, Docker+Machine, Docker, Docker-SSH:

estibador

La imagen base Docker dentro de la cual se debe especificar la compilación y luego se debe especificar, nuestra aplicación de muestra usa el nodo, por lo que especificaremos una imagen de nodo:

Ingrese la imagen de Docker predeterminada (E.gramo. Ruby: 2.1):

nodo: último

Corredor registrado correctamente. Siéntase libre de comenzar, pero si se está ejecutando, la configuración debe volver a cargar automáticamente!

Ahora algo que necesita una pequeña explicación aquí es qué es exactamente ejecutores? La forma en que fluye el trabajo de CI es que la construcción de módulos, sus pruebas, etc. se conoce como trabajos y los ejecutores ejecutan esos trabajos. Si elige VirtualBox como ejecutor, entonces GitLab Runner se integraría con el VirtualBox instalado localmente y ejecutaría los trabajos de CI en una VM, si selecciona Kubernetes, entonces sucedería en su clúster 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 los ejecutores hace que el corredor sea más flexible. Es posible que desee construir localmente porque los archivos del proyecto son demasiado grandes o que desee ejecutar en un servidor remoto con 20 núcleos y medio terabyte de RAM porque el proceso de compilación es computacionalmente intensivo, especificando una opción de ejecutor le brinda esa flexibilidad.

Por último, en su caparazón desea comenzar el servicio de corredores:

$ 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, cometió los cambios en su repositorio local ejecutando:

$ Git Stage File_Name
$ Git Commit -M "Mensaje de confirmación"

Empujamos los cambios a nuestro remoto Gitlab.

$ git push -u origen

Luego puede abrir su proyecto en Gitlab, ir a mi proyecto → tubería y verás esto una etiqueta que dice "aprobado" al lado del compromiso que hiciste. Comodidades posteriores también tendrán etiquetas.

Así que eso es lo básico de CI usando Gitlab y Runner. Espero que hayas disfrutado de la publicación y hayan aprendido algo nuevo de ella.