Crea un'immagine Docker da un'applicazione Java

1. Introduzione

Docker è una buona opzione quando si tratta di rendere le applicazioni distribuite in diversi ambienti. In questo tutorial, impareremo come impacchettare le nostre applicazioni Java in un’immagine Docker che può essere eseguita in modo coerente ovunque.

Utilizzeremo la nostra applicazione per il caricamento dei file creata in precedenza e la configureremo per creare un file JAR eseguibile. Poi, lo impacchetteremo in un’immagine Docker.

Iniziamo.

2. Configurare il Nostro Progetto Java

Per questo tutorial, utilizzeremo Maven per gestire le dipendenze del nostro progetto e i processi di build.

2.1 Configurazione Maven (pom.xml)

Per prima cosa, configuriamo il nostro file pom.xml per impacchettare il file jar insieme a tutte le sue dipendenze. Per fare questo, utilizzeremo il maven-assembly-plugin aggiunto ai nostri plugin sotto la sezione <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>

Analizziamo le parti importanti:

• <mainClass> specifica il punto di ingresso della nostra applicazione.
• <descriptorRefs> configurato con jar-with-dependencies impacchetterà la nostra applicazione e tutte le sue dipendenze in un unico file JAR.
• <execution> indica a Maven di eseguire durante la fase di package del ciclo di vita di Maven.

Ora, quando eseguiamo mvn package, Maven creerà due file JAR nella directory target - uno con le dipendenze e uno senza. Il JAR con le dipendenze avrà un suffisso jar-with-dependencies.

Possiamo testare che l’applicazione funzioni correttamente utilizzando il comando:

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

Ora siamo pronti per creare un’immagine Docker.

3. Dockerizzare l’Applicazione Java

I container sono un ottimo modo per impacchettare le applicazioni Java. Forniscono un ambiente coerente per eseguire le applicazioni, indipendentemente da dove siano distribuite. Vediamo come creare un’immagine Docker per la nostra applicazione Java.

3.1 Creare Dockerfile

Iniziamo aggiungendo un Dockerfile nella radice del nostro progetto:

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

Un Dockerfile è semplicemente un file di testo che contiene istruzioni per Docker per assemblare un’immagine. Ogni istruzione crea un nuovo layer immutabile che si basa su quello precedente.

Inizieremo definendo la nostra immagine di base e la directory di lavoro in cui vogliamo posizionare la nostra applicazione all’interno del contenitore. Poi, copieremo il file JAR e aggiungeremo le istruzioni per eseguirlo:

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"]

Per la nostra immagine di base, stiamo utilizzando eclipse-temurin:23-jre-alpine, che è una versione leggera del JRE (Java Runtime Environment) basata su Alpine Linux. Questa è una scelta ideale per eseguire applicazioni Java in un container quando non sono necessarie dipendenze specifiche.

Definiamo /app come la directory di lavoro all’interno del container. Qui è dove la nostra applicazione verrà copiata utilizzando il comando COPY. Infine, impostiamo l’entrypoint per eseguire la nostra applicazione con il comando java -jar. L’entrypoint è il comando che verrà eseguito quando il container si avvia.

3.2 Creare un’immagine Docker

Ora, eseguiamo il comando build per creare una nuova immagine dalla radice del nostro progetto:

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

Dopo che l’immagine è stata creata, possiamo semplicemente eseguire docker image ls per verificare che l’immagine sia stata costruita con successo.

3.3 Esecuzione dell’immagine Docker

Infine, eseguiamo la nostra applicazione Java Dockerizzata:

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

Questo avvierà un nuovo container ed eseguirà la nostra applicazione Java al suo interno. Dovremmo vedere i log della nostra applicazione Spring Boot nel terminale. Inoltre, stiamo mappando la porta 8090 sull’host alla porta 8090 sul container, che è la porta su cui la nostra applicazione Spring Boot è esposta. Per controllare che l’applicazione sia in esecuzione, possiamo visitare http://localhost:8090 nel nostro browser web.

4. Conclusione

In questo tutorial, abbiamo imparato a creare un’immagine Docker da un’applicazione Java. Abbiamo iniziato configurando il nostro progetto Maven per impacchettare l’applicazione con le sue dipendenze, poi abbiamo creato un Dockerfile per definire l’immagine e infine abbiamo costruito ed eseguito l’immagine Docker.

Puoi trovare il codice completo su GitHub.