Docker-Image aus Java-Anwendung erstellen

Inhaltsverzeichnis

1. Einleitung

Docker ist eine gute Option, wenn es darum geht, Anwendungen in verschiedenen Umgebungen einsetzbar zu machen. In diesem Tutorial werden wir lernen, wie wir unsere Java-Anwendungen in ein Docker-Image verpacken, das überall konsistent ausgeführt werden kann.

Wir werden unsere zuvor erstellte File-Upload-Anwendung verwenden und sie so konfigurieren, dass eine ausführbare JAR-Datei erstellt wird. Anschließend werden wir sie in ein Docker-Image verpacken.

Lass uns anfangen.

2. Einrichten unseres Java-Projekts

In diesem Tutorial verwenden wir Maven, um die Abhängigkeiten und den Build-Prozess unseres Projekts zu verwalten.

2.1 Maven-Konfiguration (`pom.xml`)

Zuerst konfigurieren wir unsere pom.xml-Datei, um die JAR-Datei zusammen mit all ihren Abhängigkeiten zu paketieren. Dazu verwenden wir das maven-assembly-plugin, das wir unter dem <build>-Abschnitt zu unseren Plugins hinzufügen:

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

Lass uns die wichtigen Teile aufschlüsseln:

<mainClass> gibt den Einstiegspunkt unserer Anwendung an.
<descriptorRefs> konfiguriert mit jar-with-dependencies wird unsere Anwendung und alle Abhängigkeiten in eine einzige JAR-Datei packen.
<execution> weist Maven an, während der package-Phase des Maven-Lebenszyklus zu laufen.

Jetzt, wenn wir mvn package ausführen, wird Maven zwei JAR-Dateien im target-Verzeichnis erstellen - eine mit Abhängigkeiten und eine ohne. Die JAR-Datei mit Abhängigkeiten wird ein jar-with-dependencies-Suffix haben.

Wir können testen, dass die Anwendung korrekt ausgeführt wird, indem wir den Befehl verwenden:

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

Jetzt sind wir bereit, ein Docker-Image zu erstellen.

3. Dockerize Java-Anwendung

Container sind eine großartige Möglichkeit, Java-Anwendungen zu verpacken. Sie bieten eine konsistente Umgebung zum Ausführen von Anwendungen, unabhängig davon, wo sie bereitgestellt werden. Lass uns ansehen, wie wir ein Docker-Image für unsere Java-Anwendung erstellen.

3.1 Dockerfile erstellen

Wir beginnen damit, eine Dockerfile im Stammverzeichnis unseres Projekts hinzuzufügen:

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

Eine Dockerfile ist einfach eine Textdatei, die Anweisungen für Docker enthält, um ein Image zusammenzustellen. Jede Anweisung erstellt eine neue, unveränderliche Schicht, die auf der vorherigen aufbaut.

Wir beginnen damit, unser Basis-Image und das Arbeitsverzeichnis zu definieren, in dem wir unsere Anwendung im Container platzieren möchten. Dann werden wir die JAR-Datei kopieren und die Anweisungen hinzufügen, um sie auszuführen:

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

Für unser Basis-Image verwenden wir eclipse-temurin:23-jre-alpine, das eine leichtgewichtige Version der JRE (Java Runtime Environment) auf Basis von Alpine Linux ist. Dies ist eine ideale Wahl, um Java-Anwendungen in einem Container auszuführen, wenn keine spezifischen Abhängigkeiten benötigt werden.

Wir definieren /app als das Arbeitsverzeichnis innerhalb des Containers. Hier wird unsere Anwendung mit dem COPY-Befehl kopiert. Schließlich setzen wir den Entry Point, um unsere Anwendung mit dem java -jar-Befehl auszuführen. Der Entry Point ist der Befehl, der ausgeführt wird, wenn der Container startet.

3.2 Erstellen eines Docker-Images

Jetzt führen wir den build Befehl aus, um ein neues Image aus dem Stammverzeichnis unseres Projekts zu erstellen:

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

Stelle sicher, dass du einen laufenden Docker-Daemon für diesen Schritt hast, andernfalls erhältst du einen Fehler. Vergiss auch nicht den Punkt am Ende des Befehls, der Docker anweist, im aktuellen Verzeichnis nach der Dockerfile zu suchen.

Nachdem das Image erstellt wurde, können wir einfach docker image ls ausführen, um zu überprüfen, ob das Image erfolgreich gebaut wurde.

3.3 Ausführen des Docker-Images

Letztendlich lassen Sie uns unsere Dockerisierte Java-Anwendung ausführen:

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

Dies wird einen neuen Container erstellen und unsere Java-Anwendung darin ausführen. Wir sollten die Protokolle von unserer Spring Boot-Anwendung im Terminal sehen. Außerdem mappen wir den Port 8090 auf dem Host zu Port 8090 im Container, welcher der Port ist, den unsere Spring Boot-Anwendung bereitstellt. Um zu überprüfen, ob die Anwendung läuft, können wir http://localhost:8090 in unserem Webbrowser besuchen.

4. Fazit

In diesem Tutorial haben wir gelernt, wie man ein Docker-Image aus einer Java-Anwendung erstellt. Wir haben damit begonnen, unser Maven-Projekt zu konfigurieren, um die Anwendung mit ihren Abhängigkeiten zu paketieren, dann haben wir eine Dockerfile erstellt, um das Image zu definieren, und schließlich haben wir das Docker-Image gebaut und ausgeführt.

Sie finden den vollständigen Code auf GitHub.