Conteneuriser une stack Spring Boot 3 et PostgreSQL avec Docker Compose

Dans l'écosystème du développement logiciel moderne, la gestion des environnements de développement et de production peut souvent se transformer en un défi complexe. La garantie d'une cohérence entre les différentes étapes du cycle de vie d'une application est primordiale pour éviter les problèmes de "ça marche sur ma machine". Pour les applications basées sur Spring Boot et nécessitant une base de données robuste comme PostgreSQL, la conteneurisation via Docker Compose offre une solution élégante et puissante.

Cet article propose d'explorer la démarche de conteneurisation d'une pile Spring Boot 3 et PostgreSQL en utilisant Docker Compose. L'objectif est de montrer comment un développeur peut encapsuler son application et sa base de données dans des conteneurs isolés, facilitant ainsi le déploiement, la scalabilité et la maintenance. Pour Laty Gueye Samba, développeur Full Stack à Dakar, cette approche est essentielle pour des projets qui demandent une grande flexibilité et une mise en œuvre rapide dans des contextes technologiques variés.

La conteneurisation permet non seulement d'isoler les dépendances, mais aussi de standardiser l'environnement d'exécution, assurant que l'application se comporte de la même manière, qu'elle soit sur la machine de développement, sur un serveur de test ou en production. Grâce à Docker Compose, l'orchestration de plusieurs conteneurs, comme une application Spring Boot et une instance PostgreSQL, devient une tâche simple et déclarative.

Préparation du projet Spring Boot pour Docker

La première étape pour conteneuriser une application Spring Boot consiste à créer un Dockerfile à la racine du projet. Ce fichier contient les instructions nécessaires à Docker pour construire l'image de l'application. Pour une application Spring Boot 3, il est recommandé d'utiliser une image de base OpenJDK et de s'assurer que le fichier JAR est correctement empaqueté.

Voici un exemple de Dockerfile pour une application Spring Boot 3 :

# Utilisation d'une image de base Java 17
FROM openjdk:17-jdk-slim

# Ajout d'un volume pour le répertoire de travail
VOLUME /tmp

# Ajout du fichier JAR de l'application
# Assurez-vous que votre projet Spring Boot génère un fichier JAR exécutable
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar

# Expose le port par défaut de Spring Boot (8080)
EXPOSE 8080

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

Il est crucial de s'assurer que le projet Spring Boot est configuré pour générer un JAR exécutable. Cela se fait généralement via le plugin Spring Boot Maven ou Gradle dans le fichier pom.xml ou build.gradle. Par exemple, avec Maven :

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Avant de construire l'image Docker, il est nécessaire de compiler l'application Spring Boot pour générer le fichier JAR. Cela peut être fait avec mvn clean package.

Configuration de Docker Compose pour la stack complète

Docker Compose permet de définir et d'exécuter des applications Docker multi-conteneurs. La configuration se fait via un fichier docker-compose.yml. Ce fichier décrira deux services principaux : l'application Spring Boot et la base de données PostgreSQL.

Voici un exemple de fichier docker-compose.yml :

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/mydatabase
      SPRING_DATASOURCE_USERNAME: myuser
      SPRING_DATASOURCE_PASSWORD: mypassword
      SPRING_JPA_HIBERNATE_DDL_AUTO: update
    depends_on:
      - db
    networks:
      - mynetwork

  db:
    image: postgres:15.3-alpine
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - db_data:/var/lib/postgresql/data
    ports:
      - "5432:5432" # Optionnel : pour accéder à la DB depuis l'extérieur du conteneur
    networks:
      - mynetwork

volumes:
  db_data:

networks:
  mynetwork:
    driver: bridge

Dans ce fichier :

• Le service app est construit à partir du Dockerfile situé dans le répertoire courant (build: .).
• Le port 8080 de l'hôte est mappé au port 8080 du conteneur Spring Boot.
• Des variables d'environnement sont passées à l'application Spring Boot pour configurer la connexion à la base de données PostgreSQL. Il est important de noter que db est le nom du service de la base de données, permettant aux conteneurs de communiquer entre eux via leur nom de service.
• depends_on: - db indique que le service app dépend du service db, assurant que la base de données est démarrée avant l'application.
• Le service db utilise l'image officielle postgres:15.3-alpine.
• Des variables d'environnement sont également définies pour la configuration de la base de données PostgreSQL (nom de la DB, utilisateur, mot de passe).
• Un volume nommé db_data est utilisé pour persister les données de la base de données, même si le conteneur est supprimé.
• Un réseau Docker personnalisé, mynetwork, est créé pour permettre une communication sécurisée et isolée entre les services.

Lancement de la stack conteneurisée

Une fois le Dockerfile et le fichier docker-compose.yml configurés, le lancement de l'ensemble de la stack devient un jeu d'enfant. Depuis le répertoire racine du projet (là où se trouvent les deux fichiers), il suffit d'exécuter une seule commande :

docker compose up --build -d

• up : Lance les services définis dans docker-compose.yml.
• --build : Reconstruit l'image du service app (Spring Boot) si des modifications ont été apportées au Dockerfile ou au code source.
• -d : Démarre les conteneurs en mode détaché, c'est-à-dire en arrière-plan.

Pour vérifier que les services sont bien démarrés et fonctionnent, la commande suivante peut être utilisée :

docker compose ps

Pour consulter les logs d'un service spécifique (par exemple, l'application Spring Boot) :

docker compose logs app

En cas de besoin d'arrêter et de supprimer les conteneurs, les réseaux et les volumes créés par Docker Compose :

docker compose down -v

L'option -v est importante pour supprimer également les volumes de données, ce qui est utile pour repartir d'une base de données vierge lors du développement.

Conclusion

La conteneurisation d'une stack Spring Boot 3 et PostgreSQL avec Docker Compose est une pratique fondamentale pour tout développeur moderne. Elle garantit la portabilité de l'application, assure la cohérence des environnements et simplifie grandement les processus de développement, de test et de déploiement. Pour Laty Gueye Samba, Développeur Full Stack à Dakar, cette expertise est un atout majeur pour livrer des solutions robustes et efficaces.

L'adoption de Docker et Docker Compose transforme la manière dont les applications sont conçues et gérées, offrant une agilité indispensable dans le monde du développement logiciel actuel. Il est fortement recommandé de se familiariser avec ces outils pour optimiser la productivité et la fiabilité des projets.

Ressources Officielles :

• Documentation Docker Compose
• Référence Dockerfile
• Spring Boot et Docker
• Documentation PostgreSQL