Créer une image Docker à partir d'une application Java

1. Introduction

Docker est une bonne option lorsqu’il s’agit de rendre les applications déployables dans différents environnements. Dans ce tutoriel, nous allons apprendre à empaqueter nos applications Java dans une image Docker qui peut fonctionner de manière cohérente partout.

Nous allons utiliser notre application de téléchargement de fichiers créée précédemment et lconfigurer pour créer un fichier JAR exécutable. Ensuite, nous l’emballerons dans une image Docker.

Commençons.

2. Configuration de notre projet Java

Pour ce tutoriel, nous allons utiliser Maven pour gérer les dépendances de notre projet et les processus de construction.

2.1 Configuration de Maven (pom.xml)

Tout d’abord, configurons notre fichier pom.xml pour empaqueter le fichier jar avec toutes ses dépendances. Pour cela, nous allons utiliser le maven-assembly-plugin ajouté à nos plugins sous la section <build> :

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.5.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.namastecode.SpringBoot3ThymeleafApplication</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Décomposons les parties importantes :

• <mainClass> spécifie le point d’entrée de notre application.
• <descriptorRefs> configuré avec jar-with-dependencies va empaqueter notre application et toutes ses dépendances dans un seul fichier JAR.
• <execution> indique à Maven de s’exécuter durant la phase package du cycle de vie de Maven.

Maintenant, lorsque nous exécutons mvn package, Maven va créer deux fichiers JAR dans le répertoire target - un avec des dépendances et un sans. Le JAR avec des dépendances aura un suffixe jar-with-dependencies.

Nous pouvons tester que l’application fonctionne correctement en utilisant la commande :

java -jar target/spring-boot-3-thymeleaf-0.0.1-SNAPSHOT-jar-with-dependencies.jar

Maintenant, nous sommes prêts à créer une image Docker.

3. Dockeriser une application Java

Les conteneurs sont un excellent moyen d’emballer des applications Java. Ils fournissent un environnement cohérent pour exécuter des applications, quel que soit l’endroit où elles sont déployées. Voyons comment créer une image Docker pour notre application Java.

3.1 Créer un Dockerfile

Nous commençons par ajouter un Dockerfile à la racine de notre projet :

spring-boot-3-thymeleaf/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/namastecode/
|   |           |   -- Other files        
│   │           └── SpringBoot3ThymeleafApplication.java
│   └── test/
│       └── java/
├── pom.xml
└── Dockerfile

Un Dockerfile est tout simplement un fichier texte contenant des instructions pour que Docker assemble une image. Chaque instruction crée une nouvelle couche immuable qui s’appuie sur la précédente.

Nous commencerons par définir notre image de base et le répertoire de travail où nous souhaitons placer notre application à l’intérieur du conteneur. Ensuite, nous copierons le fichier JAR et ajouterons les instructions pour l’exécuter :

FROM eclipse-temurin:23-jre-alpine

WORKDIR /app

COPY target/spring-boot-3-thymeleaf-0.0.1-SNAPSHOT-jar-with-dependencies.jar app.jar

ENTRYPOINT ["java", "-jar", "app.jar"]

Pour notre image de base, nous utilisons eclipse-temurin:23-jre-alpine, qui est une version légère du JRE (Java Runtime Environment) basée sur Alpine Linux. C’est un choix idéal pour exécuter des applications Java dans un conteneur lorsque aucune dépendance spécifique n’est requise.

Nous définissons /app comme le répertoire de travail à l’intérieur du conteneur. C’est ici que notre application sera copiée à l’aide de la commande COPY. Enfin, nous définissons l’entrypoint pour exécuter notre application avec la commande java -jar. L’entrypoint est la commande qui s’exécutera lorsque le conteneur démarrera.

3.2 Créer une Image Docker

Maintenant, nous exécutons la commande build pour créer une nouvelle image à partir de la racine de notre projet :

docker build -t spring-boot-3-thymeleaf .

Après la création de l’image, nous pouvons simplement exécuter docker image ls pour vérifier que l’image a été construite avec succès.

3.3 Exécution de l’image Docker

Enfin, exécutons notre application Java dockerisée :

docker run -p 8090:8090 spring-boot-3-thymeleaf:latest

Cela va créer un nouveau conteneur et exécuter notre application Java à l’intérieur. Nous devrions voir les journaux de votre application Spring Boot dans le terminal. De plus, nous mappé le port 8090 sur l’hôte au port 8090 sur le conteneur, qui est le port que notre application Spring Boot expose. Pour vérifier que l’application fonctionne, nous pouvons visiter http://localhost:8090 dans notre navigateur web.

4. Conclusion

Dans ce tutoriel, nous avons appris à créer une image Docker à partir d’une application Java. Nous avons commencé par configurer notre projet Maven pour empaqueter l’application avec ses dépendances, puis nous avons créé un Dockerfile pour définir l’image, et enfin, nous avons construit et exécuté l’image Docker.

Vous pouvez trouver le code complet sur GitHub.