Conteneuriser une application Full Stack (Spring Boot & Angular) avec Docker Compose

Dans le paysage dynamique du développement logiciel, le déploiement d'applications full-stack peut s'avérer complexe en raison de la multiplicité des composants et de leurs dépendances. Les applications modernes, combinant un backend robuste comme Spring Boot et un frontend interactif tel qu'Angular, nécessitent une approche harmonisée pour garantir la cohérence des environnements et la simplicité du déploiement. C'est là que la conteneurisation entre en jeu, transformant les défis de déploiement en opportunités d'efficacité et de scalabilité.

Laty Gueye Samba, Développeur Full Stack à Dakar, spécialisé en Java Spring Boot et Angular, reconnaît l'importance cruciale d'outils qui rationalisent le cycle de vie des applications. La conteneurisation avec Docker offre une solution élégante pour encapsuler chaque composant (backend, frontend, base de données) dans son propre conteneur isolé. Cette approche garantit que l'application se comporte de manière identique, quel que soit l'environnement de déploiement, du poste de développement à la production.

Pour orchestrer ces conteneurs et les faire interagir de manière cohérente, Docker Compose s'impose comme l'outil de prédilection. Il permet de définir l'architecture complète de l'application full-stack dans un seul fichier, simplifiant ainsi la gestion des dépendances et la mise en place d'environnements complexes. Cet article explore comment un développeur full-stack peut efficacement conteneuriser une application Spring Boot et Angular en utilisant Docker Compose.

Les fondements de Docker pour une application Full Stack

La première étape de la conteneurisation consiste à créer des images Docker distinctes pour le backend Spring Boot et le frontend Angular. Une image Docker est un paquet léger, autonome et exécutable qui contient tout le nécessaire pour exécuter une application : le code, un environnement d'exécution, des bibliothèques, des variables d'environnement et des fichiers de configuration.

Dockerfile pour le backend Spring Boot

Pour une application Spring Boot, le Dockerfile doit compiler le projet et le packager sous forme de JAR exécutable, puis le faire tourner avec une JVM. L'utilisation d'une construction en plusieurs étapes (multi-stage build) est une bonne pratique pour réduire la taille de l'image finale.

# Étape 1 : Construction de l'application Spring Boot
FROM openjdk:17-jdk-slim AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN ./mvnw clean install -DskipTests

# Étape 2 : Création de l'image finale
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Ce Dockerfile utilise une image OpenJDK pour la compilation et une image plus légère pour l'exécution, exposant le port par défaut de Spring Boot (8080).

Dockerfile pour le frontend Angular

Le frontend Angular est généralement construit et servi par un serveur web léger comme Nginx. Ici aussi, une construction multi-étapes est bénéfique.

# Étape 1 : Construction de 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 avec Nginx
FROM nginx:alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/dist/votre-projet-angular /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Le nginx.conf doit être adapté pour servir les fichiers Angular et gérer les redirections nécessaires pour le routage côté client. Un exemple simple pourrait ressembler à ceci :

# nginx.conf (exemple)
server {
    listen 80;
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
        try_files $uri $uri/ /index.html;
    }
}

L'utilisation de Nginx pour servir l'application Angular est une pratique courante, offrant performance et robustesse.

Orchestrer avec Docker Compose : Le cœur de la conteneurisation

Une fois les Dockerfiles définis pour chaque service, Docker Compose permet de définir et d'exécuter l'application multi-conteneurs. Le fichier docker-compose.yml décrit tous les services, réseaux et volumes nécessaires à l'application. Cette approche permet de démarrer l'intégralité de l'environnement de développement ou de production avec une seule commande.

Structure du fichier docker-compose.yml

Un exemple typique de docker-compose.yml pour une application Spring Boot, Angular et une base de données PostgreSQL inclurait les services suivants : backend, frontend et db.

version: '3.8'

