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

Dans l'écosystème du développement logiciel moderne, la vitesse et la fiabilité du déploiement sont des facteurs critiques de succès. Pour les applications Full Stack, combinant un backend robuste comme Spring Boot et un frontend dynamique tel qu'Angular, la complexité du processus de livraison peut rapidement devenir un goulot d'étranglement. C'est ici que le déploiement continu (CD) entre en jeu, transformant la manière dont les applications sont développées, testées et mises en production.

Le déploiement continu, rendu possible par des outils puissants comme GitLab CI/CD et Docker, permet d'automatiser l'intégralité du cycle de vie du déploiement. Cette approche garantit que chaque modification de code qui passe les tests est automatiquement déployée dans un environnement de production ou de staging, réduisant les erreurs manuelles et accélérant la mise sur le marché des fonctionnalités. Pour un expert Java Spring Boot et Angular comme Laty Gueye Samba, Développeur Full Stack à Dakar, la maîtrise de ces outils est essentielle pour bâtir des solutions performantes et résilientes.

Cet article explore comment configurer un pipeline de déploiement continu robuste pour des applications Spring Boot et Angular, en tirant parti de la puissance de GitLab CI/CD pour l'orchestration et de Docker pour la conteneurisation, une compétence clé pour tout Développeur Full Stack DevOps.

GitLab CI/CD et Docker : Les Piliers du Déploiement Continu

Pour construire un pipeline de déploiement continu efficace pour des applications Full Stack, il est fondamental de comprendre le rôle de chaque composant. GitLab CI/CD agit comme le cerveau de l'automatisation, orchestrant les différentes étapes de construction, de test et de déploiement du code. Il permet de définir un pipeline déclaratif directement dans le dépôt de code, assurant une intégration transparente et une traçabilité complète.

Docker, quant à lui, est la technologie de conteneurisation de facto. Il permet d'empaqueter une application et toutes ses dépendances dans une unité isolée et portable appelée "conteneur". Cette isolation garantit que l'application s'exécute de manière cohérente, quel que soit l'environnement sous-jacent. Pour une architecture Full Stack, il est courant de conteneuriser le backend Spring Boot et le frontend Angular séparément, puis de les orchestrer ensemble. Laty Gueye Samba, Développeur Full Stack Dakar Sénégal, utilise régulièrement cette approche pour ses projets, que ce soit pour des applications de gestion hospitalière ou des systèmes ERP.

L'alliance de GitLab CI/CD et Docker offre un environnement de développement et de déploiement harmonisé, où chaque composant de l'application est traité comme une entité autonome, mais intégrée dans un flux de travail continu et automatisé.

Mise en œuvre du pipeline pour le Backend Spring Boot

Le backend Spring Boot, écrit en Java, nécessite une phase de compilation avant d'être conteneurisé. Un pipeline GitLab CI/CD pour Spring Boot inclura généralement les étapes suivantes : compilation du code, exécution des tests unitaires et d'intégration, et création de l'image Docker de l'application.

Voici un exemple de configuration .gitlab-ci.yml pour une application Spring Boot :

stages:
  - build
  - test
  - dockerize
  - deploy

variables:
  DOCKER_IMAGE_NAME_BACKEND: $CI_REGISTRY_IMAGE/backend
  DOCKER_TAG: $CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA

