Déploiement continu d'applications Spring Boot et Angular avec Docker et GitLab CI/CD

Le développement d'applications modernes, en particulier celles exploitant des architectures robustes comme Spring Boot pour le backend et Angular pour le frontend, exige une agilité et une fiabilité accrues dans le processus de livraison. Pour répondre à ces exigences, le déploiement continu (CD) s'impose comme une pratique essentielle. Cet article explore comment Docker, en tant qu'outil de conteneurisation, et GitLab CI/CD, en tant que plateforme d'automatisation, peuvent être orchestrés pour mettre en œuvre un pipeline de déploiement continu efficace pour des applications Spring Boot et Angular.

La mise en place d'un tel pipeline transforme le cycle de vie du développement logiciel, permettant des livraisons plus fréquentes, plus rapides et avec un risque réduit. En automatisant chaque étape, de la construction à la mise en production, les équipes de développement peuvent se concentrer sur l'innovation, tandis que la cohérence de l'environnement est garantie. Laty Gueye Samba, développeur Full Stack à Dakar, expert en Java Spring Boot et Angular, souligne l'importance de ces pratiques pour garantir la robustesse et l'évolutivité des solutions logicielles.

Dockerisation des applications Spring Boot et Angular

Docker est la pierre angulaire de ce processus, offrant un moyen standardisé d'empaqueter les applications et leurs dépendances dans des conteneurs isolés. Cette approche garantit que l'application s'exécute de manière identique, quel que soit l'environnement.

Dockerfile pour une application Spring Boot

Pour une application Spring Boot, un Dockerfile utilise souvent une approche de construction multi-étapes. Cela permet de réduire la taille de l'image finale en séparant l'environnement de compilation de l'environnement d'exécution.

# Étape de compilation
FROM maven:3.8.5-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

# Étape d'exécution
FROM openjdk:17-jre-slim
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Ce Dockerfile compile le projet Spring Boot avec Maven dans une première étape, puis copie uniquement le fichier JAR exécutable vers une image JRE légère pour l'exécution, optimisant ainsi la taille et la sécurité.

Dockerfile pour une application Angular

De même, une application Angular bénéficie d'une approche multi-étapes pour construire les fichiers statiques, puis les servir via un serveur web léger comme Nginx.

# Étape de compilation
FROM node:18-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
RUN npm run build -- --configuration=production

# Étape de service avec Nginx
FROM nginx:alpine
COPY --from=build /app/dist/votre-projet-angular /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Ici, les dépendances Angular sont installées et l'application est compilée dans une première étape. Les artefacts de build sont ensuite copiés vers une image Nginx, qui servira l'application frontend.

Mise en place de GitLab CI/CD

GitLab CI/CD est un outil puissant intégré à GitLab qui permet de définir des pipelines d'intégration et de déploiement continus directement dans le dépôt de code via un fichier .gitlab-ci.yml.

Les fondamentaux du .gitlab-ci.yml

Le fichier .gitlab-ci.yml décrit les étapes (stages) et les tâches (jobs) du pipeline. Chaque tâche s'exécute dans un conteneur Docker distinct, garantissant l'isolation et la reproductibilité.

stages:
  - build_backend
  - test_backend
  - build_frontend
  - test_frontend
  - deploy_docker_images
  - deploy_to_server

variables:
  SPRING_BOOT_APP_NAME: my-spring-boot-app
  ANGULAR_APP_NAME: my-angular-app
  DOCKER_REGISTRY_URL: $CI_REGISTRY

Les stages définissent l'ordre d'exécution global. Les variables peuvent être utilisées pour paramétrer le pipeline. Les secrets (mots de passe, clés SSH) doivent être gérés via les variables CI/CD sécurisées de GitLab.

Conception du Pipeline de Déploiement Continu

Un pipeline de déploiement continu typique pour des applications Spring Boot et Angular inclura des étapes de construction, de test et de déploiement.

Stage Build & Test (Backend Spring Boot)

Cette étape est dédiée à la compilation du backend, l'exécution des tests unitaires et l'empaquetage de l'application dans une image Docker.

