CI/CD avec Jenkins

1. Introduction à Jenkins

Jenkins est l’un des outils les plus populaires pour mettre en place des pipelines de CI/CD. Contrairement à des plateformes comme GitHub Actions ou GitLab CI, Jenkins est une application que l’on installe et configure soi-même.

Il permet d’automatiser les principales étapes du cycle de vie d’une application : build, tests et déploiement, à l’aide de pipelines définis sous forme de code.

Objectif de ce tutoriel : mettre en place un pipeline Jenkins fonctionnel capable d’automatiser ces différentes étapes.

2. Prérequis et environnement de travail

Avant de créer notre premier pipeline CI/CD, assurons-nous de disposer de tout le nécessaire.

Jenkins peut être installé de différentes manières selon le contexte. Voici les principales approches.

Dans ce tutoriel, nous utiliserons Jenkins avec Docker afin de garantir une configuration simple, propre et reproductible. Si Jenkins n’est pas encore installé, tu peux suivre ce guide détaillé :Installer Jenkins sur Docker

3. Premier pipeline Jenkins

Avant de construire un pipeline CI/CD, nous allons commencer par un pipeline très simple. L’objectif est de comprendre ce qu’est un job Jenkins et comment fonctionne un Jenkinsfile.
Jenkins s’appuie sur un fichier appelé Jenkinsfile, placé à la racine du projet. Il décrit le pipeline sous forme de code.

Étape 1 : Créer un job Jenkins minimal

Crée un fichier Jenkinsfile à la racine de ton projet et ajoute le contenu suivant :

pipeline {
  agent any

  stages {
    stage('Mon premier job') {
      steps {
        echo 'Jenkins est correctement configuré !'
      }
    }
  }
}

Ce pipeline définit un job Jenkins contenant une seule étape qui affiche un message dans les logs. C’est l’équivalent d’un “Hello World” en CI/CD.

Étape 2 : Comprendre la structure du pipeline

4. Pipeline multi-stage avec Jenkins

Dans un projet réel, un pipeline est découpé en plusieurs étapes afin de séparer les responsabilités.

Ordre d’exécution :build →test →deploy