build_backend:
  stage: build
  image: maven:3.8.6-openjdk-17
  script:
    - echo "Compiling Spring Boot backend..."
    - mvn clean install -DskipTests
  artifacts:
    paths:
      - target/*.jar
    expire_in: 1 week
  only:
    - main
    - develop

test_backend:
  stage: test
  image: maven:3.8.6-openjdk-17
  script:
    - echo "Running backend tests..."
    - mvn test
  only:
    - main
    - develop

dockerize_backend:
  stage: dockerize
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - echo "Logging into Docker Registry..."
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - echo "Building Docker image for backend..."
    - docker build -t $DOCKER_IMAGE_NAME_BACKEND:$DOCKER_TAG .
    - docker push $DOCKER_IMAGE_NAME_BACKEND:$DOCKER_TAG
    - echo "Backend Docker image pushed: $DOCKER_IMAGE_NAME_BACKEND:$DOCKER_TAG"
  only:
    - main
    - develop

# Une étape de déploiement pourrait être ajoutée ici, par exemple vers Kubernetes ou un serveur Docker.

Le Dockerfile pour l'application Spring Boot serait simple, utilisant une image de base OpenJDK et copiant le JAR construit :

# Dockerfile pour le backend Spring Boot
FROM openjdk:17-jdk-slim
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
EXPOSE 8080

Pipeline CI/CD pour le Frontend Angular

L'application Angular, en tant que frontend, suit un processus similaire mais avec des outils spécifiques à JavaScript/TypeScript. Le pipeline se concentrera sur l'installation des dépendances, la compilation de l'application et la création d'une image Docker, souvent servie par un serveur web léger comme Nginx.

Exemple de configuration .gitlab-ci.yml pour une application Angular :

# ... (stages et variables existantes)

variables:
  DOCKER_IMAGE_NAME_FRONTEND: $CI_REGISTRY_IMAGE/frontend
  # ... (autres variables)

build_frontend:
  stage: build
  image: node:16
  script:
    - echo "Installing Angular dependencies..."
    - npm install
    - echo "Building Angular application..."
    - npm run build --prod
  artifacts:
    paths:
      - dist/
    expire_in: 1 week
  only:
    - main
    - develop

dockerize_frontend:
  stage: dockerize
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - echo "Logging into Docker Registry..."
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - echo "Building Docker image for frontend..."
    - docker build -t $DOCKER_IMAGE_NAME_FRONTEND:$DOCKER_TAG -f Dockerfile.frontend .
    - docker push $DOCKER_IMAGE_NAME_FRONTEND:$DOCKER_TAG
    - echo "Frontend Docker image pushed: $DOCKER_IMAGE_NAME_FRONTEND:$DOCKER_TAG"
  needs: ["build_frontend"]
  only:
    - main
    - develop

# ... (étapes de déploiement)

Le Dockerfile.frontend (nommé ainsi pour le distinguer du Dockerfile backend) utilisera Nginx pour servir les fichiers statiques de l'application Angular construite :

# Dockerfile.frontend pour l'application Angular
# Étape 1: Construire l'application Angular
FROM node:16 AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
RUN npm run build --prod

# Étape 2: Servir l'application avec Nginx
FROM nginx:alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/dist/ /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Il serait nécessaire de créer un fichier nginx.conf pour configurer Nginx afin de servir correctement l'application Angular, en gérant notamment le routage côté client (histoire de fallback).

Orchestration et Déploiement : L'Application Full Stack

Une fois les images Docker du backend et du frontend construites et poussées vers un registre (comme le GitLab Container Registry), l'étape finale est le déploiement. Pour des environnements plus simples, Docker Compose peut être utilisé pour définir et exécuter l'application Full Stack multi-conteneurs. Pour des déploiements à l'échelle, des orchestrateurs comme Kubernetes sont privilégiés.

Un fichier docker-compose.yml simple pourrait ressembler à ceci :

version: '3.8'
services:
  backend:
    image: $CI_REGISTRY_IMAGE/backend:$DOCKER_TAG
    ports:
      - "8080:8080"
    environment:
      SPRING_PROFILES_ACTIVE: production
      # ... autres variables d'environnement
  frontend:
    image: $CI_REGISTRY_IMAGE/frontend:$DOCKER_TAG
    ports:
      - "80:80"
    depends_on:
      - backend

L'étape de déploiement dans le pipeline GitLab CI/CD consisterait alors à se connecter au serveur cible et à exécuter la commande docker-compose up -d, en veillant à ce que les variables d'environnement pour les images Docker soient correctement substituées.

Conclusion

Le déploiement continu d'applications Spring Boot et Angular avec GitLab CI/CD et Docker est une approche puissante pour optimiser le cycle de vie du développement logiciel. Il offre une automatisation complète, de la construction au déploiement, garantissant des livraisons rapides, fiables et reproductibles. Pour un Développeur Full Stack DevOps comme Laty Gueye Samba, l'intégration de ces technologies est une étape indispensable pour construire des architectures robustes et évolutives, essentielles dans le paysage technologique actuel à Dakar et au-delà.

En adoptant ces pratiques, les équipes de développement peuvent se concentrer davantage sur l'innovation et moins sur les tâches opérationnelles répétitives, accélérant ainsi la valeur délivrée aux utilisateurs finaux.

Pour approfondir vos connaissances, voici quelques ressources officielles :

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