Intégration Continue avec Jenkins

Mise à jour : 02/09/2024

Jenkins est un système très puissant d’intégration continue, intégrant de nombreuses fonctionnalités et évoluant rapidement. Je vous en propose une introduction.

Notions importantes

Avant de commenter, nous allons bien définir l’architecture et les principaux concepts de Jenkins

Master, agent(s) et Protocoles

Jenkins utilise une architecture de type maitre/agent(s). Le nœud maître de Jenkins contient toutes ses configurations. Le master orchestre et contrôle l’exécution de tous les workflows définis dans des pipelines et exécutés sur les nœuds agents. Il existe deux types de nœuds : les agents statiques et les agents dynamiques (provisionné au besoin). Les nœuds statiques sont installés sur des VM directement, alors que les nœuds dynamiques sont provisionnés sur des clusters kubernetes ou dans des containers. Le master peut aussi être installé sur un cluster kubernetes.

Pour communiquer avec agents, le master utilisent soir le protocole SSH, soit le protocole JNLP (port 5000) ou soit avec des appels API.

Pipelines Jenkins

Les pipelines Jenkins sont des worflows qui peuvent être complexes décrivant toutes les étapes d’un processus d’intégration continue. Ces pipelines sont déclarés dans des fichiers appelés des Jenkinsfile.

Les JenkinsFile peuvent être écrits avec deux types de syntaxe à base du DSL Groovy :

Déclaratif : Simple à écrire faisant appel à des directives.
Scripté : Écris en Groovy donc plus complexe à écrire.

Il est possible d’étendre le déclaratif avec des fonctions, mais attention à ne pas mélanger les genres. Il faudra plutôt faire appel à des plugins, voir des Librairies partagées ou SharedLib pour éviter de réécrire tout partout du code identique.

Plugins

Les plugins sont des modules développés par la communauté Jenkins. Ils permettent de compléter les fonctionnalités qui ne sont pas nativement supportées par Jenkins. Par exemple, pour télécharger des fichiers depuis un bucket AWS S3, vous pouvez installer le plugin AWS. Vous pouvez aussi développer vos propres plugins. Mais attention de bien les choisir, pour ne pas, vous retrouvez avec des plugins non maintenus et souffrant de failles de sécurité. Vous pouvez retrouver la liste des plugins ici ↗.

Credentials

Pour maximiser la sécurité, il est possible de stockers les informations d’identification ans des fichiers cryptés sur le noeud master de Jenkins. Ces crédentials peuvent ensuite être utilisé dans les scripts de Pipeline.

Installation de Jenkins

Plutôt que d’installer Jenkins avec les packages des distributions Linux, je vais plutôt l’installer dans un cluster kubernetes de mon homelab, qui pour rappel fonctionne avec k3s.

Installation des prérequis

Pour que le déploiement fonctionne, il faudra au préalable installer helm et è sur votre machine locale. Pour cela, comme d’habitude, je vais utiliser asdf qui permet d’installer localement plusieurs versions de la plupart des outils devops.

asdf plugin add kubectl
asdf install kubectl 1.25.2
asdf global kubectl 1.25.2
asdf plugin add helm 3.9.4
asdf install helm latest
asdf global helm latest

Installation et Configuration du Helm Chart

Je vais utiliser le chart Helm officiel, car il est très bien construit.

helm repo add jenkins https://charts.jenkins.io
helm repo update

Nous allons créer un fichier des valeurs pour personnaliser notre installation.

helm show values jenkins/jenkins > jenkins-values.yaml
vi jenkins-values.yaml

Changez les valeurs suivantes :

controller:
  jenkinsUrl: "http://jenkins.localhost"
  numExecutors: 2

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: traefik
  hostName: jenkins.localhost

Comme k3s intègre Traefik comme gestionnaire d’ingress autant en profiter. Pour que cela fonctionne, il faut ajouter à votre fichier /etc/hosts l’adresse jenkins.localhost à l’adresse 127.0.0.1 :

127.0.0.1  localhost jenkins.localhost

Tout être prêt pour déployer notre chart Helm

Déploiement de jenkins dans notre cluter kubernetes

Il suffit de lancer la commande suivante :

helm install jenkins/jenkins -g -f jenkins-values.yaml

Veuillez patienter quelques minutes, le temps de télécharger les images de containers et le temps que la configuration se fasse. Pour contrôler l’avancement il suffit d’avoir 2/2 dans le retour de la commande suivante :

kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
jenkins-1674465334-0   2/2     Running   0

Contrôlons que l’ingress est bien créé :

kubectl get ingress
NAME                 CLASS    HOSTS               ADDRESS           PORTS   AGE
jenkins-1674465334   <none>   jenkins.localhost   192.168.123.198   80      101m

Vérifier dans votre navigateur, vous devriez obtenir la mire de connexion :

jenkins login

Notre premier pipeline Jenkins

Création du dépôt

Il suffit de créer dans votre compte gitlab un dépôt contenant un simple fichier Jenkinsfile avec ce contenu :

pipeline {
    agent any
    stages {
       stage('build') {
          steps {
             echo 'First Stage'
          }
       }
       stage('test') {
           steps {
               echo 'Second stage'
           }
       }
    }
 }

Notre pipeline est composé de deux stages (build et test) composés tous les deux d’un seul step. Pour les personnes connaissant gitlab-ci la transition ne devrait pas être compliqué. Ah si, il faut apprendre le langage groovy. Mais pour le moment, je vais n’utiliser que de simples steps. Je vous propose de vous rendre dans le billet dédié à l’écriture des jenkinsfile.

Pour permettre à Jenkins de cloner le dépôt, vous avez le choix d’utiliser un couple username + PAT ou une clé SSH. Je vais utiliser la première solution.