Hello,

Cette semaine on parle de CI/CD.

Tu en entends parler partout mais tu n'as jamais eu le temps de t'y pencher.

En tant que Dev, je pense que ca vaut le coup de s'y arrêter.

Le monde magique de l'automatisation

Imagine un monde où en tant que Dev qui bosse souvent seul, si tu pouvais te concentrer sur tes features.

Un monde, où chaque commit est synonyme de passage en production serein et sans effort.

Ce monde paisible existe... sauf que tu ne le connais peut-être pas encore.

Aujourd’hui, quand tu as fini le dev d'une feature, tu dois :

• Vérifier statiquement ton code avec un linter

• Builder ton app, ton docker...

• Lancer les tests unitaires (si tu en as fait)

• Pousser le code ou le build sur l'environnement de Recette avec un filezilla via ssh

• Vérifier que toutes les dépendances sont toujours ok avec des lignes des commandes

• Tester ton code sur l'environnement recette

• Pousser le code sur l'environnement de prod (rebelote)

• Vérifier les dépendances

• Croiser les doigts pour que tout fonctionne

Toutes ces actions sont souvent manuelles

Elles nécessitent de ne rien oublier, de ne pas faire d'erreurs dans les copier/coller

Il faut retrouver les bons credentials pour aller sur les bons serveurs ....

Le pire c'est que même quand tu penses que t'as tout bien fait, ca finit par planter la production.
Il manquait un détail, t'avais pas fait gaffe...

Au final, c'est décourageant de livrer plein de petites features.
Tu finis par faire des gros commits qui contiennent plein de modifications de code, pour éviter d'avoir à refaire les mêmes actions encore et encore... juste pour passer en production.

Et en faisant ça, tu limites ta capacité à développer, tu te génères plus de bug et au bout du bout, tu te décourages complètement.

A ce moment tu commences à rechercher des outils pour t'aider

Tu trouves des scripts sur stackoverflow : il marche bien pendant un certain temps.
Puis pour une raison que t'ignores, ca ne marche plus. C'est impossible à debugger car tu n'y comprends pas grand chose.

Tu utilises le dernier outil vu sur un blog : tu te rend compte que juste l'installation et la configuration t'as déjà perdu une semaine de taff.

Le problème ce n'est pas les outils ou les scripts, c'est de croire qu'automatiser, ca se fait sans effort.

Alors si les Dev veulent passer en production plus sereinement, il faut que chaque commit déclanche une succession d'actions automatiques et contrôlées, prédéfinies à l'avance.

Les pipeline CI/CD

La CI/CD permet qu'à chaque commit, une sucession d'actions prédéfinies soient réalisées automatiquement pour te garantir une mise en production simple.

Même si ton commit est tout petit, cela ne te coute pas une seconde de plus.

Cette succession d'actions s'appelle une pipeline.

La pipeline possède deux grosses parties :

La partie CI (Continuous Integration) permet de s'assurer que le code modifié s'intègre bien au reste du code existant.

S'intégrer veut dire plein de choses différentes :

• Est-ce que l'analyse statique du code est ok ?

• Est-ce les bonnes pratiques de programmation sont respectées ?

• Est-ce que les tests passent correctement ?

La partie CD (Continuous Deployement) permet de s'assurer que le code modifié sera bien déployé sur les environnements (de Recette, de Production ...) et au bon moment.

Ils existent plusieurs actions :

• Est-ce que le build s'est bien passé ?

• Est-ce que toutes les dépendances ont bien été installées ?

• Est-ce que les push vers les serveurs se sont bien déroulés ?

Tout ce que tu devais faire à la main... disparait.

A chaque étape, si l'action est en erreur, on s'arrête avant d'aller plus loin.
En effet, plus on détecte une erreur tôt, plus il est facile de la corriger et moins elle a eu d'impact.

A court terme :

• tu te prends plus la tête à faire des mises en production

• tu délivres plus de valeurs plus rapidement

• tu mets ton énergie sur ce qui compte vraiment

• tu réduis le temps entre la fin d'un développement et son passage en prod

• tu réduis les erreurs et bugs directement avant qu'ils n'arrivent sur la prod

A long terme :

• tu économises de l'énergie et surtout de la motivation

• tu professionnalises tes méthodes de travail

• tu ajoutes des compétences à ton CV/portefolio

Tout ça, c'est possible mais... il faut accepter de prendre du temps au départ
Se poser, réfléchir...
Les gens qui bossent avec méthodes finissent par avoir des résultats nettement meilleurs que les gens qui courent dans tous les sens.

Concrètement...

En se basant sur des outils comme GitHub et gitlab, tu mets en place tes pipelines.

Chaque pipeline est composée de scripts et de lignes de commandes (d'où l'intérêt d'avoir de bonnes bases quand même).

Chaque script n'effectue qu'un seul travail qui automatise ce que tu faisais à la main.

Tu améliores la sécurité de tes actions et parfois aussi des accès à tes serveurs.

Tu n'es plus soumis aux erreurs humaines d'inattention (plus de copier/coller qui foirent)

Tu es autonome pour passer en prod : plus besoin d'attendre un OPS pour qu'il aille faire des actions sur le linux.

Avant tu te prenais la tête pour des choses qui ne concernaient même pas le Dev
Tu t'énervais à cause des lignes de commandes...

Maintenant tu peux profiter du temps récupéré pour dev encore mieux et plus.

Tu as maintenant tous les arguments pour commencer à te créer tes premières pipelines dans ta CI/CD.

Pour aller plus loin

Tu sais le principe d'une CI/CD, ce qu'est une pipeline, le fait qu'il faille des scripts, que c'est plus facileavec un outil de type Github/Gitlab, qu'il faut un peu de temps pour apprendre mais que c'est rentable sur le long terme.

Pour progresser, rien de plus simple : faire ta première pipeline.

Une pipeline qui ne ferait qu'une seule chose : un tout petit truc répétitif, contrôlé et controlable facilement, qui n'a pas beaucoup d'impact en cas de panne/bug/erreur.

Une fois que ca fonctionne sur ce petit truc, tu itères en essayant des choses de plus en plus compliquées.

Je te déconseille de copier/coller une pipeline complète qui fait tout ... tu n'auras rien appris.