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 distante comme Gitlab ou GitHub pour les efforts collaboratifs. Le problème auquel les grands projets sont confrontés est la suivante - comme de nouvelles demandes de traction arrivent, elles doivent être testées puis intégrées à la branche principale et cet effort peut facilement prendre de quelques heures à quelques semaines en fonction de la taille du projet, l'emplacement des membres de l'équipe, etc.

Comme un tel problème, l'étape logique consiste à automatiser l'intégralité de Rigmarole des tests. Nous le faisons en configurant un déclencheur de telle sorte que chaque fois que les nouveaux engins sont fusionnés dans une branche un agent (GitLab Runner, par exemple) construit automatiquement l'environnement et le code, exécute tous les tests unitaires et les tests d'intégration contre lui. S'il y a une erreur rencontrée, il donne un avertissement et un rapport de crash sinon vous obtenez un signal vert disant que tout fonctionne.

Bien sûr, emmené à son extrême logique, vous pouvez également automatiser le déploiement, configurer les tests A / B automatisés et éliminer l'ensemble de l'intervention humaine du processus. Qui est appelé livraison continue et / ou déploiement continu en fonction du niveau d'automatisation. Mais nous nous concentrions uniquement sur l'intégration continue dans ce tutoriel.

Conditions préalables

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

De plus, nous supposons également que vous avez configuré un compte d'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 flux de travail CI. Dans le tutoriel, son nom sera mon projet.

Pour tout énumérer:

1. Instance gitlab
2. Référentiel vierge, appelé my-project
3. Clone local de ce référentiel
4. Votre instance GIT locale configurée pour repousser les modifications télécommande.

Création d'une application simple

Dans ce référentiel, créons un nœud simple.Application JS. Cette application est un simple express.JS Server qui est destiné à être déployé dans un conteneur Docker. Le serveur donne une charge utile HTTP disant «bonjour le monde» dans votre navigateur.

Dans la racine de votre référentiel local, créez un fichier appliquer.js et ajouter les lignes suivantes:

«utiliser strict»;
const Express = require ('express');
// Constantes
Const port = 8080;
const host = '0.0.0.0 ';
// application
const app = express ();
appliquer.get ('/', (req, res) =>
res.envoyer ('Hello World \ n');
);
appliquer.écouter (port, hôte);
console.log ('exécuter sur http: // $ host: $ port');

Puis créez un autre fichier emballer.json et ajoutez ce qui suit:

"nom": "docker_web_app",
"version 1.0.0 ",
"Description": "Node.js sur docker ",
"Auteur": "John Doe",
"Main": "Serveur.JS ",
"scripts":
"Démarrer": "Node Server.JS "
,
"dépendances":
"Express": "^ 4.16.1"

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

Du nœud: 8
# Créer un répertoire d'applications
Workdir / usr / src / app
# Installer les dépendances des applications
# Un joker est utilisé pour assurer les deux forfaits.json et verrouillage de package.json sont copiés
Copier le package *.json ./ /
Exécuter l'installation de NPM
# Si vous construisez votre code pour la production
# Run NPM Install --only = Production
Source de l'application # bundle
COPIE…
Exposer 8080
Cmd ["nœud", "app"]

Le processus de construction de cette application impliquerait de créer un conteneur de nœud et d'installer les dépendances (comme express.Module JS). Ce processus devrait se produire sans aucune erreur. Par souci de simplicité, nous n'allons pas discuter de tests dans ce tutoriel.

Pipeline de coureurs Gitlab

Maintenant, nous ajouterions un autre fichier à notre référentiel qui serait appelé .gitlab-ci.YML . Ce fichier contiendrait les instructions pour construire notre projet. Maintenant, chaque fois que nous poussons un engagement sur notre instance gitlab, Gitlab invoquerait un coureur pour construire et tester le projet.

Nous attribuons ce pipeline divers emplois ce qui peut s'exécuter indépendamment les uns des autres, ce qui rend le processus de construction plus flexible. Pour le repo ci-dessus, c'est un .gitlab-ci.YML Créez ce fichier à la racine de votre référentiel:

