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

Dans l'écosystème du développement logiciel moderne, la capacité à livrer des applications de manière rapide, fiable et automatisée est devenue un facteur clé de succès. Le déploiement continu (CD) est au cœur de cette exigence, permettant de réduire les délais de mise sur le marché et d'améliorer la qualité des livraisons.

Pour les applications Full Stack, combinant par exemple un backend Java Spring Boot et un frontend Angular, la complexité du déploiement peut être significative. La gestion des dépendances, la construction des artefacts pour chaque partie de l'application, et leur orchestration pour un fonctionnement harmonieux, nécessitent une approche robuste. C'est dans ce contexte que GitLab CI/CD et Docker Compose se révèlent être des outils incontournables. Laty Gueye Samba, Développeur Full Stack basé à Dakar, Sénégal, souligne régulièrement l'importance de ces pratiques pour des projets efficaces et évolutifs.

Cet article explorera comment combiner la puissance des pipelines de GitLab CI/CD avec la flexibilité de la conteneurisation Docker Compose pour automatiser le déploiement continu d'applications Full Stack Java/Angular, offrant ainsi une solution complète et performante pour les développeurs.

Comprendre le Déploiement Continu avec GitLab CI/CD

Le Déploiement Continu (CD) est une extension de l'Intégration Continue (CI) qui garantit que chaque modification de code qui passe les tests automatisés est automatiquement déployée dans un environnement de production ou de pré-production. GitLab CI/CD est une plateforme intégrée à GitLab qui permet de définir des pipelines d'intégration et de déploiement directement dans le dépôt de code, via un fichier .gitlab-ci.yml.

Pour une application Full Stack Java/Angular, une pipeline GitLab CI/CD typique peut inclure les étapes suivantes :

• Build Backend (Java Spring Boot) : Compilation du code Java, exécution des tests unitaires et packaging de l'application (ex: en fichier JAR).
• Build Frontend (Angular) : Installation des dépendances NPM, exécution des tests unitaires et de bout en bout, puis construction des fichiers statiques optimisés pour la production.
• Conteneurisation : Création des images Docker pour le backend et le frontend.
• Test d'intégration : Déploiement temporaire des conteneurs pour des tests d'intégration automatisés.
• Déploiement : Push des images Docker vers un registre et déploiement des services via Docker Compose sur le serveur cible.

Un extrait simplifié d'une configuration .gitlab-ci.yml pourrait ressembler à ceci, définissant les étapes principales :

stages:
  - build
  - package
  - deploy

build_backend:
  stage: build
  image: maven:3.8.5-openjdk-17
  script:
    - echo "Building Java backend..."
    - mvn clean install -DskipTests
  artifacts:
    paths:
      - target/*.jar
  only:
    - master

build_frontend:
  stage: build
  image: node:16
  script:
    - echo "Building Angular frontend..."
    - npm install
    - npm run build -- --configuration production
  artifacts:
    paths:
      - dist/frontend
  only:
    - master

package_docker:
  stage: package
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Building Docker images..."
    - docker build -t my-registry/backend:latest ./backend
    - docker build -t my-registry/frontend:latest ./frontend
    - docker push my-registry/backend:latest
    - docker push my-registry/frontend:latest
  only:
    - master

deploy_production:
  stage: deploy
  image: docker:latest
  services:
    - docker:dind
  script:
    - echo "Deploying with Docker Compose..."
    - apk add openssh-client # Installer ssh pour se connecter au serveur distant
    - ssh user@your_server "docker login my-registry && docker pull my-registry/backend:latest && docker pull my-registry/frontend:latest && docker-compose -f /path/to/docker-compose.yml up -d"
  only:
    - master

Conteneurisation avec Docker Compose pour les Applications Full Stack

Docker est devenu la norme de facto pour la conteneurisation, offrant une manière légère et portable de packager des applications et leurs dépendances. Pour des architectures multi-services comme une application Full Stack Java/Angular, Docker Compose est l'outil idéal. Il permet de définir et d'exécuter des applications Docker multi-conteneurs.

Chaque composant de l'application (backend Java, frontend Angular, base de données) est encapsulé dans son propre conteneur, assurant une isolation et une gestion simplifiée des dépendances. Laty Gueye Samba, expert en Java Spring Boot et Angular, utilise régulièrement Docker Compose pour simuler des environnements de production en local et pour déployer des applications en production, soulignant ainsi sa polyvalence.

Un Dockerfile pour le backend Java (Spring Boot) pourrait ressembler à ceci :

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

Et un Dockerfile pour le frontend Angular (servi par Nginx) :

# Dockerfile pour le frontend Angular
# Étape 1 : Construction de l'application Angular
FROM node:16-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 avec Nginx
FROM nginx:alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/dist/frontend /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Ensuite, le fichier docker-compose.yml orchestre ces services, ainsi qu'une base de données comme PostgreSQL :

version: '3.8'

services:
  backend:
    build:
      context: ./backend # Chemin vers le répertoire du backend
      dockerfile: Dockerfile
    image: my-registry/backend:latest
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydatabase
      SPRING_DATASOURCE_USERNAME: user
      SPRING_DATASOURCE_PASSWORD: password
    depends_on:
      - db

  frontend:
    build:
      context: ./frontend # Chemin vers le répertoire du frontend
      dockerfile: Dockerfile
    image: my-registry/frontend:latest
    ports:
      - "80:80"
    depends_on:
      - backend

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Intégrer Docker Compose dans la Pipeline GitLab CI/CD

L'intégration de Docker Compose dans la pipeline GitLab CI/CD consiste à utiliser les capacités de GitLab pour construire les images Docker, les pousser vers un registre (GitLab Container Registry ou Docker Hub) et ensuite se connecter au serveur de déploiement pour y exécuter les commandes Docker Compose.

Comme illustré dans l'exemple de .gitlab-ci.yml précédent, l'étape package_docker est responsable de la création et du push des images. Ensuite, l'étape deploy_production utilise SSH pour se connecter au serveur cible. Une fois connecté, le script pull les dernières images depuis le registre et utilise docker-compose up -d pour démarrer ou mettre à jour les services en mode détaché. Cette approche garantit que l'application est toujours déployée avec la version la plus récente et cohérente des composants backend et frontend.

L'utilisation d'un registre d'images Docker est cruciale. GitLab fournit son propre registre intégré, ce qui simplifie grandement le processus en évitant de devoir configurer un registre externe et ses authentifications associées. Les identifiants GitLab CI/CD sont souvent suffisants pour pousser et tirer des images du registre intégré.

Conclusion

Le déploiement continu d'applications Full Stack Java/Angular avec GitLab CI/CD et Docker Compose offre une solution complète, fiable et automatisée pour les défis complexes de la livraison logicielle. Cette synergie permet aux équipes de développement, et notamment à des experts comme Laty Gueye Samba, Développeur Full Stack Dakar Sénégal, de se concentrer sur l'innovation et la création de valeur, plutôt que sur les tâches répétitives et sujettes aux erreurs du déploiement manuel.

En adoptant ces pratiques DevOps, les entreprises peuvent bénéficier d'une cadence de livraison accélérée, d'une meilleure stabilité des environnements et d'une confiance accrue dans les versions déployées. L'investissement dans ces technologies est un pas vers une ingénierie logicielle de pointe, essentielle pour l'avenir du développement.

Ressources Officielles :

• Documentation GitLab CI/CD
• Documentation Docker Compose
• Documentation Docker