Jenkins : intégration continue et automatisation

Qu'est-ce que Jenkins ?

Jenkins est un serveur d'automatisation open-source écrit en Java. C'est l'outil de référence pour l'intégration continue (CI) et le déploiement continu (CD), utilisé par des millions de développeurs dans le monde.

Jenkins permet d'automatiser toutes les étapes du cycle de vie d'une application : build, tests, déploiement, monitoring, et bien plus encore grâce à son écosystème riche de plus de 1800 plugins.

Installation de Jenkins

Installation sur Linux (Ubuntu/Debian)

# Ajouter la clé GPG Jenkins
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
  /usr/share/keyrings/jenkins-keyring.asc > /dev/null

# Ajouter le dépôt Jenkins
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
  https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
  /etc/apt/sources.list.d/jenkins.list > /dev/null

# Installer Java (prérequis)
sudo apt-get update
sudo apt-get install fontconfig openjdk-17-jre

# Installer Jenkins
sudo apt-get install jenkins

# Démarrer Jenkins
sudo systemctl start jenkins
sudo systemctl enable jenkins

# Vérifier le statut
sudo systemctl status jenkins

Installation via Docker

# Créer un volume pour persister les données
docker volume create jenkins-data

# Lancer Jenkins dans un conteneur
docker run -d \
  --name jenkins \
  -p 8080:8080 \
  -p 50000:50000 \
  -v jenkins-data:/var/jenkins_home \
  jenkins/jenkins:lts

# Récupérer le mot de passe initial
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Premier démarrage

Accédez à http://localhost:8080 et suivez l'assistant de configuration :

1. Entrez le mot de passe initial (affiché dans les logs ou dans /var/jenkins_home/secrets/initialAdminPassword)
2. Installez les plugins suggérés
3. Créez votre compte administrateur
4. Configurez l'URL de Jenkins

Créer votre premier job

Freestyle Project

Le type de job le plus simple pour démarrer :

1. Cliquez sur "Nouveau Item"
2. Entrez un nom : mon-premier-job
3. Sélectionnez "Freestyle project"
4. Dans "Build", ajoutez "Exécuter un script shell"
5. Entrez le script :

#!/bin/bash
echo "Hello from Jenkins!"
date
whoami
pwd

6. Cliquez sur "Sauvegarder"
7. Cliquez sur "Lancer un build"
8. Consultez les logs dans "Console Output"

Job avec Git

Configuration pour récupérer le code depuis Git :

1. Dans "Source Code Management", sélectionnez "Git"
2. Entrez l'URL du dépôt : https://github.com/user/mon-projet.git
3. Ajoutez des credentials si le dépôt est privé
4. Spécifiez la branche : */main
5. Dans "Build Triggers", cochez "Poll SCM"
6. Schedule : H/5 * * * * (vérifie toutes les 5 minutes)
7. Script de build :

#!/bin/bash
npm install
npm test
npm run build

Pipelines Jenkins

Les Pipelines permettent de définir l'intégralité du processus CI/CD sous forme de code. C'est la méthode recommandée pour les projets modernes.

Créer un Pipeline

1. Nouveau Item → "Pipeline"
2. Dans "Pipeline", sélectionnez "Pipeline script"
3. Entrez le code Groovy :

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://github.com/user/mon-projet.git'
            }
        }

        stage('Build') {
            steps {
                sh 'npm install'
                sh 'npm run build'
            }
        }

        stage('Test') {
            steps {
                sh 'npm test'
            }
        }

        stage('Deploy') {
            steps {
                echo 'Déploiement en production...'
                sh './deploy.sh'
            }
        }
    }

    post {
        success {
            echo 'Pipeline exécuté avec succès!'
        }
        failure {
            echo 'Pipeline échoué!'
        }
    }
}

Syntaxe déclarative vs scripte

Jenkins supporte deux syntaxes de pipeline :

• Déclarative (recommandée) : Plus simple, structurée, avec validation
• Scripte : Plus flexible, basée sur Groovy pur

Jenkinsfile et Pipeline as Code

Au lieu de définir le pipeline dans l'interface Jenkins, créez un fichier Jenkinsfile dans votre dépôt Git.

Avantages

• Pipeline versionné avec le code source
• Code review du pipeline via Pull Requests
• Réutilisable et partageable entre projets
• Historique complet des modifications

Exemple de Jenkinsfile complet