Image: Node: Dernière
étapes:
- construire
Cache:
Chemins:
- node_modules /
install_dependces:
Étape: construire
scénario:
- Installation de NPM

Nous n'avons qu'une seule étape construire Et il a juste Installation de NPM En tant que script. Ceci est une commande que vous devrez exécuter manuellement chaque fois qu'un changement arrive à votre projet. Le coureur Gitlab ferait ça pour vous. Le coureur pourrait être installé dans un cluster Kubernetes, un VPS dans le cloud ou dans votre poste de travail local et s'il est actif, il attendra les instructions du serveur GitLab pour exécuter une version.

Nous installions et configurerions un coureur 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 À l'intérieur de votre référentiel de test.

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

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

Installation de GitLab Runner

Gitlab 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 examine les modifications. Il s'agit d'un seul binaire exécutable 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 sauvagement, donc les répertorier tous sont irréalisables.

Alternativement, vous pouvez utiliser Runner comme service Docker, mais respectons simplement 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 Registre

Cela vous posera plusieurs questions à partir de votre coordinateur Gitlab-CI qui serait votre instance Gitlab:

$ Gitlab Runner Registre
Veuillez saisir l'URL du coordinateur Gitlab-CI (E.g. https: // gitlab.com /):
https: // gitlab.exemple.com

Il demanderait ensuite votre jeton de coureur, que nous avons obtenu dans la section précédente:

Veuillez saisir le jeton Gitlab-Ci pour ce coureur:

Votre_secret_token

Ensuite, pour une description d'identification et vous pouvez simplement ignorer l'ajout de tags en frappant:

Veuillez saisir la description de Gitlab-CI pour ce coureur:

[Nom d'hôte]: démo pour la configuration de CI à l'aide du coureur

Veuillez saisir les balises GitLab-CI pour ce coureur (comma séparé):

Enregistrement du coureur… réussi

Plus important encore, il vous demandera un exécuteur testamentaire (plus à ce sujet dans un instant), nous choisirons Docker pour le bien de notre exemple.

Veuillez entrer l'exécuteur 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 ensuite être spécifiée, notre exemple d'application utilise le nœud afin que nous spécifions une image de nœud:

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

Node: dernier

Runner enregistré avec succès. N'hésitez pas à le démarrer, mais s'il s'exécute déjà, la configuration doit être automatiquement rechargée!

Maintenant, quelque chose qui a besoin d'une petite explication ici est ce que sont exactement exécuteurs exécuteurs? La façon dont le travail CI circule est que la construction de modules, leurs tests, etc emplois et les exécuteurs exécuteurs exécutent ces travaux. Si vous choisissez VirtualBox en tant qu'exécuteur testamentaire, alors GitLab Runner s'intégrerait au VirtualBox installé localement et exécuterait les travaux CI dans une machine virtuelle, si vous sélectionnez Kubernetes, cela se produirait 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 projet d'échantillon 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 exécuteurs rend le coureur plus flexible. Vous voudrez peut-être construire localement parce que les fichiers du projet sont trop grands ou que vous voudrez peut-être exécuter dans un serveur distant avec 20 cœurs et un demi-téraoctet de RAM car le processus de construction est à forte intensité de calcul, spécifiant une option exécutrice vous donne cette flexibilité.

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

$ Gitlab Runner Start

Voyant .gitlab-ci.YML en action

Maintenant, nous avons apporté tous ces modifications dans notre dépôt local créé toute l'application.JS, package.Json, Dockerfile et .gitlab-ci.fichiers yml. Vraisemblablement, vous avez commis les modifications à votre référentiel local en fonctionnant:

$ git stage file_name
$ git commit -m "commit message"

Poussons les modifications à notre gitlab à distance.

$ git push -u origine

Vous pouvez ensuite ouvrir votre projet à Gitlab, aller à My-Project → Pipeline Et vous verrez cela une étiquette disant «passée» à côté de l'engagement que vous avez fait. Commits ultérieurs, aura également des balises.

C'est donc les bases de CI en utilisant Gitlab et Runner. J'espère que vous avez apprécié le post et en appris quelque chose de nouveau.