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

Le déploiement d'applications Full Stack modernes, combinant des technologies robustes comme Spring Boot pour le backend et Angular pour le frontend, représente souvent un défi en termes de complexité et de rapidité. Pour un développeur Full Stack à Dakar, au Sénégal, la capacité à automatiser ce processus est non seulement un gain de temps considérable, mais aussi un gage de qualité et de fiabilité. Cet article explore comment mettre en place une stratégie de déploiement continu (CI/CD) efficace en utilisant GitLab CI/CD et Docker pour ces architectures.

Dans un environnement de développement rapide, la fluidité entre le code source et la production est primordiale. L'intégration et le déploiement continus (CI/CD) offrent une méthodologie permettant d'automatiser les étapes de build, de test et de déploiement, réduisant ainsi les erreurs humaines et accélérant le cycle de livraison. Associé à la conteneurisation via Docker, cette approche garantit une cohérence parfaite des environnements, de la machine du développeur jusqu'au serveur de production.

Laty Gueye Samba, Développeur Full Stack basé à Dakar, Sénégal, s'appuie sur ces pratiques pour construire et livrer des applications performantes. La maîtrise de ces outils est essentielle pour des projets exigeant robustesse et évolutivité, notamment dans le contexte des applications métier complexes ou des systèmes ERP où la continuité des services est critique.

Fondamentaux du CI/CD avec GitLab et Docker pour le Full Stack

Le pipeline CI/CD est au cœur de l'automatisation du déploiement. GitLab CI/CD est un outil puissant qui permet de définir des pipelines directement dans le dépôt de code, via un fichier .gitlab-ci.yml. Chaque modification du code déclenche une série d'étapes (stages) configurables, allant de la compilation à l'exécution des tests, en passant par le déploiement.

Docker, de son côté, résout le problème des "ça marche sur ma machine". En empaquetant l'application et toutes ses dépendances dans un conteneur portable, il assure que l'application se comportera de manière identique quel que soit l'environnement d'exécution. Pour une application Full Stack Spring Boot/Angular, cela signifie conteneuriser le backend Java et le frontend Angular séparément ou ensemble, en fonction de l'architecture choisie.

Un pipeline CI/CD typique pour une application Full Stack pourrait inclure les étapes suivantes :

• Build : Compilation du code Spring Boot (avec Maven/Gradle) et de l'application Angular (avec npm/yarn).
• Test : Exécution des tests unitaires et d'intégration pour les deux parties de l'application.
• Dockerize : Création des images Docker pour le backend et le frontend.
• Deploy : Déploiement des conteneurs Docker sur un serveur cible ou une plateforme d'orchestration.

Architecture du Pipeline GitLab CI/CD pour Spring Boot et Angular

Pour orchestrer le déploiement d'une application Spring Boot et Angular, le fichier .gitlab-ci.yml est central. Il définit les jobs et les stages du pipeline. Voici un exemple simplifié de structure qui pourrait être utilisée :

stages:
  - build
  - test
  - dockerize
  - deploy

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

# --- Jobs pour le Backend Spring Boot ---
build_backend:
  stage: build
  image: maven:3.8.7-openjdk-17
  script:
    - echo "Construction du backend Spring Boot..."
    - cd backend-app
    - mvn clean package -DskipTests
  artifacts:
    paths:
      - backend-app/target/*.jar
    expire_in: 1 day

test_backend:
  stage: test
  image: maven:3.8.7-openjdk-17
  script:
    - echo "Exécution des tests backend..."
    - cd backend-app
    - mvn test

dockerize_backend:
  stage: dockerize
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Création de l'image Docker du backend..."
    - cd backend-app
    - docker build -t $DOCKER_IMAGE_BACKEND .
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $DOCKER_IMAGE_BACKEND

# --- Jobs pour le Frontend Angular ---
build_frontend:
  stage: build
  image: node:18-alpine
  script:
    - echo "Construction du frontend Angular..."
    - cd frontend-app
    - npm install
    - npm run build -- --output-path=./dist --configuration=production
  artifacts:
    paths:
      - frontend-app/dist/
    expire_in: 1 day

test_frontend:
  stage: test
  image: node:18-alpine
  script:
    - echo "Exécution des tests frontend..."
    - cd frontend-app
    - npm test

dockerize_frontend:
  stage: dockerize
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Création de l'image Docker du frontend..."
    - cd frontend-app
    - docker build -t $DOCKER_IMAGE_FRONTEND .
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $DOCKER_IMAGE_FRONTEND

# --- Job de Déploiement (exemple) ---
deploy_production:
  stage: deploy
  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 $DEPLOY_SERVER_IP >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
  script:
    - echo "Déploiement en production..."
    - ssh $DEPLOY_USER@$DEPLOY_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-backend || true && docker rm my-backend || true && docker run -d --name my-backend -p 8080:8080 $DOCKER_IMAGE_BACKEND && docker stop my-frontend || true && docker rm my-frontend || true && docker run -d --name my-frontend -p 80:80 $DOCKER_IMAGE_FRONTEND"
  environment:
    name: production
  only:
    - main

Ce fichier .gitlab-ci.yml illustre les étapes clés. Il est crucial d'avoir des Dockerfile bien configurés pour les applications Spring Boot et Angular afin de construire des images optimisées. Par exemple, le Dockerfile pour Angular pourrait utiliser un build multi-stage pour créer l'application avec Node.js puis servir les fichiers statiques avec Nginx dans une image finale très légère.

Intégration et Déploiement avec Registre Docker et Environnements

Le registre de conteneurs de GitLab (Container Registry) est un composant essentiel. Il permet de stocker les images Docker construites par le pipeline CI/CD, les rendant accessibles pour le déploiement. L'authentification est gérée via les variables prédéfinies de GitLab, simplifiant la connexion et le push/pull des images.

La gestion des environnements (développement, staging, production) est facilitée par GitLab CI/CD. Il est possible de déclencher des déploiements spécifiques à chaque environnement, souvent en se basant sur les branches Git (par exemple, la branche develop pour le staging, la branche main pour la production). L'utilisation de variables d'environnement dans le pipeline permet d'adapter la configuration des applications (adresses de bases de données, clés API) en fonction de l'environnement cible.

Pour le déploiement lui-même, plusieurs stratégies peuvent être adoptées. Pour des cas plus simples, un déploiement direct via SSH sur une machine virtuelle est possible, comme illustré dans l'exemple de pipeline. Pour des architectures plus complexes et évolutives, l'intégration avec des orchestrateurs de conteneurs comme Kubernetes est la voie privilégiée, permettant une gestion fine des services, de la scalabilité et de la haute disponibilité. Dans ces scénarios, le pipeline GitLab CI/CD serait responsable de la construction des images Docker et de la mise à jour des manifestes Kubernetes, qui seraient ensuite appliqués au cluster.

Conclusion

L'implémentation d'un pipeline CI/CD avec GitLab CI/CD et Docker est une démarche stratégique pour tout projet Full Stack Spring Boot/Angular. Elle garantit l'automatisation, la fiabilité et la rapidité des déploiements, des aspects cruciaux pour la réussite de projets ambitieux. Laty Gueye Samba, Développeur Full Stack Java Spring Boot + Angular à Dakar, met en œuvre ces technologies pour livrer des solutions robustes et maintenables.

En adoptant ces pratiques, les équipes de développement peuvent se concentrer davantage sur l'innovation et la création de valeur, sachant que le processus de livraison est sécurisé et efficace. C'est une compétence clé pour tout professionnel désireux de rester à la pointe des technologies modernes.

Pour approfondir le sujet, il est recommandé de consulter les ressources officielles :

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