// Jenkinsfile
pipeline {
    agent {
        docker {
            image 'node:18-alpine'
        }
    }

    environment {
        NODE_ENV = 'production'
        API_URL = credentials('api-url')
    }

    options {
        timeout(time: 30, unit: 'MINUTES')
        timestamps()
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Install Dependencies') {
            steps {
                sh 'npm ci'
            }
        }

        stage('Lint') {
            steps {
                sh 'npm run lint'
            }
        }

        stage('Test') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        sh 'npm run test:unit'
                    }
                }
                stage('Integration Tests') {
                    steps {
                        sh 'npm run test:integration'
                    }
                }
            }
        }

        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }

        stage('Docker Build') {
            steps {
                script {
                    docker.build("mon-app:${env.BUILD_NUMBER}")
                }
            }
        }

        stage('Deploy to Staging') {
            when {
                branch 'develop'
            }
            steps {
                sh 'kubectl apply -f k8s/staging/'
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                input message: 'Déployer en production?', ok: 'Déployer'
                sh 'kubectl apply -f k8s/production/'
            }
        }
    }

    post {
        always {
            junit 'test-results/**/*.xml'
            archiveArtifacts artifacts: 'dist/**/*', fingerprint: true
        }
        success {
            slackSend color: 'good', message: "Build réussi: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
        failure {
            slackSend color: 'danger', message: "Build échoué: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
    }
}

Configuration du job pour utiliser le Jenkinsfile

1. Nouveau Item → "Pipeline"
2. Dans "Pipeline", sélectionnez "Pipeline script from SCM"
3. SCM : "Git"
4. Repository URL : votre dépôt Git
5. Script Path : Jenkinsfile (par défaut)

Plugins essentiels

Jenkins dispose de plus de 1800 plugins. Voici les incontournables :

Source Control

• Git Plugin : Intégration Git (inclus par défaut)
• GitHub Plugin : Intégration GitHub avec webhooks
• GitLab Plugin : Intégration GitLab
• Bitbucket Plugin : Intégration Bitbucket

Build & Test

• NodeJS Plugin : Gestion des versions Node.js
• Maven Integration Plugin : Support Maven pour Java
• Gradle Plugin : Support Gradle
• Docker Pipeline Plugin : Utiliser Docker dans les pipelines
• JUnit Plugin : Afficher les résultats de tests

Déploiement

• SSH Agent Plugin : Connexion SSH pour déploiement
• Publish Over SSH : Transfert de fichiers via SSH
• Kubernetes CLI Plugin : Déploiement Kubernetes
• AWS Steps Plugin : Intégration AWS

Notifications

• Slack Notification Plugin : Alertes Slack
• Email Extension Plugin : Emails personnalisés
• Discord Notifier : Notifications Discord

Qualité & Sécurité

• SonarQube Scanner : Analyse de code
• Warnings Next Generation : Analyse des warnings
• OWASP Dependency-Check : Scan de vulnérabilités

Installation de plugins

# Via l'interface : Manage Jenkins → Manage Plugins → Available
# Ou via CLI :
java -jar jenkins-cli.jar -s http://localhost:8080/ install-plugin docker-workflow

Intégration Git et webhooks

Configuration GitHub Webhook

1. Dans votre dépôt GitHub : Settings → Webhooks → Add webhook
2. Payload URL : http://votre-jenkins-url/github-webhook/
3. Content type : application/json
4. Événements : "Just the push event" ou personnalisez
5. Active : ✅

Configuration Jenkins

Dans votre job Jenkins :

1. Build Triggers → Cochez "GitHub hook trigger for GITScm polling"
2. Installez le plugin GitHub Plugin si ce n'est pas fait

Multibranch Pipeline

Le Multibranch Pipeline crée automatiquement un pipeline pour chaque branche du dépôt.

1. Nouveau Item → "Multibranch Pipeline"
2. Branch Sources → "Git" ou "GitHub"
3. Repository URL : votre dépôt
4. Behaviors : Discover branches, Discover pull requests
5. Build Configuration → "by Jenkinsfile"

Jenkins détectera automatiquement toutes les branches contenant un Jenkinsfile et créera un pipeline pour chacune.

Bonnes pratiques

• Pipeline as Code : Toujours utiliser Jenkinsfile dans le dépôt Git
• Agents dédiés : Utilisez des agents Docker ou Kubernetes pour l'isolation
• Shared Libraries : Centralisez le code réutilisable entre pipelines
• Credentials sécurisés : Stockez les secrets dans Jenkins Credentials
• Build rapides : Optimisez les builds avec cache et parallélisation
• Nettoyage régulier : Configurez buildDiscarder pour limiter l'historique
• Monitoring : Activez les métriques Prometheus
• Backup : Sauvegardez régulièrement $JENKINS_HOME
• Version Jenkins : Utilisez la version LTS pour la stabilité
• Sécurité : Activez CSRF protection et Matrix-based security

Exemple de Shared Library

// vars/buildNodeApp.groovy
def call(Map config) {
    pipeline {
        agent any
        stages {
            stage('Build') {
                steps {
                    sh "npm install"
                    sh "npm run build"
                }
            }
            stage('Test') {
                steps {
                    sh "npm test"
                }
            }
        }
    }
}

// Jenkinsfile
@Library('my-shared-library') _
buildNodeApp(
    nodeVersion: '18'
)

Conclusion

Jenkins reste l'outil CI/CD le plus populaire et le plus flexible grâce à son écosystème de plugins. Sa courbe d'apprentissage est compensée par sa puissance et sa capacité à s'adapter à n'importe quel workflow.

Explorez les pipelines CI/CD pour approfondir les concepts d'automatisation et de déploiement continu.