Docker und Java: Containerisierung von Anwendungen – vollständiger Leitfaden

Einführung in Docker und Java: Warum Containerisierung die Entwicklung verändert

Moderne Softwareentwicklung ist ohne Containerisierung nicht mehr denkbar. Docker hat sich als De-facto-Standard für das Verpacken, Ausliefern und Ausführen von Anwendungen etabliert. Für Java-Entwickler löst Docker Schlüsselprobleme: "Es funktioniert auf meinem Rechner" und die Komplexität der Umgebungseinrichtung. In diesem Artikel werden wir uns ansehen, wie man Java-Anwendungen containerisiert – von einer einfachen JAR-Datei bis hin zu einem komplexen Microservice mit Spring Boot.

Docker ermöglicht es, eine Anwendung zusammen mit ihren Abhängigkeiten (JVM, Bibliotheken, Systemtools) in einem leichten, portablen Container zu isolieren. Dies ist besonders wichtig für Java, wo die JDK-Version, Speichereinstellungen und Systembibliotheken das Programmverhalten stark beeinflussen können.

Was Sie in diesem Artikel lernen werden

• Erstellung eines Dockerfile für Java-Anwendungen
• Optimierung der Image-Größen
• Arbeit mit Multi-Modul-Projekten (Maven/Gradle)
• Best Practices für Sicherheit und Leistung

1. Grundlagen: Erstellen eines Dockerfile für eine Java-Anwendung

Beginnen wir mit einem einfachen Beispiel. Angenommen, Sie haben eine Java-Anwendung, die als JAR-Datei gebaut wurde. Hier ist ein minimales Dockerfile, das sie in einen Container verpackt:

# Verwende das offizielle OpenJDK-ImageFROM openjdk:17-jdk-slim

# Lege das Arbeitsverzeichnis festWORKDIR /app

# Kopiere die JAR-Datei in den ContainerCOPY target/myapp.jar app.jar

# Öffne den Port, den die Anwendung verwendetEXPOSE 8080

# Befehl zum StartenENTRYPOINT ["java", "-jar", "app.jar"]

Dieses Dockerfile macht drei einfache Dinge: Es nimmt ein Basis-Image mit JDK 17, kopiert das kompilierte JAR und startet es. In realen Projekten ist dieser Ansatz jedoch ineffizient – bei jeder Codeänderung baut Docker das gesamte Image neu, einschließlich des Kopierens des JAR.

Multi-Stage-Build

Um die Build- und Ausführungsphasen zu trennen, verwenden Sie Multi-Stage-Dockerfiles. Dies reduziert das finale Image, indem Build-Tools (Maven, Gradle, JDK für die Kompilierung) ausgeschlossen werden.

# Build-PhaseFROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /buildCOPY pom.xml .RUN mvn dependency:go-offlineCOPY src ./srcRUN mvn clean package -DskipTests

# Finale PhaseFROM openjdk:17-jdk-slimWORKDIR /appCOPY --from=builder /build/target/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Die erste Phase verwendet ein vollständiges Maven-Image für die Kompilierung, die zweite ein minimales JRE-Image für die Ausführung. Das finale Image wiegt ~200 MB statt 700+ MB.

2. Image-Optimierung: Größe reduzieren und Build beschleunigen

Große Images verlangsamen das Deployment und erhöhen die Ladezeit. Hier sind einige Techniken für Java:

Verwenden Sie JLink zur Erstellung einer minimalen JRE

Ab Java 9 können Sie eine benutzerdefinierte JRE erstellen, die nur die benötigten Module enthält. Dies reduziert die Image-Größe drastisch.

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

FROM debian:bookworm-slimCOPY --from=jre-builder /jre /jreWORKDIR /appCOPY target/myapp.jar app.jarENV PATH="/jre/bin:${PATH}"ENTRYPOINT ["java", "-jar", "app.jar"]

Ein solches Image kann nur 40-60 MB wiegen, statt 200+ MB.

Docker-Layer-Caching

Docker cached jede Schicht. Um den Build zu beschleunigen, platzieren Sie selten geänderte Dateien (Abhängigkeiten) am Anfang des Dockerfile und häufig geänderte (Quellcode) am Ende.

FROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /build# Zuerst nur pom.xml kopieren und Abhängigkeiten herunterladenCOPY pom.xml .RUN mvn dependency:go-offline# Dann Quellcode kopieren und bauenCOPY src ./srcRUN mvn clean packag