Un pipeline GitLab CI propre pour une application Java et Maven

Par Hamza Mechtaly · · 3 min de lecture

Cache Maven, étapes parallèles, rapports de tests, SonarQube, publication dans Nexus et règles d’exécution : un .gitlab-ci.yml commenté pour une application Java.

Pipeline GitLab CI pour Java et Maven

Voici le squelette de pipeline GitLab CI que je réutilise le plus souvent pour une application Java construite avec Maven. Il n’a rien d’extraordinaire, et c’est voulu : il est rapide, lisible, et il applique le principe « on construit une fois, on publie un artefact versionné ».

Le fichier complet

stages: [build, test, quality, publish]

variables:
  MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository"
  MAVEN_CLI: "--batch-mode --errors --no-transfer-progress"

default:
  image: maven:3.9-eclipse-temurin-21
  cache:
    key:
      files: [pom.xml]
    paths: [.m2/repository]

build:
  stage: build
  script:
    - mvn $MAVEN_CLI -DskipTests package
  artifacts:
    paths: [target/*.jar]
    expire_in: 1 day

tests-unitaires:
  stage: test
  script:
    - mvn $MAVEN_CLI test
  artifacts:
    when: always
    reports:
      junit: target/surefire-reports/TEST-*.xml

tests-integration:
  stage: test
  services: [postgres:16]
  variables:
    POSTGRES_DB: app
    POSTGRES_PASSWORD: test
  script:
    - mvn $MAVEN_CLI verify -Dtest=Aucun -Dsurefire.failIfNoSpecifiedTests=false
  artifacts:
    when: always
    reports:
      junit: target/failsafe-reports/TEST-*.xml

sonarqube:
  stage: quality
  script:
    - mvn $MAVEN_CLI verify sonar:sonar -Dsonar.qualitygate.wait=true
  allow_failure: false
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

publier:
  stage: publish
  script:
    - mvn $MAVEN_CLI deploy -DskipTests -Drevision=$APP_VERSION
  rules:
    - if: $CI_COMMIT_TAG
      variables:
        APP_VERSION: $CI_COMMIT_TAG

Les choix, un par un

Le cache Maven. Sans lui, chaque job retélécharge des centaines de dépendances. La clé basée sur pom.xml invalide le cache seulement quand les dépendances changent. Le dossier doit être dans le projet ($CI_PROJECT_DIR), sinon GitLab ne peut pas le mettre en cache.

--batch-mode --no-transfer-progress. Des journaux lisibles, sans les milliers de lignes de téléchargement. On retrouve les erreurs en dix secondes au lieu de deux minutes de défilement.

Les tests unitaires et d’intégration en parallèle. Ils sont dans le même stage, donc ils tournent en même temps. Dans le job d’intégration, -Dtest=Aucun avec surefire.failIfNoSpecifiedTests=false saute les tests unitaires déjà joués à côté, et Failsafe ne lance que les tests d’intégration. Le service postgres donne une vraie base aux tests d’intégration ; Testcontainers est une autre option si vos runners ont accès à Docker.

Les rapports JUnit. Avec reports: junit, GitLab affiche les tests en échec directement dans la merge request. Le when: always les publie même quand le job échoue, ce qui est justement le moment où on en a besoin.

La porte qualité SonarQube. sonar.qualitygate.wait=true fait échouer le pipeline si le code ne respecte pas les seuils de l’équipe (couverture, nouveaux bugs, vulnérabilités). C’est plus efficace qu’un tableau de bord que personne ne regarde.

La publication uniquement sur un tag. Un tag Git, c’est une version : le job publier envoie l’artefact dans Nexus avec ce numéro. La propriété revision (variables CI-friendly de Maven) évite de modifier le pom.xml à chaque version.

Ce que j’ajoute ensuite

  • un scan des dépendances (OWASP Dependency-Check, ou l’analyse intégrée à GitLab) ;
  • la construction de l’image de conteneur, taguée avec la même version que le JAR ;
  • un job de déploiement manuel (when: manual) par environnement, qui ne fait que déployer l’artefact déjà publié.

Les erreurs que je croise souvent

  • mvn clean install dans chaque job : on reconstruit tout plusieurs fois, et on remplit le dépôt local du runner pour rien.
  • Des secrets écrits dans le .gitlab-ci.yml : ils vont dans les variables CI/CD protégées et masquées.
  • Un seul énorme job qui fait tout : impossible de savoir ce qui a échoué sans lire mille lignes.

Ce pipeline tient en une soixantaine de lignes, donne un verdict en quelques minutes et produit un artefact traçable. C’est une bonne base, qu’on enrichit ensuite selon les besoins du projet.

À lire aussi