Dockerisation d'une application Spring Boot et Angular : Bonnes pratiques et déploiement en environnement de production

Dans l'écosystème du développement logiciel moderne, la conteneurisation est devenue une pierre angulaire pour la création, le déploiement et la gestion d'applications. Docker, en particulier, s'est imposé comme l'outil de référence, offrant une solution robuste pour encapsuler des applications et leurs dépendances dans des conteneurs isolés. Cette approche garantit la portabilité et la cohérence de l'environnement, de la machine de développement à l'environnement de production.

Pour les développeurs full stack, tels que Laty Gueye Samba, basé à Dakar, Sénégal, expert en Java Spring Boot et Angular, la maîtrise de Docker est essentielle. Elle permet d'optimiser le cycle de vie des applications, de faciliter la collaboration et d'assurer un déploiement fiable. Cet article explore les bonnes pratiques de dockerisation d'une application combinant un backend Spring Boot et un frontend Angular, en mettant l'accent sur les étapes clés pour un déploiement efficace en environnement de production.

L'objectif est de présenter une méthodologie structurée pour tirer parti de Docker, garantissant que les applications développées par Laty Gueye Samba et d'autres professionnels puissent fonctionner de manière identique, quel que soit l'environnement cible. L'accent sera mis sur l'optimisation des images, la sécurité et l'orchestration pour un déploiement fluide et performant.

Dockerisation de l'API Spring Boot : Optimisation et Sécurité

La dockerisation d'une application Spring Boot commence par la création d'un Dockerfile efficace. Les bonnes pratiques se concentrent sur la réduction de la taille de l'image, l'accélération des builds et la sécurisation du conteneur.

Utilisation de builds multi-étapes

Il est fortement recommandé d'utiliser des builds multi-étapes pour les applications Spring Boot. Cela permet de séparer l'environnement de compilation (avec JDK) de l'environnement d'exécution (avec JRE), réduisant considérablement la taille de l'image finale.

# Étape 1 : Compilation de l'application
FROM maven:3.8.7-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean install -DskipTests

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

Optimisation et sécurité

• Version de JRE/JDK : Utiliser une version -slim ou -alpine de l'image de base JRE pour minimiser la taille.
• Utilisateur non-root : Exécuter le conteneur avec un utilisateur non-root pour des raisons de sécurité.
• Cache des dépendances : Pour Maven ou Gradle, copier uniquement le fichier pom.xml ou build.gradle et exécuter la commande de téléchargement des dépendances avant de copier le code source. Cela permet à Docker de mettre en cache les dépendances, accélérant les builds ultérieurs si le fichier de dépendances n'a pas changé.

Dockerisation de l'application Angular : Serveur web léger et builds efficaces

Pour une application Angular, la dockerisation implique généralement deux étapes principales : la construction de l'application statique et son déploiement via un serveur web léger comme Nginx.

Build multi-étapes pour Angular et Nginx

Similaire à Spring Boot, un build multi-étapes est idéal pour Angular. La première étape compile l'application Angular en fichiers statiques, et la seconde utilise Nginx pour servir ces fichiers.

# Étape 1 : Compilation de l'application Angular
FROM node:18-alpine AS builder
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=builder /app/dist/votre-projet-angular /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Le fichier nginx.conf est crucial pour configurer Nginx afin de servir correctement les routes Angular et les fichiers statiques :

# nginx.conf
server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ /index.html;
    }

    # Proxy pour l'API Spring Boot (si l'API est sur un chemin spécifique)
    # location /api {
    #     proxy_pass http://backend-service:8080; # 'backend-service' sera le nom du service dans docker-compose
    #     proxy_set_header Host $host;
    #     proxy_set_header X-Real-IP $remote_addr;
    #     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    # }
}

Orchestration et déploiement avec Docker Compose pour la production

Pour un environnement de production, gérer des conteneurs isolés est insuffisant. Il est nécessaire d'orchestrer leur démarrage, leur communication et leur configuration. Docker Compose est l'outil idéal pour définir et exécuter des applications multi-conteneurs.

Fichier docker-compose.yml

Un fichier docker-compose.yml permet de lier l'API Spring Boot et l'application Angular, en configurant les réseaux, les volumes et les variables d'environnement.

version: '3.8'

services:
  backend:
    build:
      context: ./backend # Chemin vers le dossier de l'application Spring Boot
      dockerfile: Dockerfile
    container_name: spring-boot-api
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydatabase
      SPRING_DATASOURCE_USERNAME: user
      SPRING_DATASOURCE_PASSWORD: password
      # Autres variables d'environnement spécifiques à la production
    depends_on:
      - db
    networks:
      - app-network

  frontend:
    build:
      context: ./frontend # Chemin vers le dossier de l'application Angular
      dockerfile: Dockerfile
    container_name: angular-app
    ports:
      - "80:80"
    environment:
      # Ex: Pour configurer l'URL de l'API depuis Angular
      # Cette configuration dépend de la manière dont Angular gère les variables d'environnement en runtime
      ANGULAR_API_URL: http://localhost:8080 # Ou l'URL publique si un proxy est utilisé
    networks:
      - app-network

  db: # Exemple avec PostgreSQL
    image: postgres:13
    container_name: postgres-db
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db-data:/var/lib/postgresql/data # Volume persistant pour les données
    networks:
      - app-network

volumes:
  db-data:

networks:
  app-network:
    driver: bridge

Pour déployer, il suffit d'utiliser la commande : docker-compose up -d --build.

Conclusion

La dockerisation d'une application Spring Boot et Angular offre des avantages considérables en termes de portabilité, de cohérence et de déploiement. En suivant les bonnes pratiques présentées, les développeurs peuvent créer des images légères, sécurisées et facilement gérables. L'utilisation de Docker Compose simplifie l'orchestration de ces applications multi-conteneurs, rendant le déploiement en environnement de production plus fiable et efficace.

L'expertise de Laty Gueye Samba, Développeur Full Stack Java Spring Boot + Angular à Dakar, Sénégal, dans ces technologies est un atout majeur pour les projets nécessitant des architectures robustes et modernes. La maîtrise de ces outils assure des performances optimales et une maintenance simplifiée, des éléments clés pour la réussite de tout projet numérique, que ce soit pour des applications de gestion des risques ou des plateformes complexes.

Pour approfondir les connaissances sur Docker, Spring Boot et Angular, il est recommandé de consulter les ressources officielles :

• Documentation officielle de Docker
• Spring Boot (Site officiel)
• Documentation officielle d'Angular