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

Dans l'écosystème technologique actuel, la capacité à livrer des applications de manière rapide, fiable et automatisée est devenue un impératif. Pour les développeurs Full Stack, en particulier ceux qui maîtrisent des technologies comme Java Spring Boot pour le backend et Angular pour le frontend, le déploiement continu est une pierre angulaire de l'efficacité.

Cet article explore comment un développeur peut orchestrer un pipeline de déploiement continu robuste pour une application Spring Boot & Angular en s'appuyant sur les puissants outils que sont GitLab CI/CD et Docker. Cette approche permet non seulement d'accélérer les cycles de développement, mais aussi de garantir une cohérence et une reproductibilité inégalées entre les environnements de développement, de test et de production.

En tant qu'Expert Java Spring Boot Angular, Laty Gueye Samba, Développeur Full Stack basé à Dakar, Sénégal, met en lumière l'importance de ces pratiques modernes pour la livraison de solutions logicielles performantes et adaptatives, notamment dans des contextes exigeants comme les applications de gestion des risques ou les systèmes d'information hospitaliers.

Les Fondations : Conteneurisation avec Docker

La conteneurisation avec Docker est la première étape cruciale pour un déploiement continu efficace. Elle permet d'empaqueter l'application et toutes ses dépendances dans un conteneur standardisé, garantissant ainsi que l'application fonctionnera de la même manière, quel que soit l'environnement hôte. C'est particulièrement avantageux pour les applications Full Stack qui combinent différentes technologies comme Spring Boot et Angular.

Dockerfile pour le Backend Spring Boot

Le backend Spring Boot est généralement construit en un fichier JAR exécutable. Le Dockerfile va se charger de créer une image qui inclut ce JAR et une machine virtuelle Java (JVM).

# Utiliser une image de base Java pour le runtime
FROM openjdk:17-jdk-slim

# Définir le répertoire de travail à l'intérieur du conteneur
WORKDIR /app

# Copier le fichier JAR de l'application (supposant qu'il est déjà construit)
COPY target/your-spring-boot-app.jar /app/app.jar

# Exposer le port par défaut de Spring Boot (par exemple, 8080)
EXPOSE 8080

# Commande pour exécuter l'application
ENTRYPOINT ["java", "-jar", "app.jar"]

Dockerfile pour le Frontend Angular

Pour l'application Angular, le processus implique la construction des fichiers statiques (HTML, CSS, JavaScript) et leur service via un serveur web léger comme Nginx.

# Étape 1 : Construire l'application Angular
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 2 : Servir l'application construite avec Nginx
FROM nginx:alpine

COPY --from=build /app/dist/your-angular-app /usr/share/nginx/html

# Exposer le port par défaut de Nginx
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

L'Orchestration du CI/CD avec GitLab

GitLab CI/CD est une plateforme intégrée qui permet d'automatiser les étapes de construction, de test et de déploiement. Un fichier .gitlab-ci.yml, placé à la racine du dépôt, définit l'ensemble du pipeline. Ce fichier est le cœur du déploiement continu avec GitLab CI/CD.

Définition des Étapes (Stages)

Un pipeline typique pour une application Full Stack comme celle composée de Spring Boot et Angular inclurait les étapes suivantes :

• build : Compilation du backend Java et du frontend Angular.
• test : Exécution des tests unitaires et d'intégration.
• package : Création des images Docker pour les deux parties de l'application.
• deploy : Déploiement des images Docker sur l'environnement cible.

Exemple de Fichier .gitlab-ci.yml (Simplifié)

stages:
  - build
  - test
  - package
  - deploy

variables:
  DOCKER_REGISTRY: my-docker-registry.com
  SPRING_BOOT_IMAGE: ${DOCKER_REGISTRY}/laty-spring-boot-app
  ANGULAR_IMAGE: ${DOCKER_REGISTRY}/laty-angular-app

# Job pour construire l'application Spring Boot
build_backend:
  stage: build
  image: maven:3.8.5-openjdk-17
  script:
    - echo "Building Spring Boot backend..."
    - mvn clean install -DskipTests
  artifacts:
    paths:
      - backend/target/*.jar
    expire_in: 1 week

# Job pour construire l'application Angular
build_frontend:
  stage: build
  image: node:18-alpine
  script:
    - echo "Building Angular frontend..."
    - cd frontend
    - npm install
    - npm run build -- --configuration=production
  artifacts:
    paths:
      - frontend/dist/your-angular-app
    expire_in: 1 week

# Job pour les tests (exemple pour Spring Boot)
test_backend:
  stage: test
  image: maven:3.8.5-openjdk-17
  script:
    - echo "Running backend tests..."
    - mvn test
  dependencies:
    - build_backend

# Job pour créer les images Docker
package_docker_images:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY # Connexion au registre GitLab ou autre
    - docker build -t ${SPRING_BOOT_IMAGE}:$CI_COMMIT_SHORT_SHA -f backend/Dockerfile backend/
    - docker push ${SPRING_BOOT_IMAGE}:$CI_COMMIT_SHORT_SHA
    - docker build -t ${ANGULAR_IMAGE}:$CI_COMMIT_SHORT_SHA -f frontend/Dockerfile frontend/
    - docker push ${ANGULAR_IMAGE}:$CI_COMMIT_SHORT_SHA
  dependencies:
    - build_backend
    - build_frontend

# Job de déploiement (exemple très simplifié vers un hôte distant)
deploy_production:
  stage: deploy
  image: alpine/helm:3.8.2 # Ou une image avec SSH/kubectl si besoin
  environment:
    name: production
    url: https://your-app.com
  script:
    - echo "Deploying to production..."
    # Exemple: Utilisation de SSH pour se connecter au serveur et démarrer/mettre à jour les conteneurs
    # Il est recommandé d'utiliser des outils d'orchestration comme Kubernetes ou Docker Compose
    - 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 -o StrictHostKeyChecking=no user@your-server.com "
        docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY;
        docker pull ${SPRING_BOOT_IMAGE}:$CI_COMMIT_SHORT_SHA;
        docker pull ${ANGULAR_IMAGE}:$CI_COMMIT_SHORT_SHA;
        docker stop spring-boot-app || true; docker rm spring-boot-app || true;
        docker stop angular-app || true; docker rm angular-app || true;
        docker run -d --name spring-boot-app -p 8080:8080 ${SPRING_BOOT_IMAGE}:$CI_COMMIT_SHORT_SHA;
        docker run -d --name angular-app -p 80:80 ${ANGULAR_IMAGE}:$CI_COMMIT_SHORT_SHA;
        "
  only:
    - main # Déployer uniquement depuis la branche principale

Conclusion

L'implémentation d'un pipeline de déploiement continu pour une application Full Stack (Spring Boot & Angular) en utilisant GitLab CI/CD et Docker est une démarche essentielle pour tout développeur moderne. Elle garantit l'automatisation de la livraison logicielle, réduit les risques d'erreurs humaines et permet une itération rapide sur les produits.

Cette synergie entre Spring Boot, Angular, Docker et GitLab CI/CD représente une approche pérenne pour optimiser les processus de développement et de déploiement. Laty Gueye Samba, Expert Java Spring Boot Angular, continue de promouvoir ces bonnes pratiques pour construire des applications robustes et évolutives.

Pour approfondir vos connaissances sur ces outils, il est recommandé de consulter les documentations officielles :

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