⚙️ Jenkins – CI/CD, Pipelines & Déploiement

Qu'est-ce que Jenkins ?

Jenkins est un serveur d'automatisation open-source (écrit en Java). C'est l'outil de **CI/CD** (Intégration Continue / Déploiement Continu) le plus utilisé au monde.

Son rôle est d'automatiser les phases non-humaines du développement logiciel (build, test, déploiement).

CI/CD (Intégration Continue / Déploiement Continu)

CI (Continuous Integration) :

1. Un développeur "push" son code vers Git.
2. Jenkins détecte le push (via Webhook).
3. Jenkins "build" le projet (ex: npm install, mvn package).
4. Jenkins lance les tests unitaires (npm test).
5. Jenkins rapporte le résultat (OK/Échec) au développeur.

CD (Continuous Deployment) :

6. Si la CI est OK, Jenkins "package" l'application (ex: image Docker).
7. Jenkins déploie l'application sur un serveur (Staging, Prod).

Jenkins vs (GitLab CI, GitHub Actions)

Controller (ex-Master)

Le Controller (Contrôleur) est le serveur central (le "cerveau").
Il ne fait pas de travail de build.

• Stocke la configuration (jobs, plugins).
• Gère l'interface web (Port 8080).
• Planifie et distribue les "builds" aux Agents.

Agent (ex-Slave)

