Qu'est-ce que l'intégration continue (CI)?

L'intégration continue est la prochaine étape logique après avoir un système de contrôle de version comme Git et un système de contrôle de version à distance comme GitLab ou GitHub pour les efforts de collaboration. Le problème auquel sont confrontés les grands projets est le suivant : au fur et à mesure que de nouvelles demandes d'extraction arrivent, elles doivent être testées puis intégrées à la branche principale et cet effort peut facilement prendre de quelques heures à quelques semaines selon la taille du projet, l'emplacement des membres de l'équipe, etc.

Comme pour tout problème de ce type, l'étape logique consiste à automatiser l'ensemble du casse-tête des tests. Nous le faisons en configurant un déclencheur tel que chaque fois que de nouveaux commits sont fusionnés dans une branche, un agent (GitLab Runner, par exemple) crée automatiquement l'environnement et le code, exécute tous les tests unitaires et les tests d'intégration par rapport à celui-ci. S'il y a une erreur rencontrée, cela donne un avertissement et un rapport de crash sinon vous obtenez un signal vert indiquant que tout fonctionne.

Bien entendu, poussé à son extrême logique, vous pouvez également automatiser le déploiement, configurer des tests A/B automatisés et supprimer complètement l'intervention humaine du processus. C'est ce qu'on appelle la livraison continue et/ou le déploiement continu en fonction du niveau d'automatisation. Mais nous nous concentrerions uniquement sur l'intégration continue dans ce tutoriel.

Conditions préalables

Nous allons nous concentrer sur la configuration d'un flux CI simple dans le didacticiel à l'aide d'une instance GitLab sur HTTPS dont nous avons parlé dans un article précédent.

De plus, nous supposons également que vous avez configuré un compte utilisateur dans cette instance GitLab et que vous avez un référentiel (cloné sur votre machine locale) géré sous votre nom d'utilisateur. C'est ce référentiel que nous utiliserons pour démontrer le workflow CI. Dans le tutoriel, son nom sera mon projet.

Pour tout lister :

1. Instance GitLab
2. Référentiel vierge, appelé mon-projet
3. Clone local de ce dépôt
4. Votre instance Git locale configurée pour pousser les modifications dans à distance.

Créer une application simple

Dans ce référentiel, créons un simple Node.application js. Cette application est un simple Express.js qui est destiné à être déployé dans un conteneur Docker. Le serveur donne une charge utile HTTP disant "Hello World" dans votre navigateur.

A la racine de votre dépôt local, créez un fichier application.js et ajoutez les lignes suivantes :

« utiliser strict » ;
const express = require('express');
// Constantes
const PORT = 8080 ;
const HTE = '0.0.0.0';
// Application
const app = express();
application.get('/', (req, res) =>
res.send('Bonjour tout le monde\n');
);
application.écouter(PORT, HTE);
console.log('Exécution sur http://$HOST:$PORT');

Créez ensuite un autre fichier paquet.json et ajoutez-y :

"nom": "docker_web_app",
"version 1.0.0",
"description": "Noeud.js sur Docker",
"auteur": "John Doe",
"principal": "serveur.js",
"scripts":
"start": "serveur de nœud.js"
,
"dépendances":
"express": "^4.16.1"

Enfin, créez un Dockerfile et ajoutez-y le contenu suivant :

À PARTIR du nœud : 8
# Créer un répertoire d'applications
WORKDIR /usr/src/app
# Installer les dépendances de l'application
# Un caractère générique est utilisé pour assurer à la fois le package.json ET package-lock.json sont copiés
COPIER le forfait*.json ./
Exécutez l'installation de npm
# Si vous construisez votre code pour la production
# RUN npm install --only=production
# Regrouper la source de l'application
COPIE…
EXPOSE 8080
CMD [ "nœud", "application"]

Le processus de construction de cette application impliquerait la création d'un conteneur de nœuds et l'installation des dépendances (comme Express.module js). Ce processus devrait se dérouler sans aucune erreur. Par souci de simplicité, nous n'allons pas discuter de tests dans ce tutoriel.

GitLab Runner Pipeline

Maintenant, nous ajouterions un autre fichier à notre référentiel qui s'appellerait .gitlab-ci.yml . Ce fichier contiendrait les instructions pour construire notre projet. Désormais, chaque fois que nous envoyons un commit à notre instance GitLab, GitLab invoque un Runner pour construire et tester le projet.

Nous attribuons à ce pipeline divers emplois qui peuvent fonctionner indépendamment les uns des autres, rendant le processus de construction plus flexible. Pour le dépôt ci-dessus, il s'agit d'un .gitlab-ci.yml créez ce fichier à la racine de votre référentiel :

image: nœud:dernier
étapes:
- construire
cache :
chemins :
- node_modules/
install_dependencies :
étape : construire
scénario:
- npm installer

Nous n'avons qu'une étape construire et il vient de npm installer comme scénario. Il s'agit d'une commande que vous devrez exécuter manuellement chaque fois qu'un changement intervient dans votre projet. Le coureur GitLab le ferait pour vous. Runner peut être installé dans un cluster Kubernetes, un VPS dans le cloud ou sur votre poste de travail local et s'il est actif, il attendra les instructions du serveur GitLab pour exécuter un build.