pipeline {
    agent any
    
    environment {
        PROJECT_NAME = 'demo-app'
        BUILD_DIR = 'build'
    }
    
    stages {
        stage('Checkout') {
            steps {
                echo 'Récupération du code source...'
                checkout scm
            }
        }
        
        stage('Build') {
            steps {
                echo 'Construction du projet...'
                sh '''
                    mkdir -p BUILD_DIR
                    cp -r index.html css BUILD_DIR/
                '''
            }
        }
        
        stage('Test') {
            steps {
                echo 'Exécution des tests...'
                sh '''
                    # Vérification de la présence des fichiers
                    test -f BUILD_DIR/index.html
                    test -f BUILD_DIR/css/style.css
                    echo "Tests réussis!"
                '''
            }
        }
        
        stage('Deploy') {
            steps {
                echo 'Déploiement de l'application...'
                sh '''
                    # Exemple de déploiement
                    echo "Déploiement vers l'environnement cible"
                    # cp -r BUILD_DIR/* /var/www/html/
                '''
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline exécuté avec succès!'
        }
        failure {
            echo 'Le pipeline a échoué.'
        }
        always {
            cleanWs()
        }
    }
}

Exécuter et vérifier le pipeline depuis Jenkins

⚠️ Pour que Jenkins puisse accéder à ton Jenkinsfile, il devrait être disponible sur Github ou Gitlab. Fais donc un push pour mettre à jour ton repository.

Maintenant que ton Jenkinsfile est prêt dans ton dépôt GitHub, il est temps de voir ton pipeline s’exécuter dans Jenkins. Comme nous avons installé Jenkins via Docker, tu peux y accéder dans ton navigateur à l’adresse :http://localhost:8080.

Après quelques secondes, un nouveau build apparaît dans la colonne de gauche. Si tout est correct, ton job s’exécute et Jenkins affiche un statut SUCCESS.

Ton pipeline est maintenant opérationnel ! Tu peux l’utiliser comme base pour créer des pipelines plus avancés, avec plusieurs stages pour le build, les tests et le déploiement.

Exemple de pipeline réussi

Exemple de pipeline échoué

5. Déploiement continu avec Docker

Jusqu'ici, notre pipeline automatisait le build et les tests : nous étions principalement dans une logique de CI (Continuous Integration). Nous allons maintenant ajouter une étape de CD (Continuous Deployment), c'est-à-dire un déploiement automatique de l'application après le succès du pipeline.

J'ai choisi d'illustrer le déploiement avec Docker, car c'est une solution très utilisée en entreprise et parfaitement adaptée à Jenkins. Cependant, un déploiement continu peut aussi se faire vers d'autres plateformes comme Vercel, Netlify, Render, Railway, un VPS ou un cloud provider.

Configuration préalable : Docker dans Jenkins

Nous allons d'abord supprimer le conteneur Jenkins qui existait déjà dans Docker avec cette commande :

docker rm -f jenkins

Tu peux remplacer jenkins par le nom que tu as donné à ton conteneur dans Docker Desktop.
Maintenant, nous allons relancer Jenkins avec le socket Docker monté terminal :

docker run -d `
  -p 8080:8080 -p 50000:50000 `
  -v jenkins_home:/var/jenkins_home `
  -v /var/run/docker.sock:/var/run/docker.sock `
  --name jenkins `
  jenkins/jenkins:lts

La ligne -v /var/run/docker.sock:/var/run/docker.sock permet à Jenkins d'utiliser le Docker de ta machine.
Maintenant, installe Docker CLI dans le conteneur Jenkins en exécutant cette commande dans ton terminal :

docker exec -u root jenkins bash -c "apt-get update && apt-get install -y docker.io"

Puis donnes les permissions :

docker exec -u root jenkins chmod 666 /var/run/docker.sock

Vérification

Pour confirmer que Docker fonctionne correctement dans Jenkins, tu peux créer un petit pipeline de test avec ce stage :

stage('Test Docker') {
    steps {
        sh 'docker --version'
    }
}

Si cette commande s'exécute sans erreur et affiche la version de Docker dans les logs Jenkins, tu es prêt à continuer !

Étape 1 : Créer un Dockerfile

À la racine de ton projet, crée un fichier nommé Dockerfile. Ce fichier définit comment ton application sera empaquetée dans une image Docker.

Copie et colle le code suivant :

FROM nginx:alpine

COPY build/ /usr/share/nginx/html

EXPOSE 80

Explication du Dockerfile :

• FROM nginx:alpine : on utilise une image Nginx légère basée sur Alpine Linux
• COPY build/ /usr/share/nginx/html : on copie le contenu du dossier build (généré par le pipeline) vers le répertoire par défaut de Nginx
• EXPOSE 80 : on expose le port 80 pour accéder à l'application

Étape 2 : Configurer les credentials Docker dans Jenkins

En essayant de te connecter à Jenkins, tu dois remettre ton met de passe administrateur. Si tu ne l'avais pas sauvegardé, tu peux le retrouver avec cette commande :

docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Ensuite, tu continueras la configuration en te servant de ce tutoriel : Installer Jenkins dans Docker.
Tu dois également recréer ton pipeline, pour cela, tu dois retourner à l'étape 4 de ce tutoriel.

Nous allons maintenant configurer Jenkins pour qu'il puisse se connecter à Docker Hub et pousser automatiquement les images après chaque build réussi.

Avant de continuer, assure-toi d'avoir :

• Un compte Docker Hub. Tu peux le créer sur le site : hub.docker.com
• Un repository Docker pour ton image

Étape 3 : Mettre à jour le Jenkinsfile complet

Nous allons maintenant créer un pipeline CI/CD complet qui inclut : build, tests, création de l'image Docker, push vers Docker Hub et déploiement automatique.

Voici le Jenkinsfile complet à utiliser :

pipeline {
    agent any
    
    environment {
        PROJECT_NAME = 'demo-app'
        BUILD_DIR = 'build'
        IMAGE_NAME = 'ton-dockerhub-username/demo-app'
    }
    
    stages {
        stage('Checkout') {
            steps {
                echo 'Récupération du code source...'
                checkout scm
            }
        }
        
        stage('Build') {
            steps {
                echo 'Construction du projet...'
                sh '''
                    mkdir -p ${BUILD_DIR}
                    cp -r index.html css ${BUILD_DIR}/
                '''
            }
        }
        
        stage('Test') {
            steps {
                echo 'Exécution des tests...'
                sh '''
                    test -f ${BUILD_DIR}/index.html
                    test -f ${BUILD_DIR}/css/style.css
                    echo "Tests réussis!"
                '''
            }
        }
        
        stage('Docker Build') {
            steps {
                echo "Construction de l'image Docker..."
                sh 'docker build -t $IMAGE_NAME .'
            }
        }
        
        stage('Docker Push') {
            steps {
                echo "Envoi de l'image vers Docker Hub..."
                withCredentials([usernamePassword(
                    credentialsId: 'docker-credentials',
                    usernameVariable: 'DOCKER_USER',
                    passwordVariable: 'DOCKER_PASS'
                )]) {
                    sh '''
                        echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin
                        docker push $IMAGE_NAME
                    '''
                }
            }
        }
        
        stage('Deploy') {
            steps {
                echo "Déploiement automatique de l'application..."
                sh '''
                    docker rm -f demo-app || true
                    docker run -d -p 8081:80 --name demo-app $IMAGE_NAME
                '''
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline exécuté avec succès!'
        }
        failure {
            echo 'Le pipeline a échoué.'
        }
        always {
            cleanWs()
        }
    }
}

⚠️ N'oublie pas de remplacer ton-dockerhub-username par ton vrai nom d'utilisateur Docker Hub et demo-app par le nom de ton repository dans la variable IMAGE_NAME !

Comprendre le pipeline CD

Analysons les nouveaux stages ajoutés pour le déploiement continu :

sh 'docker build -t $IMAGE_NAME .'

withCredentials([...]) {
    sh '''
        echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin
        docker push $IMAGE_NAME
    '''
}

sh '''
    docker rm -f demo-app || true
    docker run -d -p 8081:80 --name demo-app $IMAGE_NAME
'''

Étape 4 : Exécuter le pipeline et vérifier le déploiement

Pour vérifier que le déploiement fonctionne :

• Fais un commit et push tes modifications contenant le Dockerfile et le Jenkinsfile vers GitHub ou GitLab
• Lance le pipeline depuis Jenkins en cliquant sur "Build Now"
• Observe les logs pour chaque stage

Si tout se passe bien, tu devrais voir :

• L'image Docker construite avec succès
• L'image envoyée vers Docker Hub
• Le conteneur démarré automatiquement

Accéder à ton application :

Ton application est maintenant accessible dans ton navigateur à l'adresse :

Tu as maintenant un pipeline CI/CD complet et automatisé qui fait :

• 1.Build : construction du projet
• 2.Test : vérification des fichiers
• 3.Docker Build : création de l'image
• 4.Docker Push : envoi vers Docker Hub
• 5.Deploy : déploiement automatique du conteneur

6. Variables et secrets Jenkins

Comme pour GitLab CI/CD ou GitHub Actions, il est fortement déconseillé de stocker des informations sensibles (API keys, tokens, mots de passe) directement dans le code.

Jenkins permet de gérer ces secrets de manière sécurisée via : Manage Jenkins (l'icône ⚙️ en haut à gauche) → Credentials.
Cliques ensuite sur System puis Global credentials pour ajouter des variables secrètes. Chaque secret peut être assigné à un identifiant unique que tu pourras utiliser dans ton pipeline.

Exemple : pour utiliser un token API stocké dans Jenkins, tu peux déclarer une variable d’environnement dans ton Jenkinsfile :

pipeline {
  agent any

  environment {
    API_TOKEN = credentials('my-api-token')
  }

  stages {
    stage('Print Token') {
      steps {
        echo "Le token est sécurisé et peut être utilisé ici"
      }
    }
  }
}

⚠️ Cette variable ne sera pas affichée en clair dans les logs. Jenkins remplace automatiquement la valeur réelle par des astérisques si tu essaies de l’afficher.

7. Dépannage et bonnes pratiques

Pour maintenir tes pipelines Jenkins efficaces et fiables, voici quelques recommandations essentielles :

• Consulter les logs de build : clique sur un build puis Console Output pour voir les étapes exécutées et détecter les erreurs.
• Tester les étapes une par une : commence par des pipelines simples et ajoute les stages progressivement.
• Utiliser des pipelines lisibles : nomme clairement les stages et commente les étapes importantes.
• Versionner systématiquement le Jenkinsfile : le Jenkinsfile doit rester dans ton dépôt Git pour garder un historique et faciliter la collaboration.
• Gérer les secrets via Jenkins Credentials : ne jamais stocker d’API keys ou mots de passe en clair.

8. Conclusion

Jenkins reste une solution extrêmement puissante pour mettre en place des pipelines CI/CD sur mesure. Son principal avantage est la flexibilité, c'est-à-dire que tu contrôles entièrement ton serveur, tes agents et tes pipelines.

Après avoir exploré Github Actions, GitLab CI/CD et Jenkins, tu disposes désormais d’une vision claire des approches du CI/CD :

• Github Actions et GitLab CI/CD : intégrés, faciles à configurer dans le dépôt, idéaux pour démarrer rapidement.
• Jenkins : indépendant, extrêmement flexible et personnalisable, parfait pour les projets complexes ou multi-environnements.

Tu peux maintenant expérimenter avec des pipelines multi-stage, gérer des secrets et automatiser des déploiements réels. Chaque projet te permettra de te familiariser avec la puissance de Jenkins.