Docker und Kotlin: Containerisierung von Anwendungen für Entwickler

Docker und Kotlin: Anwendungscontainerisierung

Moderne Kotlin-Entwicklung erfordert zunehmend den Einsatz von Containerisierung. Docker ermöglicht es, eine Anwendung zusammen mit all ihren Abhängigkeiten in einer isolierten Umgebung zu verpacken, was ein konsistentes Verhalten auf dem lokalen Entwicklungsrechner, dem Testserver und in der Produktion garantiert. In diesem Artikel werden wir uns ansehen, wie man Kotlin-Projekte mithilfe von Best Practices und Codebeispielen richtig containerisiert.

Warum Kotlin-Anwendungen containerisieren?

Kotlin läuft auf der JVM, daher erben darauf geschriebene Anwendungen alle Funktionen des Java-Ökosystems. Die Hauptvorteile der Containerisierung sind:

• Umgebungsreproduzierbarkeit — vermeidet "bei mir funktioniert es"-Probleme.
• Abhängigkeitsisolierung — Versionen von JDK, Bibliotheken und Systemtools werden im Image festgelegt.
• Skalierbarkeit — Container lassen sich einfach in Kubernetes und anderen Orchestratoren bereitstellen.
• Schnelle Bereitstellung — Docker-Images sind kleiner als virtuelle Maschinen.

Erstellen eines Dockerfiles für eine Kotlin-Anwendung

Betrachten wir ein typisches Kotlin-Projekt mit Gradle. Unser build.gradle.kts könnte so aussehen:

plugins {    kotlin("jvm") version "1.9.22"    application}

application {    mainClass.set("com.example.MainKt")}

dependencies {    implementation(kotlin("stdlib"))    // other dependencies}

Erstellen wir nun ein Dockerfile. Die erste Option ist ein mehrstufiger Build, der die Kompilierungsphase von der Ausführungsphase trennt:

# Build stageFROM gradle:8.5-jdk21 AS buildCOPY --chown=gradle:gradle . /home/gradle/srcWORKDIR /home/gradle/srcRUN gradle build --no-daemon

# Execution stageFROM eclipse-temurin:21-jre-alpineWORKDIR /appCOPY --from=build /home/gradle/src/build/libs/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Lassen Sie uns die wichtigsten Punkte erläutern:

• gradle:8.5-jdk21 — offizielles Image mit Gradle und JDK zum Bauen.
• eclipse-temurin:21-jre-alpine — leichtes JRE-Image auf Alpine Linux (ca. 80 MB).
• COPY --from=build — nur das gebaute JAR kopieren, ohne Quellcode und Gradle-Cache.
• EXPOSE 8080 — dokumentiert den Port (öffnet ihn nicht automatisch).

Um das Image zu bauen, führen Sie aus:

docker build -t kotlin-app:latest .docker run -p 8080:8080 kotlin-app:latest

Optimierung der Image-Größe

Die Image-Größe ist entscheidend für die Bereitstellungsgeschwindigkeit. Hier sind einige Techniken für Kotlin-Anwendungen:

1. Verwenden von jlink zur Erstellung einer benutzerdefinierten JRE

Wenn Ihre Anwendung nicht alle JDK-Module verwendet, können Sie eine minimale JRE erstellen:

# Build stageFROM gradle:8.5-jdk21 AS buildCOPY . /appWORKDIR /appRUN gradle build --no-daemon

# Custom JRE creation stageFROM eclipse-temurin:21-jdk-alpine AS jre-builderRUN jlink \    --add-modules java.base,java.logging,java.naming,java.sql \    --strip-debug \    --no-man-pages \    --no-header-files \    --compress=2 \    --output /jre

# Final stageFROM alpine:3.19ENV JAVA_HOME=/jreENV PATH="${JAVA_HOME}/bin:${PATH}"COPY --from=jre-builder /jre /jreCOPY --from=build /app/build/libs/*.jar /app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "/app.jar"]

Dieser Ansatz reduziert die Image-Größe von ~200 MB auf ~40-50 MB.

2. Verwenden von Spring Boot layertools

Für Spring Boot-Projekte (mit Kotlin) können Sie das JAR für Docker-Caching in Schichten aufteilen:

// build.gradle.ktsstasks.bootJar {    layered {        enabled = true    }}

Kopieren Sie im Dockerfile die Schichten separat,