Nous installerions et configurerions un Runner localement pour l'automatiser.

Obtenir le jeton de coureur

Ouvrez votre référentiel sur GitLab et visitez ses paramètres CD/CI. C'est Paramètres → CD/CI dans votre référentiel de test.

Laissez le paramètre Auto DevOps à sa valeur par défaut et cliquez sur DÉVELOPPER pour développer les paramètres généraux du pipeline et un jeton de coureur s'affichera. Copiez sa valeur et, bien sûr, gardez-la privée si vous appréciez votre projet.

En utilisant ce jeton, votre exécutable GitLab Runner local pourra s'enregistrer en toute sécurité avec votre instance GitLab.

Installation de GitLab Runner

GitLab-Runner est un petit programme léger écrit en Go qui exécute CI lié emplois sur votre machine locale et envoie les résultats à GitLab pour qu'il considère les changements. Il s'agit d'un seul exécutable binaire qui peut être installé sur n'importe quel système d'exploitation majeur. Suivez les instructions ici, pour votre système d'exploitation particulier. Ces installations varient énormément, il est donc impossible de toutes les lister.

Alternativement, vous pouvez utiliser Runner en tant que service Docker, mais restons-en à l'installation traditionnelle, car les commandes sont plus simples à lire et à comprendre pour le lecteur. Une fois que vous l'avez installé sur votre poste de travail local, vous devez exécuter la commande :

$ gitlab-runner s'inscrire

Cela vous posera plusieurs questions en commençant par votre coordinateur GitLab-CI qui serait votre instance GitLab :

$ gitlab-runner s'inscrire
Veuillez saisir l'URL du coordinateur gitlab-ci (e.g. https://gitlab.com/) :
https://gitlab.Exemple.com

Il vous demanderait ensuite votre Runner Token, que nous avons obtenu dans la section précédente :

Veuillez saisir le jeton gitlab-ci pour ce coureur :

Your_Secret_Token

Ensuite, pour une description d'identification et vous pouvez simplement ignorer l'ajout de balises en appuyant sur :

Veuillez saisir la description de gitlab-ci pour ce coureur :

[Nom d'hôte] : Démo pour configurer CI à l'aide de Runner

Veuillez saisir les balises gitlab-ci pour ce coureur (séparés par des virgules) :

Inscription du coureur… réussie

Plus important encore, il vous demandera un exécuteur (plus de détails dans un instant), nous choisirons Docker pour notre exemple.

Veuillez saisir l'exécuteur : docker-ssh+machine, kubernetes, parallels, shell, ssh, virtualbox, docker+machine, docker, docker-ssh :

docker

L'image docker de base dans laquelle la construction aurait lieu doit alors être spécifiée, notre exemple d'application utilise un nœud, nous allons donc spécifier une image de nœud :

Veuillez saisir l'image Docker par défaut (e.g. rubis:2.1):

nœud:dernier

Coureur inscrit avec succès. N'hésitez pas à le démarrer, mais s'il est déjà en cours d'exécution, la configuration devrait être automatiquement rechargée!

Maintenant, quelque chose qui a besoin d'une petite explication voici ce que sont exactement exécuteurs testamentaires? La façon dont le travail de CI se déroule est que la construction de modules, leurs tests, etc. sont tous connus comme emplois et les exécuteurs exécutent ces tâches. Si vous choisissez VirtualBox en tant qu'exécuteur, GitLab runner s'intégrera à VirtualBox installé localement et exécutera les tâches CI dans une machine virtuelle. Si vous sélectionnez kubernetes, cela se produira dans votre cluster Kubernetes, dans le cloud, si vous sélectionnez ssh, vous pouvez déléguer les tâches CI à un serveur distant.

Notre exemple de projet est basé sur Docker, il est donc logique d'utiliser Docker comme exécuteur. Vous devez avoir Docker installé localement pour ça.

Avoir plusieurs options pour les exécuteurs rend Runner plus flexible. Vous pouvez vouloir construire localement parce que les fichiers du projet sont trop volumineux ou vous pouvez vouloir exécuter sur un serveur distant avec 20 cœurs et un demi-téraoctet de RAM car le processus de construction est gourmand en calcul, la spécification d'une option d'exécuteur vous donne cette flexibilité.

Enfin, dans votre shell, vous voudriez démarrer le service Runner :

$ gitlab-runner start

Voyant .gitlab-ci.yml en action

Maintenant, nous avons apporté toutes ces modifications dans notre référentiel local créé toute l'application.js, paquet.json, Dockerfile et .gitlab-ci.fichiers yml. Vraisemblablement, vous avez validé les modifications dans votre référentiel local en exécutant :

$ git stage nom_fichier
$ git commit -m « Message de validation »

Apportons les modifications à notre GitLab distant.

$ git push -u origine

Vous pouvez ensuite ouvrir votre projet dans GitLab, allez dans mon-projet → Pipeline et vous verrez ceci une balise indiquant "passé" à côté du commit que vous avez fait. Les commits suivants auront également des balises.

Voilà donc les bases de la CI utilisant GitLab et Runner. J'espère que vous avez apprécié l'article et que vous en avez appris quelque chose de nouveau.