build_backend_image:
  stage: build_backend
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:$CI_COMMIT_SHORT_SHA -t $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:latest ./backend
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $DOCKER_REGISTRY_URL
    - docker push $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:$CI_COMMIT_SHORT_SHA
    - docker push $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:latest
  only:
    - main

test_backend:
  stage: test_backend
  image: maven:3.8.5-openjdk-17
  script:
    - cd backend
    - mvn test
  artifacts:
    when: always
    reports:
      junit: backend/target/surefire-reports/*.xml
  only:
    - main

Le job build_backend_image construit l'image Docker du backend et la pousse vers le registre Docker de GitLab. Le job test_backend exécute les tests Maven.

Stage Build & Test (Frontend Angular)

Similaire au backend, cette étape compile l'application Angular, exécute les tests et crée une image Docker.

build_frontend_image:
  stage: build_frontend
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:$CI_COMMIT_SHORT_SHA -t $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:latest ./frontend
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $DOCKER_REGISTRY_URL
    - docker push $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:$CI_COMMIT_SHORT_SHA
    - docker push $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:latest
  only:
    - main

test_frontend:
  stage: test_frontend
  image: node:18-alpine
  script:
    - cd frontend
    - npm install
    - npm test -- --no-watch --no-progress --browsers=ChromeHeadlessCI
  artifacts:
    when: always
    reports:
      junit: frontend/junit.xml
  only:
    - main

Les jobs build_frontend_image et test_frontend gèrent la conteneurisation et les tests de l'application Angular.

Stage Deploy (Production)

Une fois les images construites et testées, elles sont déployées sur le serveur cible. Cela peut impliquer l'utilisation de SSH pour se connecter au serveur, s'authentifier au registre Docker, puis démarrer les nouveaux conteneurs.

deploy_to_production:
  stage: deploy_to_server
  image: alpine/git
  before_script:
    - apk add --no-cache openssh-client
    - eval "$(ssh-agent -s)"
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add - > /dev/null
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan $PRODUCTION_SERVER_IP >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
  script:
    - ssh $PRODUCTION_SERVER_USER@$PRODUCTION_SERVER_IP "
        docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $DOCKER_REGISTRY_URL &&
        docker pull $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:latest &&
        docker pull $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:latest &&
        docker stop $SPRING_BOOT_APP_NAME $ANGULAR_APP_NAME || true &&
        docker rm $SPRING_BOOT_APP_NAME $ANGULAR_APP_NAME || true &&
        docker run -d --name $SPRING_BOOT_APP_NAME -p 8080:8080 $DOCKER_REGISTRY_URL/$SPRING_BOOT_APP_NAME:latest &&
        docker run -d --name $ANGULAR_APP_NAME -p 80:80 $DOCKER_REGISTRY_URL/$ANGULAR_APP_NAME:latest
      "
  environment:
    name: production
    url: http://$PRODUCTION_SERVER_IP
  when: manual # Ou on_success pour un déploiement entièrement automatique
  only:
    - main

Le script de déploiement utilise SSH pour exécuter des commandes Docker sur le serveur de production, tirant les nouvelles images, arrêtant les anciens conteneurs et démarrant les nouveaux. L'utilisation ds variables d'environnement (SSH_PRIVATE_KEY, PRODUCTION_SERVER_USER, etc.) est cruciale pour la sécurité.

Conclusion

Le déploiement continu d'applications Spring Boot et Angular avec Docker et GitLab CI/CD offre une solution robuste et efficace pour moderniser le processus de livraison logicielle. En conteneurisant les applications et en automatisant le pipeline de construction, de test et de déploiement, les équipes de développement peuvent améliorer significativement leur productivité, la qualité du code et la rapidité des mises à jour.

Cette approche permet non seulement de réduire les erreurs manuelles, mais aussi de garantir la cohérence des environnements, de la machine du développeur à la production. Laty Gueye Samba, Développeur Full Stack à Dakar, expert Java Spring Boot et Angular, encourage l'adoption de ces pratiques pour bâtir des systèmes résilients et performants.

Ressources Officielles

• Documentation Docker
• Documentation GitLab CI/CD
• Site officiel Spring Boot
• Site officiel Angular