Docker et Java : conteneurisation d'applications de A à Z

Introduction : pourquoi Docker est-il important pour un développeur Java ?

Le développement Java moderne ne se passe guère de la conteneurisation. Docker permet d'empaqueter une application avec toutes ses dépendances, la JVM et la configuration dans un conteneur isolé. Cela résout le problème « ça marche sur ma machine » et simplifie le CI/CD. Dans cet article, nous allons parcourir le cycle complet : de l'installation de Docker à l'optimisation des images pour la production.

1. Bases de Docker pour Java

1.1 Qu'est-ce que Docker et pourquoi est-il utile pour les projets Java ?

Docker est une plateforme pour créer, livrer et exécuter des applications dans des conteneurs. Pour Java, c'est particulièrement pertinent :

• Isolation des versions de la JVM — on peut utiliser Java 11 pour un service et Java 17 pour un autre sur le même hôte.
• Reproductibilité — l'image contient la version exacte du JDK, des bibliothèques et des utilitaires système.
• Passage à l'échelle — il est facile de lancer plusieurs instances via Kubernetes ou Docker Swarm.

1.2 Installation de Docker

Pour commencer, installez Docker Desktop (Windows/Mac) ou Docker Engine (Linux). Vérifiez l'installation :

docker --versiondocker info

2. Création d'un Dockerfile pour une application Java

Considérons une application Spring Boot simple. Créons un fichier Dockerfile à la racine du projet.

2.1 Dockerfile de base

# Utilisation de l'image officielle OpenJDKFROM openjdk:17-jdk-alpine

# Définition du répertoire de travailWORKDIR /app

# Copie du fichier JARCOPY target/myapp.jar app.jar

# Ouverture du portEXPOSE 8080

# Commande de lancementENTRYPOINT ["java", "-jar", "app.jar"]

2.2 Construction et exécution du conteneur

# Construction de l'imagedocker build -t my-java-app .

# Exécution du conteneurdocker run -p 8080:8080 my-java-app

Après le lancement, l'application sera accessible à l'adresse http://localhost:8080.

3. Optimisation des images Docker pour Java

Les images volumineuses ralentissent le déploiement. Examinons les techniques clés d'optimisation.

3.1 Construction multi-étapes (Multi-stage builds)

Permet de séparer l'étape de construction et l'étape d'exécution. Seul le JAR se retrouve dans l'image finale, sans Maven/Gradle ni les sources.

# Étape de constructionFROM maven:3.8.5-openjdk-17 AS buildWORKDIR /appCOPY pom.xml .RUN mvn dependency:go-offlineCOPY src ./srcRUN mvn package -DskipTests

# Étape d'exécutionFROM openjdk:17-jdk-alpineWORKDIR /appCOPY --from=build /app/target/myapp.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

3.2 Optimisation des couches

Docker met en cache les couches. Séparez la copie des données : d'abord les dépendances (changent rarement), puis le code (change souvent).

FROM maven:3.8.5-openjdk-17 AS buildWORKDIR /app# Copie uniquement du POM et téléchargement des dépendancesCOPY pom.xml .RUN mvn dependency:go-offline# Copie des sources et constructionCOPY src ./srcRUN mvn package -DskipTests

FROM openjdk:17-jdk-alpineWORKDIR /appCOPY --from=build /app/target/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

3.3 Utilisation de jlink pour créer une JRE minimale

Si vous utilisez Java 9+, vous pouvez créer une JRE personnalisée avec uniquement les modules nécessaires.

FROM openjdk:17-slim AS jre-buildRUN jlink --add-modules java.base,java.logging,java.sql \          --output /jre \          --strip-debug \          --no-man-pages \          --no-header-files

FROM alpine:latestCOPY --from=jre-build /jre /jreCOPY target/app.jar /app.jarENTRYPOINT ["/jre/bin/java", "-jar", "/app.jar"]

Une telle image peut peser moins de 50 Mo au lieu de 300+ Mo.

4. Docker Compose pour les microservices Java

Si vous avez plusieurs services (par exemple, Spring Boot + PostgreSQL), utilisez docker-compose.yml.

4.1 Pr