Dockeriser une stack complète (Spring Boot, Angular, PostgreSQL) pour la production: Guide étape par étape

Dans le paysage dynamique du développement logiciel, la gestion et le déploiement d'applications complexes représentent un défi constant. Pour les développeurs Full Stack comme Laty Gueye Samba, basé à Dakar, Sénégal, la capacité à orchestrer efficacement des architectures composées de multiples services est cruciale. Une stack courante inclut souvent une application backend construite avec Java Spring Boot, un frontend développé avec Angular, et une base de données relationnelle telle que PostgreSQL.

Traditionnellement, le déploiement de ces composants sur un serveur de production pouvait être fastidieux, marqué par des problèmes de compatibilité d'environnement et des configurations manuelles répétitives. C'est là que Docker entre en jeu, offrant une solution élégante pour conteneuriser chaque service, garantissant ainsi une cohérence entre les environnements de développement et de production.

Cet article propose un guide étape par étape pour la Dockerisation complète d'une stack Spring Boot, Angular et PostgreSQL, préparant ainsi ces applications pour un déploiement en production robuste et scalable. L'objectif est de fournir une approche pratique pour tout développeur Full Stack souhaitant optimiser son processus de déploiement grâce à la puissance de Docker et Docker Compose.

1. Préparation des applications pour la Dockerisation

La première étape consiste à créer un Dockerfile pour chaque composant de l'application. Un Dockerfile est un script qui contient des instructions pour la construction d'une image Docker.

1.1. Dockerisation de l'application Spring Boot (Backend)

Pour le backend Spring Boot, il est essentiel de créer un fichier JAR exécutable. Cela se fait généralement en utilisant Maven ou Gradle. Une fois le JAR généré (par exemple, target/my-backend-app.jar), le Dockerfile peut être structuré comme suit :

# Utiliser une image Java légère comme base
FROM openjdk:17-jdk-slim AS build

# Définir le répertoire de travail
WORKDIR /app

# Copier le fichier JAR de l'application Spring Boot
COPY target/my-backend-app.jar app.jar

# Exposer le port sur lequel l'application s'exécute
EXPOSE 8080

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

Ce Dockerfile est simple : il utilise une image OpenJDK 17, copie le fichier JAR de l'application et définit la commande d'exécution. Avant de construire cette image, il est impératif d'avoir empaqueté l'application Spring Boot : mvn clean package.

1.2. Dockerisation de l'application Angular (Frontend)

La Dockerisation d'une application Angular implique généralement une construction multi-étapes pour optimiser la taille de l'image finale. La première étape construit l'application, la seconde utilise un serveur web léger comme Nginx pour servir les fichiers statiques.

# Étape 1: Construire l'application Angular
FROM node:18-alpine AS build

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm install

COPY . .

# Construire l'application en mode production
RUN npm run build --configuration=production

# Étape 2: Servir l'application avec Nginx
FROM nginx:alpine

# Copier les fichiers de construction d'Angular vers le répertoire de service de Nginx
COPY --from=build /app/dist/my-frontend-app /usr/share/nginx/html

# Copier une configuration Nginx personnalisée si nécessaire (optionnel)
# COPY nginx.conf /etc/nginx/conf.d/default.conf

# Exposer le port de Nginx
EXPOSE 80

# Commande par défaut pour démarrer Nginx
CMD ["nginx", "-g", "daemon off;"]

Ce Dockerfile garantit que l'application Angular est construite efficacement et servie par un serveur web performant et léger, idéal pour la production. Il est essentiel que le dossier /app/dist/my-frontend-app corresponde au chemin de sortie de votre build Angular.

2. Orchestration de la stack complète avec Docker Compose

Après avoir conteneurisé chaque composant individuellement, l'étape suivante consiste à les orchestrer ensemble à l'aide de Docker Compose. Docker Compose permet de définir et d'exécuter des applications multi-conteneurs. Un fichier docker-compose.yml va déclarer tous les services (backend, frontend, base de données), leurs dépendances, leurs réseaux et leurs volumes.

Voici un exemple de fichier docker-compose.yml pour la stack Spring Boot, Angular et PostgreSQL :

version: '3.8'

services:
  db:
    image: postgres:13
    restart: always
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data
    ports:
      - "5432:5432" # Optionnel pour accès direct, recommandé de ne pas exposer en production

  backend:
    build:
      context: ./backend # Chemin vers le dossier de l'application Spring Boot
      dockerfile: Dockerfile
    restart: always
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydb
      SPRING_DATASOURCE_USERNAME: user
      SPRING_DATASOURCE_PASSWORD: password
      SPRING_JPA_HIBERNATE_DDL_AUTO: update # À adapter pour la production (ex: none ou validate)
    depends_on:
      - db

  frontend:
    build:
      context: ./frontend # Chemin vers le dossier de l'application Angular
      dockerfile: Dockerfile
    restart: always
    ports:
      - "80:80"
    depends_on:
      - backend

volumes:
  db_data:

Ce fichier définit trois services :

• db : Utilise l'image officielle PostgreSQL, configure les variables d'environnement pour la base de données et persiste les données grâce à un volume nommé db_data.
• backend : Construit l'image à partir du Dockerfile situé dans le dossier ./backend. Il expose le port 8080 et utilise des variables d'environnement pour se connecter à la base de données (le nom du service db est utilisé comme hostname). Il dépend du service db.
• frontend : Construit l'image à partir du Dockerfile situé dans le dossier ./frontend. Il expose le port 80 et dépend du service backend (bien que la communication directe soit souvent client-side, cette dépendance assure un ordre de démarrage).

Pour lancer la stack, il suffit de naviguer dans le répertoire contenant le fichier docker-compose.yml et d'exécuter :

docker-compose up -d --build

L'option -d détache les conteneurs (ils s'exécutent en arrière-plan) et --build force la reconstruction des images, assurant que les dernières modifications sont prises en compte.

Conclusion

La Dockerisation d'une stack complète composée de Spring Boot, Angular et PostgreSQL est une étape essentielle pour tout développeur Full Stack souhaitant optimiser le processus de déploiement en production. Ce guide a démontré comment conteneuriser chaque composant individuellement, puis les orchestrer de manière cohérente avec Docker Compose. Cette approche garantit non seulement une meilleure isolation et portabilité des applications, mais aussi une réduction significative des "ça marche sur ma machine" en production.

En adoptant ces pratiques, les développeurs peuvent améliorer la fiabilité de leurs déploiements et se concentrer davantage sur le développement de fonctionnalités, sachant que l'environnement de production sera cohérent et prévisible. Laty Gueye Samba, en tant qu'Expert Java Spring Boot Angular et Développeur Full Stack basé à Dakar, met l'accent sur l'importance de ces compétences pour la création de solutions logicielles performantes et résilientes.

Ressources Officielles :

• Documentation Docker
• Documentation Docker Compose
• Site officiel Spring Boot
• Documentation Angular
• Documentation PostgreSQL