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

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

Dans l'écosystème du développement logiciel moderne, la vitesse de livraison et la fiabilité sont primordiales. Les déploiements manuels sont souvent sources d'erreurs, lents et incompatibles avec les exigences d'un marché technologique dynamique. Cet article explore comment l'automatisation du déploiement, en combinant les puissances de GitLab CI/CD et de Docker, peut transformer la manière dont les applications Spring Boot (backend) et Angular (frontend) sont mises en production.

L'adoption de pratiques de Conteneurisation et d'Intégration/Déploiement Continu (CI/CD) est devenue une norme pour les équipes qui cherchent à optimiser leurs workflows. Pour un développeur Full Stack Java Spring Boot + Angular basé à Dakar, comme Laty Gueye Samba, l'intégration de ces outils est essentielle pour garantir l'efficacité et la robustesse des solutions logicielles, notamment dans des projets exigeants.

Ce guide technique détaillera les étapes pour conteneuriser vos applications Spring Boot et Angular, puis mettra en œuvre un pipeline GitLab CI/CD pour automatiser la construction, le test et le déploiement de ces conteneurs Docker.

1. Conteneurisation des applications avec Docker

Docker offre une solution pour empaqueter les applications et leurs dépendances dans des conteneurs isolés, garantissant une cohérence de l'environnement, de développement à la production. Cela élimine les problèmes de "ça marche sur ma machine".

1.1. Dockerisation de l'application Spring Boot

Pour une application Spring Boot, le processus implique généralement de construire un JAR exécutable, puis de le placer dans une image Docker basée sur un environnement d'exécution Java (JRE).

