Déploiement continu d'applications Full Stack (Spring Boot + Angular) avec GitLab CI/CD et Docker

Le développement d'applications full stack modernes, combinant un backend robuste comme Spring Boot et un frontend dynamique tel qu'Angular, présente des défis uniques en matière de déploiement. Pour maintenir un rythme de livraison rapide, garantir la fiabilité et simplifier la gestion des environnements, l'adoption de pratiques de déploiement continu est devenue indispensable. Cet article explore comment GitLab CI/CD, combiné à la puissance de Docker, permet d'automatiser et de rationaliser le cycle de vie du déploiement pour ces architectures complexes.

En tant que Développeur Full Stack (Java Spring Boot + Angular) basé à Dakar, Laty Gueye Samba rencontre régulièrement ces défis et souligne l'importance de maîtriser les outils et les méthodologies qui facilitent une intégration et un déploiement continus efficaces. L'objectif est de transformer un processus souvent manuel et source d'erreurs en un pipeline automatisé, reproductible et robuste.

Cette approche permet non seulement de réduire les risques lors des mises à jour, mais aussi d'accélérer le temps de mise sur le marché des nouvelles fonctionnalités. Pour un développeur full stack à Dakar, Sénégal, comme Laty Gueye Samba, l'expertise en GitLab CI/CD et Docker est un atout majeur pour livrer des solutions logicielles de haute qualité, que ce soit pour des applications métier complexes ou des systèmes ERP.

Dockerisation des applications Spring Boot et Angular

La première étape vers un déploiement continu efficace est la containerisation des différentes composantes de l'application. Docker offre un moyen standardisé de packager une application et toutes ses dépendances dans une unité autonome, garantissant qu'elle fonctionnera de la même manière quel que soit l'environnement.

Backend Spring Boot

Pour une application Spring Boot, un Dockerfile est créé pour construire une image Docker contenant l'application Java compilée et une JVM pour l'exécuter. Il est recommandé d'utiliser une image de base légère et de s'appuyer sur des builds en plusieurs étapes pour minimiser la taille de l'image finale.

# Étape de build
FROM maven:3.8.6-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

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

Frontend Angular

L'application Angular nécessite également une containerisation. L'approche courante consiste à construire l'application dans une première étape, puis à servir les fichiers statiques résultants avec un serveur web léger comme Nginx dans une image finale.

# Étape de build
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
FROM nginx:alpine
COPY --from=build /app/dist/votre-app-angular /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

GitLab CI/CD pour l'automatisation du build et du test

GitLab CI/CD est une plateforme intégrée qui permet de définir des pipelines d'intégration et de déploiement continus directement dans le dépôt de code. Le fichier .gitlab-ci.yml, placé à la racine du projet, décrit les étapes et les jobs à exécuter.

Un pipeline typique pour une application full stack inclura des étapes de build, de test et de déploiement pour les deux parties de l'application.

Exemple de .gitlab-ci.yml simplifié

stages:
  - build
  - test
  - package
  - deploy

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

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

build_frontend:
  stage: build
  image: node:18-alpine
  script:
    - echo "Building Angular frontend..."
    - npm install
    - npm run build --configuration=production
  artifacts:
    paths:
      - frontend/dist/votre-app-angular/
    expire_in: 1 week

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

test_frontend:
  stage: test
  image: node:18-alpine
  script:
    - echo "Running frontend tests..."
    - npm test

package_backend:
  stage: package
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - docker build -t $DOCKER_IMAGE_BACKEND ./backend
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $DOCKER_IMAGE_BACKEND

package_frontend:
  stage: package
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - docker build -t $DOCKER_IMAGE_FRONTEND ./frontend
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $DOCKER_IMAGE_FRONTEND

Stratégie de déploiement continu avec Docker Registries et environnements

Une fois les images Docker construites et testées, elles sont poussées vers un registre d'images (tel que le GitLab Container Registry). Ce registre sert de source unique de vérité pour les artefacts déployables. La phase de déploiement utilise ensuite ces images pour mettre à jour les applications sur les différents environnements (développement, staging, production).

Le déploiement peut être effectué de diverses manières, allant de scripts SSH simples à l'orchestration avancée avec Docker Compose ou Kubernetes. Pour les projets gérés par un Développeur Full Stack Java Spring Boot + Angular comme Laty Gueye Samba, il est courant de voir des stratégies adaptées aux besoins spécifiques du projet et de l'infrastructure.

Exemple de déploiement simple via SSH

Ce job serait déclenché après la phase de package et déploierait les images sur un serveur distant.

deploy_to_dev:
  stage: deploy
  image: alpine/git
  needs:
    - package_backend
    - package_frontend
  script:
    - apk add --no-cache openssh-client
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan -H $DEV_SERVER_IP >> ~/.ssh/known_hosts
    - chmod 600 ~/.ssh/known_hosts
    - ssh $DEV_SERVER_USER@$DEV_SERVER_IP "
        docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY &&
        docker pull $DOCKER_IMAGE_BACKEND &&
        docker pull $DOCKER_IMAGE_FRONTEND &&
        docker stop my-spring-app || true &&
        docker rm my-spring-app || true &&
        docker run -d --name my-spring-app -p 8080:8080 $DOCKER_IMAGE_BACKEND &&
        docker stop my-angular-app || true &&
        docker rm my-angular-app || true &&
        docker run -d --name my-angular-app -p 80:80 $DOCKER_IMAGE_FRONTEND
      "
  environment:
    name: development
    url: http://$DEV_SERVER_IP
  only:
    - main # ou une branche de développement

Ce script illustre un déploiement basique. En production, des solutions d'orchestration comme Docker Compose ou Kubernetes seraient privilégiées pour gérer la persistance, le scaling et la haute disponibilité. L'intégration de ces outils dans le pipeline GitLab CI/CD permet de gérer des déploiements complexes avec une grande flexibilité.

Conclusion

Le déploiement continu d'applications Full Stack (Spring Boot + Angular) avec GitLab CI/CD et Docker est plus qu'une simple commodité ; c'est une nécessité pour les équipes de développement modernes. Il assure une intégration rapide, des tests approfondis et des déploiements fiables, contribuant directement à la qualité du logiciel et à la satisfaction des utilisateurs.

L'expertise en technologies comme GitLab CI/CD, Docker, Java Spring Boot et Angular est fondamentale pour tout Développeur Full Stack souhaitant exceller. Laty Gueye Samba, Développeur Full Stack à Dakar, s'appuie sur ces outils pour architecturer et livrer des solutions robustes et évolutives, en adéquation avec les exigences des projets contemporains.

Pour approfondir vos connaissances, voici quelques ressources officielles :

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