Mise en place d'une CI/CD complète avec GitLab CI et Docker pour des applications Spring Boot/Angular

Dans l'écosystème du développement logiciel moderne, l'intégration continue et le déploiement continu (CI/CD) sont devenus des piliers incontournables pour livrer des applications de haute qualité à un rythme soutenu. Ces pratiques permettent d'automatiser les étapes de construction, de test et de déploiement, réduisant ainsi les erreurs humaines et accélérant le cycle de vie du développement.

Pour un développeur Full Stack, expert Java Spring Boot et Angular tel que Laty Gueye Samba, basé à Dakar, la maîtrise des outils et des méthodes CI/CD est essentielle pour créer des solutions robustes et évolutives. Cet article explore la mise en place d'une chaîne CI/CD complète en utilisant GitLab CI comme orchestrateur et Docker pour la conteneurisation, spécifiquement pour des applications développées avec Spring Boot (backend) et Angular (frontend).

L'objectif est de guider le lecteur à travers les étapes clés pour automatiser la construction, les tests et la création d'images Docker prêtes pour le déploiement, assurant une livraison continue et efficace des applications.

Fondamentaux de la CI/CD avec GitLab CI et Docker

La CI/CD représente un ensemble de pratiques visant à intégrer les changements de code fréquemment et à les déployer automatiquement. GitLab CI, intégré nativement à GitLab, offre une plateforme puissante pour définir des pipelines de CI/CD via un fichier .gitlab-ci.yml. Chaque modification pushée vers un dépôt GitLab peut déclencher un pipeline, exécutant une série d'étapes (jobs) configurées.

Docker, quant à lui, est une technologie de conteneurisation qui permet d'empaqueter une application et toutes ses dépendances dans un environnement isolé appelé "conteneur". Ces conteneurs sont portables et garantissent que l'application fonctionne de manière cohérente, quel que soit l'environnement d'exécution. L'utilisation de Docker dans une chaîne CI/CD est particulièrement avantageuse pour :

• L'isolation de l'environnement : Chaque étape du pipeline peut s'exécuter dans un conteneur dédié, garantissant que les dépendances et l'environnement sont cohérents.
• La portabilité : Les images Docker construites en CI peuvent être déployées sur n'importe quel environnement supportant Docker (serveur, cloud, Kubernetes) sans modification.
• La reproductibilité : Les builds sont identiques à chaque exécution, éliminant les problèmes de "ça marche sur ma machine".

Pour des applications Spring Boot/Angular, l'approche consiste à construire des images Docker distinctes pour le backend et le frontend, puis à les assembler ou les déployer de manière coordonnée.

Mise en place pour une application Spring Boot (Backend)

La partie backend, généralement développée avec Spring Boot, nécessite une compilation du code Java en un fichier JAR exécutable, puis la création d'une image Docker contenant ce JAR et un environnement d'exécution Java. Voici un exemple de .gitlab-ci.yml et de Dockerfile pour une application Spring Boot.

.gitlab-ci.yml pour Spring Boot

stages:
  - build
  - test
  - package

variables:
  MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"
  DOCKER_IMAGE_NAME: latysamba/springboot-app
  DOCKER_IMAGE_TAG: $CI_COMMIT_SHORT_SHA

cache:
  paths:
    - .m2/repository

build_job:
  stage: build
  image: maven:3.8.7-openjdk-17
  script:
    - echo "Building Spring Boot application..."
    - mvn clean package -DskipTests
  artifacts:
    paths:
      - target/*.jar
    expire_in: 1 day

test_job:
  stage: test
  image: maven:3.8.7-openjdk-17
  script:
    - echo "Running unit tests..."
    - mvn test

package_docker_job:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Building Docker image for Spring Boot application..."
    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
    - docker build -t $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG .
    - docker push $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
  only:
    - master

Dockerfile pour Spring Boot

# Stage 1: Build the application
FROM maven:3.8.7-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# Stage 2: Create the final image
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Ce pipeline définit trois étapes : build pour compiler le JAR, test pour exécuter les tests unitaires, et package pour construire et pousser l'image Docker vers un registre (ici, le registre intégré de GitLab ou Docker Hub).

Mise en place pour une application Angular (Frontend)

La partie frontend, développée avec Angular, implique la compilation du code TypeScript en JavaScript, le bundling des assets, et la création d'une image Docker qui servira ces fichiers statiques via un serveur web léger comme Nginx. Un Dockerfile multi-stage est idéal pour minimiser la taille de l'image finale.

.gitlab-ci.yml pour Angular

stages:
  - install_dependencies
  - build
  - test
  - package

variables:
  DOCKER_IMAGE_NAME: latysamba/angular-app
  DOCKER_IMAGE_TAG: $CI_COMMIT_SHORT_SHA

cache:
  paths:
    - node_modules/

install_deps_job:
  stage: install_dependencies
  image: node:18-alpine
  script:
    - echo "Installing Angular dependencies..."
    - npm ci --cache .npm --prefer-offline
  artifacts:
    paths:
      - node_modules/
    expire_in: 1 day

build_job:
  stage: build
  image: node:18-alpine
  script:
    - echo "Building Angular application for production..."
    - npm run build -- --configuration=production
  artifacts:
    paths:
      - dist/
    expire_in: 1 day

test_job:
  stage: test
  image: node:18-alpine
  script:
    - echo "Running Angular unit tests..."
    - npm test -- --no-watch --browsers=ChromeHeadless

package_docker_job:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Building Docker image for Angular application..."
    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
    - docker build -t $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG .
    - docker push $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
  only:
    - master

Dockerfile pour Angular

# Stage 1: Build the Angular application
FROM node:18-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build -- --configuration=production

# Stage 2: Serve the application with Nginx
FROM nginx:alpine
COPY --from=build /app/dist/ /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Ce pipeline Angular inclut des étapes pour installer les dépendances (avec cache), construire l'application pour la production, exécuter les tests unitaires et enfin, créer une image Docker avec Nginx pour servir l'application compilée.

Conclusion

La mise en place d'une chaîne CI/CD complète avec GitLab CI et Docker pour des applications Spring Boot et Angular est une étape fondamentale vers une livraison logicielle agile et fiable. Les exemples de configurations de pipelines présentés permettent d'automatiser des processus fastidieux, de garantir la reproductibilité des environnements et de libérer les développeurs pour se concentrer sur l'innovation. Laty Gueye Samba, Développeur Full Stack Java Spring Boot Angular à Dakar, encourage l'adoption de ces pratiques pour tout projet moderne, garantissant ainsi une efficacité et une qualité accrues.

Pour approfondir vos connaissances, il est recommandé de consulter les documentations officielles :

• Documentation officielle de GitLab CI/CD
• Documentation officielle de Docker
• Documentation officielle de Spring Boot
• Documentation officielle d'Angular