# Dockerfile.backend
# Utilisation d'une image de base Java pour l'exécution
FROM openjdk:17-jdk-slim AS build
# Définir le répertoire de travail
WORKDIR /app
# Copier le fichier pom.xml et les sources
COPY pom.xml .
COPY src ./src
# Construire l'application (peut prendre du temps)
RUN ./mvnw clean package -DskipTests
# Phase d'exécution légère
FROM openjdk:17-jre-slim
# Définir le port sur lequel l'application Spring Boot écoute
EXPOSE 8080
# Copier le JAR construit de la phase 'build'
COPY --from=build /app/target/*.jar app.jar
# Commande pour démarrer l'application
ENTRYPOINT ["java", "-jar", "app.jar"]

Ce Dockerfile utilise une approche multi-stage : une première étape pour construire l'application avec le JDK complet, et une seconde, plus légère, pour l'exécution avec le JRE.

1.2. Dockerisation de l'application Angular

La conteneurisation d'une application Angular suit un schéma similaire, avec une étape de construction des fichiers statiques et une étape de service via un serveur web léger comme Nginx.

# Dockerfile.frontend
# Première étape : construire l'application Angular
FROM node:18-alpine AS build
# Définir le répertoire de travail
WORKDIR /app
# Copier les fichiers de configuration et les sources
COPY package.json package-lock.json ./
RUN npm install
COPY . .
# Construire l'application Angular pour la production
# Assurez-vous que le chemin de sortie est 'dist/votre-projet-angular'
RUN npm run build -- --output-path=./dist --configuration=production

# Seconde étape : servir l'application avec Nginx
FROM nginx:alpine
# Copier la configuration Nginx personnalisée
COPY nginx.conf /etc/nginx/conf.d/default.conf
# Copier les fichiers de build Angular de la première étape
COPY --from=build /app/dist /usr/share/nginx/html
# Exposer le port par défaut de Nginx
EXPOSE 80
# Commande pour démarrer Nginx
CMD ["nginx", "-g", "daemon off;"]

Un fichier nginx.conf simple serait nécessaire à côté du Dockerfile pour configurer Nginx, par exemple pour la gestion des routes Angular (try_files).

2. Intégration Continue et Déploiement Continu avec GitLab CI/CD

GitLab CI/CD est un outil puissant intégré à GitLab qui permet d'automatiser les étapes de votre pipeline de développement. Le fichier .gitlab-ci.yml, placé à la racine de votre dépôt, définit les différentes étapes et tâches.

2.1. Structure d'un pipeline CI/CD pour Spring Boot et Angular

Un pipeline typique comprend des étapes pour la construction, le test et la création/poussée des images Docker vers un registre (comme le GitLab Container Registry ou Docker Hub).

# .gitlab-ci.yml
stages:
  - build
  - test
  - package
  - deploy

variables:
  DOCKER_IMAGE_BACKEND: $CI_REGISTRY_IMAGE/backend:$CI_COMMIT_SHA
  DOCKER_IMAGE_FRONTEND: $CI_REGISTRY_IMAGE/frontend:$CI_COMMIT_SHA

# --- Backend Jobs ---
build_backend:
  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 week

test_backend:
  stage: test
  image: maven:3.8.7-openjdk-17
  script:
    - echo "Testing Spring Boot application..."
    - mvn test

docker_build_and_push_backend:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Building backend Docker image..."
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $DOCKER_IMAGE_BACKEND -f Dockerfile.backend .
    - docker push $DOCKER_IMAGE_BACKEND
  only:
    - main # Déclencher uniquement sur la branche main

# --- Frontend Jobs ---
build_frontend:
  stage: build
  image: node:18-alpine
  script:
    - echo "Building Angular application..."
    - npm install
    - npm run build -- --output-path=./dist --configuration=production
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

test_frontend:
  stage: test
  image: node:18-alpine
  script:
    - echo "Testing Angular application..."
    - npm test -- --no-watch --browsers=ChromeHeadless # Exemple pour tests unitaires

docker_build_and_push_frontend:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Building frontend Docker image..."
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $DOCKER_IMAGE_FRONTEND -f Dockerfile.frontend .
    - docker push $DOCKER_IMAGE_FRONTEND
  only:
    - main

# --- Deployment Job (Exemple avec Docker Compose) ---
deploy_application:
  stage: deploy
  image: docker/compose:latest
  script:
    - echo "Deploying application using Docker Compose..."
    - # Configuration de l'environnement distant, par exemple via SSH
    - # ssh user@your_server "docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY && docker pull $DOCKER_IMAGE_BACKEND && docker pull $DOCKER_IMAGE_FRONTEND && docker-compose -f docker-compose.prod.yml up -d"
    - # Ceci est un exemple simplifié. Un déploiement en production nécessiterait une stratégie plus robuste.
    - echo "Deployment job triggered. For actual deployment, replace placeholder commands."
  only:
    - main
  when: manual # Le déploiement est souvent manuel ou conditionnel pour la production

Ce fichier définit des jobs pour chaque étape (build, test, package) pour les deux applications (backend et frontend). L'étape package se connecte au registre Docker (ici, le registre GitLab par défaut) et y pousse les images conteneurisées. Le job deploy_application est un exemple simplifié qui devrait être adapté pour votre environnement de production (Kubernetes, Docker Swarm, etc.).

3. Orchestration des services avec Docker Compose

Pour un environnement de développement local ou un déploiement sur un serveur unique, Docker Compose est un excellent outil pour orchestrer plusieurs conteneurs. Il permet de définir l'architecture de votre application (services, réseaux, volumes) dans un fichier YAML.

# docker-compose.yml
version: '3.8'
services:
  backend:
    image: ${CI_REGISTRY_IMAGE}/backend:latest # Ou utilisez le SHA pour une version spécifique
    ports:
      - "8080:8080"
    environment:
      # Ajoutez ici les variables d'environnement pour votre backend
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydatabase
      SPRING_DATASOURCE_USERNAME: user
      SPRING_DATASOURCE_PASSWORD: password
    depends_on:
      - db
    networks:
      - app-network

  frontend:
    image: ${CI_REGISTRY_IMAGE}/frontend:latest # Ou utilisez le SHA
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network

  db:
    image: postgres:13-alpine
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  db_data:

Ce fichier docker-compose.yml décrit comment le backend Spring Boot, le frontend Angular (via Nginx) et une base de données PostgreSQL interagissent. Lors du déploiement, les images sont tirées du registre et les services sont démarrés en fonction de cette configuration.

Conclusion

L'automatisation du déploiement avec GitLab CI/CD et Docker est une stratégie gagnante pour les applications Spring Boot et Angular. Elle garantit une cohérence environnementale, réduit les erreurs humaines et accélère considérablement le cycle de livraison, permettant aux équipes de se concentrer sur l'innovation plutôt que sur des tâches répétitives.

En adoptant ces pratiques, les développeurs peuvent améliorer la qualité de leurs logiciels et répondre plus efficacement aux besoins des entreprises. Laty Gueye Samba, Développeur Full Stack Java Spring Boot + Angular, expert basé à Dakar, encourage vivement l'intégration de ces outils pour toute équipe de développement moderne.

Pour approfondir vos connaissances, voici quelques ressources officielles :

• Documentation Docker officielle
• Documentation GitLab CI/CD officielle
• Déploiement Spring Boot
• Déploiement Angular