Introduction à la CI/CD

La CI/CD (Intégration Continue / Déploiement Continu) est aujourd’hui le socle de toute organisation qui veut livrer plus vite, plus souvent et avec moins de bugs. C’est un ensemble de pratiques et d’outils qui permettent de transformer chaque commit en un artefact testé, validé, et parfois directement déployé.

CI (Continuous Integration)

• Chaque commit déclenche automatiquement un build et une batterie de tests.
• On détecte rapidement les régressions.
• On partage un tronc commun toujours valide.

CD (Continuous Delivery / Deployment)

• Les builds validés sont automatiquement mis en staging ou en production.
• Réduit le time-to-market.
• Favorise les déploiements fréquents et sécurisés.

💡 L’idée fondatrice : "Si ça marche en local, ça doit marcher partout – et sans clic manuel".

Panorama des outils CI/CD

Il existe des dizaines d’outils CI/CD sur le marché, mais dans cette formation nous allons nous concentrer sur les 5 plus utilisés et incontournables :

1. GitHub Actions – natif GitHub, parfait pour les projets open source et cloud natifs.
2. GitLab CI – intégré directement dans GitLab, riche et complet.
3. Jenkins – le vétéran open source, extrêmement flexible et extensible.
4. Azure DevOps – plébiscité dans les environnements Microsoft/Enterprise.
5. CircleCI – outil cloud-first très apprécié pour sa simplicité et ses optimisations.

GitHub Actions

GitHub Actions est le moteur CI/CD intégré directement dans GitHub. Il permet de déclencher des workflows en réponse à des événements (push, pull request, release, cron…).

Exemple minimal

# .github/workflows/ci.yml
name: Java CI with Maven

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
      - name: Build with Maven
        run: mvn clean verify

Ce pipeline compile le projet, exécute les tests et remonte les résultats dans l’onglet "Actions".

GitLab CI

GitLab CI est totalement intégré à GitLab. La configuration se fait via un fichier .gitlab-ci.yml à la racine du projet.

Exemple minimal

# .gitlab-ci.yml
stages:
  - build
  - test

build-job:
  stage: build
  image: maven:3.9.4-eclipse-temurin-17
  script:
    - mvn clean compile

test-job:
  stage: test
  image: maven:3.9.4-eclipse-temurin-17
  script:
    - mvn test

Chaque stage s’exécute dans un conteneur. Ici, le build précède les tests.

Jenkins

Jenkins est le vétéran du CI/CD. Open source, il repose sur des pipelines déclaratifs écrits dans un Jenkinsfile.

Exemple minimal

// Jenkinsfile
pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'mvn clean compile'
      }
    }
    stage('Test') {
      steps {
        sh 'mvn test'
      }
    }
  }
}

Jenkins est extrêmement extensible grâce à ses plugins, mais nécessite une maintenance continue (serveur, mises à jour, sécurité).

Azure DevOps

Azure DevOps propose un moteur de pipelines YAML très riche, orienté Enterprise et multi-langages.

Exemple minimal

# azure-pipelines.yml
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
  - task: Maven@3
    inputs:
      mavenPomFile: 'pom.xml'
      goals: 'clean verify'

L’avantage d’Azure : intégration native avec Azure Repos, Boards, Artifacts et les environnements de déploiement.

CircleCI

CircleCI est un outil CI/CD cloud-first, apprécié pour sa simplicité et son exécution rapide. La configuration se fait dans .circleci/config.yml.

Exemple minimal

# .circleci/config.yml
version: 2.1
jobs:
  build:
    docker:
      - image: cimg/openjdk:17.0
    steps:
      - checkout
      - run: mvn clean verify

workflows:
  version: 2
  ci-workflow:
    jobs:
      - build

CircleCI est particulièrement adapté aux projets SaaS et start-ups, avec des pipelines très rapides.

Exemple complet – Selenium + Java

Pour illustrer l’intégration CI/CD, nous allons utiliser un test automatisé simple écrit en Java + Selenium WebDriver, exécuté avec Maven.

1. Code du test Selenium

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.junit.*;

public class GoogleSearchTest {
    private static WebDriver driver;

    @BeforeClass
    public static void setup() {
        driver = new ChromeDriver();
    }

    @Test
    public void testSearch() {
        driver.get("https://www.google.com");
        WebElement searchBox = driver.findElement(By.name("q"));
        searchBox.sendKeys("CI/CD Selenium");
        searchBox.submit();
        Assert.assertTrue(driver.getTitle().contains("CI/CD"));
    }

    @AfterClass
    public static void tearDown() {
        if (driver != null) driver.quit();
    }
}

Ce test ouvre Google, recherche « CI/CD Selenium » et vérifie que le titre contient bien la requête.

2. Dépendances Maven

<dependencies>
  <dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>4.21.0</version>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

3. Intégration dans GitHub Actions

# .github/workflows/selenium.yml
name: Selenium CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
      - name: Setup Chrome
        uses: browser-actions/setup-chrome@v1
      - name: Run tests
        run: mvn test

Ici, GitHub Actions installe Chrome, Java et exécute directement le test Selenium dans un job CI.

Bonnes pratiques CI/CD

Construire un pipeline CI/CD efficace ne se résume pas à « lancer des tests ». Voici les principes clés à respecter.

1. Pipelines rapides

• Évitez les étapes inutiles (build inutile si pas de modifs côté code source).
• Cachez vos dépendances Maven/NPM pour accélérer les builds.
• Exécutez les tests en parallèle dès que possible.

2. Pipelines reproductibles

• Utilisez des images Docker figées avec des versions précises.
• Bloquez les dépendances (lockfiles, pom.xml, package-lock.json).

3. Intégration continue stricte

• Chaque commit doit déclencher un pipeline complet.
• N’acceptez pas de merge si les tests échouent.
• Faites tourner les tests critiques en pre-merge.

4. Visibilité et feedback

• Publiez des rapports HTML (Surefire, Allure) en artefacts du pipeline.
• Ajoutez des captures d’écran et des logs pour les tests UI.
• Envoyez les résultats sur Slack/Teams pour l’équipe.

5. Sécurité

• Stockez vos secrets (tokens, credentials) dans le gestionnaire natif (GitHub Secrets, GitLab Variables…).
• Ne les mettez jamais en clair dans le YAML ou le Jenkinsfile.
• Scannez vos dépendances (Snyk, Dependabot, Trivy).

6. Maintenance

• Gardez vos runners/agents à jour (OS, versions de Java, ChromeDriver).
• Sur Jenkins : surveillez la dette technique (plugins obsolètes, jobs orphelins).

Ressources complémentaires

Pour aller plus loin dans la compréhension et la pratique du CI/CD, voici une sélection de ressources fiables et régulièrement mises à jour :

• Documentation GitHub Actions
• Documentation GitLab CI/CD
• Documentation Jenkins
• Azure DevOps Pipelines
• Documentation CircleCI
• Article de référence de Martin Fowler sur la CI
• Site Continuous Delivery de Jez Humble
• Les 12 facteurs d’une application moderne