services:
  backend:
    build:
      context: ./backend # Chemin vers le dossier du projet Spring Boot
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydatabase
      SPRING_DATASOURCE_USERNAME: user
      SPRING_DATASOURCE_PASSWORD: password
      # Autres variables d'environnement Spring Boot
    depends_on:
      - db
    networks:
      - app-network

  frontend:
    build:
      context: ./frontend # Chemin vers le dossier du projet Angular
      dockerfile: Dockerfile
    ports:
      - "4200:80" # Mapper le port 4200 du host au port 80 du conteneur Nginx
    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

volumes:
  db_data:

networks:
  app-network:
    driver: bridge

Dans cet exemple :

• Le service backend est construit à partir du Dockerfile situé dans le dossier ./backend. Il expose le port 8080 et dépend du service db. Les variables d'environnement sont utilisées pour configurer la connexion à la base de données.
• Le service frontend est construit à partir du Dockerfile dans ./frontend. Il mappe le port 4200 de la machine hôte au port 80 de Nginx à l'intérieur du conteneur.
• Le service db utilise une image PostgreSQL officielle. Les variables d'environnement configurent la base de données et un volume est utilisé pour persister les données, même si le conteneur est supprimé.
• Tous les services sont connectés au même réseau app-network, leur permettant de communiquer entre eux en utilisant leurs noms de service (ex: backend peut se connecter à la base de données via db:5432).

Mise en œuvre et bonnes pratiques

Pour lancer l'application conteneurisée, il suffit d'ouvrir un terminal dans le répertoire contenant le fichier docker-compose.yml et d'exécuter la commande :

docker-compose up --build

Cette commande va construire les images (si elles ne sont pas déjà à jour) et démarrer tous les services définis dans le fichier Compose. Le backend Spring Boot sera accessible via http://localhost:8080 et le frontend Angular via http://localhost:4200.

Quelques bonnes pratiques pour la conteneurisation d'applications full-stack :

• Utilisation des volumes : Pour les bases de données, les volumes Docker sont essentiels pour persister les données. Pour le développement, on peut mapper des volumes pour le code source afin de bénéficier du rechargement à chaud (hot-reloading) sans reconstruire l'image à chaque modification.
• Gestion des variables d'environnement : Utilisez les variables d'environnement pour configurer les applications, surtout pour les informations sensibles comme les identifiants de base de données. Pour la production, considérez des outils comme Docker Swarm secrets ou Kubernetes Secrets.
• Multi-stage builds : Comme montré dans les exemples de Dockerfile, les constructions en plusieurs étapes réduisent considérablement la taille des images Docker finales, ce qui accélère les téléchargements et réduit la surface d'attaque.
• Santé des conteneurs : Ajoutez des checks de santé (health checks) à vos services dans Docker Compose pour s'assurer que les conteneurs sont prêts à recevoir du trafic avant que les services dépendants ne démarrent.

Conclusion

La conteneurisation d'une application Full Stack (Spring Boot & Angular) avec Docker Compose est une compétence indispensable pour les développeurs modernes. Elle apporte une solution robuste aux défis de l'environnement de développement, de test et de production, garantissant la cohérence, la portabilité et la scalabilité des applications. Laty Gueye Samba, Développeur Full Stack expert Java Spring Boot Angular basé à Dakar, met en avant ces technologies comme des piliers pour la construction d'applications performantes et résilientes.

En adoptant Docker et Docker Compose, les équipes de développement, en particulier les experts Java Spring Boot et Angular, peuvent significativement améliorer leur efficacité, réduire les "ça marche sur ma machine" et accélérer le déploiement d'applications complexes. La conteneurisation est une étape fondamentale vers l'intégration continue et le déploiement continu (CI/CD), et un facteur clé de succès pour les projets au Sénégal et au-delà.

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

• Documentation officielle Docker : https://docs.docker.com/
• Documentation Docker Compose : https://docs.docker.com/compose/
• Documentation Spring Boot : https://spring.io/projects/spring-boot
• Documentation Angular : https://angular.io/docs