Mettre en place un pipeline CI/CD automatisé avec GitLab pour des projets Spring Boot/Angular

Dans l'écosystème du développement logiciel moderne, la livraison continue et l'intégration continue (CI/CD) sont devenues des piliers essentiels pour garantir l'efficacité, la qualité et la rapidité des déploiements. L'automatisation des processus de build, de test et de déploiement permet aux équipes de se concentrer sur l'innovation, réduisant considérablement les erreurs manuelles et les délais de mise sur le marché.

GitLab, en tant que plateforme DevOps complète, offre un système CI/CD intégré qui simplifie l'orchestration de ces pipelines. Cet article explore comment mettre en place un pipeline CI/CD automatisé avec GitLab pour des applications Full Stack, combinant un backend robuste basé sur Spring Boot et un frontend dynamique avec Angular. La démarche présentée est particulièrement pertinente pour des experts comme Laty Gueye Samba, développeur Full Stack à Dakar, qui gère des applications métier complexes où la fiabilité et la rapidité de déploiement sont primordiales.

Les Fondamentaux du CI/CD avec GitLab

Le CI/CD GitLab repose sur un fichier de configuration, .gitlab-ci.yml, situé à la racine du dépôt. Ce fichier définit une série de jobs regroupés en stages (étapes). Chaque job exécute une tâche spécifique, comme la compilation du code, l'exécution des tests unitaires, la création d'une image Docker ou le déploiement. Les runners GitLab, des agents d'exécution, sont chargés d'exécuter ces jobs.

Un pipeline CI/CD typique pour une application Full Stack inclut généralement les étapes suivantes :

• Build : Compilation du code source (backend et frontend).
• Test : Exécution des tests unitaires et d'intégration pour chaque composant.
• Package : Création d'artefacts (JAR, WAR, images Docker, bundles JavaScript minifiés).
• Deploy : Déploiement des artefacts sur des environnements de staging ou de production.

L'intégration continue assure que chaque modification de code est immédiatement testée, tandis que la livraison continue automatise le déploiement vers un environnement après validation. Pour des experts Java Spring Boot Angular, cette automatisation est cruciale pour maintenir l'agilité dans le développement de solutions robustes.

Mettre en place la CI/CD pour un projet Spring Boot

Pour un projet Spring Boot, le pipeline CI/CD se concentre sur la compilation du code Java, l'exécution des tests Maven ou Gradle, et la création d'un fichier JAR ou d'une image Docker. Voici un exemple simplifié de .gitlab-ci.yml pour un backend Spring Boot, utilisant Maven :

image: maven:3.8.6-openjdk-17 # Utilise une image Docker Maven avec Java 17

variables:
  MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"

cache:
  paths:
    - .m2/repository

stages:
  - build
  - test
  - package

build_backend:
  stage: build
  script:
    - echo "Compiling Spring Boot backend..."
    - mvn compile
  artifacts:
    paths:
      - target/classes/
    expire_in: 1 day

test_backend:
  stage: test
  script:
    - echo "Running Spring Boot backend tests..."
    - mvn test
  dependencies:
    - build_backend

package_backend:
  stage: package
  script:
    - echo "Packaging Spring Boot backend into JAR..."
    - mvn package -DskipTests
  artifacts:
    paths:
      - target/*.jar
    expire_in: 30 days
  dependencies:
    - test_backend

Ce script définit trois étapes : build, test, et package. Le cache Maven est utilisé pour accélérer les builds en conservant les dépendances téléchargées. Après le packaging, le fichier JAR est disponible en tant qu'artefact, prêt pour un déploiement ultérieur (par exemple, sur un serveur via SSH, ou en tant qu'image Docker poussée vers un registre).

Intégrer la CI/CD pour une application Angular

L'application Angular nécessite un environnement Node.js. Le pipeline se concentrera sur l'installation des dépendances, l'exécution des tests (unitaires, e2e), le linting et la construction du bundle de production. Voici un exemple de .gitlab-ci.yml pour le frontend Angular :

image: node:16 # Utilise une image Docker Node.js

stages:
  - install_deps
  - lint_test
  - build
  - deploy

cache:
  paths:
    - node_modules/

install_angular_dependencies:
  stage: install_deps
  script:
    - echo "Installing Angular dependencies..."
    - npm ci

lint_and_test_angular:
  stage: lint_test
  script:
    - echo "Running Angular linting and tests..."
    - npm run lint
    - npm test -- --no-watch --browsers=ChromeHeadless # Exécute les tests en mode headless
  dependencies:
    - install_angular_dependencies

build_angular:
  stage: build
  script:
    - echo "Building Angular application for production..."
    - npm run build -- --configuration=production --base-href=/
  artifacts:
    paths:
      - dist/
    expire_in: 1 week
  dependencies:
    - lint_and_test_angular

deploy_angular_to_hosting:
  stage: deploy
  image: alpine/git # Image légère pour SSH/SCP
  before_script:
    - apk add openssh-client
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan $DEPLOY_SERVER_HOST >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
  script:
    - echo "Deploying Angular application to production server..."
    - scp -r dist/* $DEPLOY_USER@$DEPLOY_SERVER_HOST:/var/www/html/angular-app/
  only:
    - main # Déployer uniquement sur la branche main
  dependencies:
    - build_angular

Ce pipeline couvre l'installation des dépendances (`npm ci` pour une installation propre et reproductible), le linting, les tests unitaires et la construction du projet Angular en mode production. L'étape de déploiement utilise scp pour transférer les fichiers statiques du frontend vers un serveur web, protégé par des variables d'environnement GitLab pour les clés SSH et les informations de connexion, une pratique sécurisée et recommandée par les experts en CI/CD.

Conclusion

L'implémentation d'un pipeline CI/CD automatisé avec GitLab pour des projets Spring Boot et Angular transforme radicalement le processus de développement et de déploiement. Elle assure une qualité logicielle constante, une détection précoce des problèmes et une livraison rapide des nouvelles fonctionnalités. Pour un développeur Full Stack à Dakar, expert en Java Spring Boot et Angular comme Laty Gueye Samba, l'intégration de ces pratiques est essentielle pour construire des applications robustes et scalables, répondant aux exigences des environnements d'entreprise complexes au Sénégal et au-delà.

Pour approfondir ce sujet, il est recommandé de consulter la documentation officielle de GitLab CI/CD, Spring Boot et Angular :

• Documentation GitLab CI/CD
• Spring Boot Build Systems
• Déploiement Angular