Un Agent (Agent) est un "worker" (l'esclave) qui exécute les tâches.

• Peut être une VM, un conteneur Docker, un pod K8s.
• Possède les "outils" (ex: Java, Node.js, Docker).
• Reçoit les ordres du Controller ("Build ce projet") et exécute les étapes.

Schéma de flux

[Image d'une architecture Jenkins Controller/Agent]
(Dev -> 'git push')
   |
   ▼ (Webhook)
+-----------------------+
| Controller (Serveur)  |
| (Port 8080)           |
| (Gère l'UI, Planifie) |
+-----------------------+
   |
   | (Lance le build via SSH ou JNLP)
   |
   +----------+-----------------+
   |          |                 |
   ▼          ▼                 ▼
+--------+ +--------+       +--------+
| Agent 1| | Agent 2|       | Agent 3|
| (Linux)| | (Win)  |       | (Docker)|
| (Java 11)| (NodeJS) |       | (Python)|
+--------+ +--------+       +--------+
 (Exécute le build, 'npm install'...)

Jenkins est Java

Jenkins est une application .war (Web Archive) Java. Il nécessite un Java Development Kit (JDK) (ou JRE) pour s'exécuter (sur le Controller et les Agents).

Version Requise

• Jenkins LTS (actuel) : Java 11 ou Java 17. (Java 8 est obsolète).

Installation (OpenJDK 17 - Ubuntu/Debian)

sudo apt update
sudo apt install -y openjdk-17-jdk

# Vérifier
java -version
# openjdk version "17.0.x" ...

Installation (OpenJDK 17 - RHEL/Rocky)

sudo dnf install -y java-17-openjdk-devel

# Vérifier
java -version

docker run (Simple)

L'image officielle (jenkins/jenkins:lts) est recommandée. La persistance de /var/jenkins_home est cruciale.

docker run -d \
    --name jenkins \
    -p 8080:8080 \
    -p 50000:50000 \
    -v jenkins_home:/var/jenkins_home \
    jenkins/jenkins:lts-jdk17

# -p 8080: (UI Web)
# -p 50000: (Agents JNLP)
# -v jenkins_home:... (Volume pour les données)

docker-compose.yml (Plus robuste)

version: '3.8'
services:
  jenkins:
    image: jenkins/jenkins:lts-jdk17
    container_name: jenkins
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - jenkins_home_data:/var/jenkins_home
    restart: unless-stopped

volumes:
  jenkins_home_data:

1. Déverrouillage

Lors du premier accès (http://localhost:8080), Jenkins demande un mot de passe initial (pour prouver que vous êtes l'admin).

Ce mot de passe se trouve sur le serveur :

# (Si install Linux)
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

# (Si install Docker)
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

2. Plugins & Admin

Customize Jenkins :
-> "Install suggested plugins" (Recommandé pour les débutants).

Create First Admin User :
Créez votre propre compte (ex: ideo_admin) pour ne plus utiliser le mot de passe généré.

"Manage Jenkins" (Administrer Jenkins)

C'est le panneau de configuration central de Jenkins. C'est ici que vous gérez :

• System : Configuration globale (URL, variables d'env...).
• Tools : (Important) Définir les outils (JDK, Git, Node.js) pour les Agents.
• Nodes and Clouds : Ajouter/Gérer les Agents.
• Credentials : (Important) Stocker les secrets (mots de passe, clés SSH).
• Plugins : Gérer les plugins.
• Security : Gérer les utilisateurs et les permissions.

Gestion des Plugins

La puissance de Jenkins vient de ses plugins. (Manage Jenkins -> Plugins).

Plugins "indispensables" à installer (s'ils ne le sont pas) :

Le "Nouveau" mode (Moderne)

"Pipeline as Code" est la méthode moderne. La configuration n'est plus dans l'UI de Jenkins, mais dans un fichier texte appelé Jenkinsfile, stocké à la racine de votre projet Git.

Avantages

• Versionné : La CI/CD est dans Git, comme le code (traçabilité).
• Reproductible : Il suffit de pointer Jenkins vers le SCM.
• Robuste : Permet une logique complexe (try/catch, parallèle, conditions).
• Partageable : (Via Shared Libraries).

Jenkinsfile (Exemple simple)

pipeline {
    agent any // Sur quel agent ?
    
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
    }
}

Commandes de base (steps)

Étapes de Plugins (Commun)

Syntaxe Groovy

Le pipeline "Scripted" est du code Groovy pur. Il est plus puissant mais plus difficile à lire.

Il commence par node { } (l'équivalent de agent) et les étapes sont des stage { } (fonctions).

Exemple (Scripted)

node('linux') { // 1. Bloc 'node' (agent)
    try {
        
        stage('Checkout') {
            git 'https://github.com/...'
        }
        
        stage('Build & Test') {
            // Logique Groovy (boucles, conditions...)
            def nodeVersion = "node:18"
            
            docker.image(nodeVersion).inside {
                sh 'npm install'
                sh 'npm test'
            }
        }
        
        stage('Parallel Deploy') {
            // Exécuter en parallèle
            parallel(
                staging: {
                    stage('Deploy Staging') {
                        echo "Deploying to staging..."
                    }
                },
                qa: {
                    stage('Deploy QA') {
                        echo "Deploying to QA..."
                    }
                }
            )
        }
        
    } catch (e) {
        // Gérer les erreurs
        currentBuild.result = 'FAILURE'
        slackSend(message: "Échec: ${e.message}")
        throw e
    } finally {
        // Cleanup
        deleteDir()
    }
}

1 Job par Branche

Un job "Pipeline" simple est lié à une seule branche (ex: main). C'est inutile pour le développement (feature, dev).

Un job "Multibranch Pipeline" scanne un dépôt Git (via Webhook) et crée/supprime automatiquement des jobs Jenkins pour *chaque branche* qui contient un Jenkinsfile.

Création

1. New Item -> Multibranch Pipeline.
2. Branch Sources : Add Source -> Git.
3. Entrez l'URL du dépôt et les Credentials.
4. Save.

Exemple de Jenkinsfile (Multibranch)

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
        stage('Deploy Staging') {
            // Ne s'exécute que sur la branche 'dev'
            when { branch 'dev' }
            steps {
                echo "Deploying to STAGING..."
            }
        }
        stage('Deploy Prod') {
            // Ne s'exécute que sur 'main'
            when { branch 'main' }
            steps {
                // (Attend une approbation manuelle)
                input message: "Déployer en PROD ?"
                echo "Deploying to PRODUCTION..."
            }
        }
    }
}

Une UI pour les Pipelines

L'interface "classique" de Jenkins est dense et peu adaptée à la visualisation des stages (Build, Test, Deploy) d'un Pipeline.

Blue Ocean est un plugin (souvent installé par défaut) qui offre une interface utilisateur moderne, visuelle et interactive, dédiée aux Pipelines (Multibranch ou non).

Accès : http://jenkins:8080/blue

Visualisation claire des stages (surtout parallel), accès direct aux logs par étape, et ré-exécution d'un stage spécifique.