Docker für Java-Entwickler: Workshop zu Jib und Testcontainers

Docker für Java einordnen und einrichten

• Container für Java-Dienste: gleiches JDK und gleiche Konfiguration lokal, in CI und im Betrieb
• Arbeitsablauf: Maven- oder Gradle-Build, Image, Registry, Container
• Docker Desktop unter Windows mit WSL 2 statt Docker Toolbox; Rancher Desktop und Podman als Alternativen
• Docker Engine unter Linux, Docker Desktop auf dem Mac mit Apple Silicon
• JDK-Basis-Images auswählen: Eclipse Temurin, Amazon Corretto, Red Hat UBI und Distroless Java

Container ausführen und das erste Java-Image

• Docker CLI an einer Spring-Boot-Anwendung: run, ps, logs, exec und inspect
• Port 8080 freigeben, SPRING_PROFILES_ACTIVE setzen, Konfiguration per Volume einbinden
• Erstes Dockerfile: FROM, COPY und ENTRYPOINT für eine einfache Anwendung
• Fat JAR aus target/ ins Image kopieren und mit java -jar starten
• ENTRYPOINT in Exec-Form, damit die JVM SIGTERM erhält und sauber herunterfährt
• Weitere Anweisungen: WORKDIR, USER, ARG, ENV, EXPOSE, HEALTHCHECK und LABEL
• .dockerignore für target/, build/, .git und IDE-Dateien

Java-Images mit Maven und Gradle bauen

• Multi-Stage-Build: Kompilieren im JDK-Image, Laufzeit im schlanken JRE-Image
• BuildKit-Cache-Mounts für ~/.m2 und den Gradle-Cache, Abhängigkeiten vorab auflösen
• Layered JARs von Spring Boot: Abhängigkeiten, Loader und Anwendungscode als eigene Schichten
• Jib mit Maven- und Gradle-Plugin: reproduzierbare Images ohne Dockerfile und ohne Docker-Daemon
• Cloud Native Buildpacks mit spring-boot:build-image bzw. bootBuildImage
• Quarkus: Container-Image-Erweiterungen für Jib und Docker, Fast-JAR-Struktur im JVM-Modus
• Native Images mit GraalVM für Quarkus und Spring Boot im Multi-Stage-Build
• Eigene minimale Java-Laufzeit mit jdeps und jlink erzeugen
• Multi-Plattform-Images für ARM und x86 mit docker buildx oder Jib-Plattformen

Die JVM im Container

• Container-Erkennung der JVM über cgroups v2 und UseContainerSupport
• Heap mit -XX:MaxRAMPercentage statt festem -Xmx, lokal mit docker run --memory prüfen
• JAVA_TOOL_OPTIONS und JDK_JAVA_OPTIONS für JVM-Parameter ohne neues Image
• Startzeit verkürzen: Class Data Sharing (AppCDS) und Spring AOT bereits beim Image-Build

Images taggen, prüfen und teilen

• Tags aus Maven-Version und Git-SHA, kein latest für Bereitstellungen
• Push nach Docker Hub, GitHub Container Registry, Harbor oder Nexus
• Schwachstellenscan mit Docker Scout oder Trivy, SBOM mit dem CycloneDX-Maven-Plugin

Lokale Umgebung mit Docker Compose

• Compose-Grundlagen: compose.yaml, Services, Netzwerke, Volumes und docker compose als Plugin
• Spring-Boot-API mit PostgreSQL und Redis als Multi-Container-Anwendung
• Spring Boot Docker Compose Support: compose.yaml startet beim Anwendungsstart mit
• Quarkus Dev Services: Datenbank und Broker im Dev-Modus ohne eigene Compose-Datei
• Projektname, compose.override.yaml und .env-Dateien je Entwickler:in
• Mehrere Dateien mit -f und include, Profile für Debug- und Monitoring-Dienste
• JDWP-Port im Compose-Service freigeben und den IntelliJ-Debugger anhängen

Daten und Zustand in Containern

• Benannte Volumes oder Bind Mounts: wo die Daten der Entwicklungsdatenbank liegen
• Schema per Flyway oder Liquibase beim Start der Anwendung migrieren
• Volumes sichern und zurückspielen mit einem Hilfscontainer und tar
• PostgreSQL mit Primär und Replik per Compose für Lese-Last- und Failover-Tests
• Volume-Treiber und Plugins: local mit NFS-Optionen, Einsatz in Mehrknoten-Umgebungen

Integrationstests mit Testcontainers

• Testcontainers mit JUnit 5: @Testcontainers, @Container und PostgreSQLContainer
• @ServiceConnection in Spring Boot statt manueller @DynamicPropertySource
• Module für Kafka, LocalStack und Keycloak; eigene Images als GenericContainer
• Testcontainers zur Entwicklungszeit: Anwendung lokal mit Containern aus der Testkonfiguration starten
• Testcontainers in GitHub Actions und mit Podman oder Rootless-Docker betreiben

Java-Container beobachten

• docker stats, docker logs und docker events für den schnellen Überblick
• JVM im Container analysieren: jcmd, Java Flight Recorder und Heap-Dump per docker cp
• Micrometer und Actuator: /actuator/prometheus mit Prometheus und Grafana im Compose-Stack
• cAdvisor für Metriken je Container neben den JVM-Metriken

Ausblick: Docker Swarm für Java-Dienste

• Swarm-Modus der Docker Engine: Einsatz heute und Abgrenzung zu Kubernetes
• Mehrknoten-Testcluster auf lokalen VMs oder auf AWS/Azure statt mit Docker Machine
• Java-Dienst als Service mit Replikaten; Verhalten bei Ausfall von Container oder Knoten
• Skalieren und Rolling Update mit docker service update, Rücksprung bei Fehlern
• Compose-Stack ausrollen, Knoten mit drain warten, Constraints und globale Dienste

Java-Images mit Coding-Agenten

• Dockerfile-Änderungen des Agenten an Bauzeit, Schichtgröße und Cache-Treffern messen, etwa mit dive
• mvn verify mit Testcontainers als Abnahmekriterium, bevor der Agent eine Änderung als fertig meldet
• Vorgeschlagene JVM-Flags unter festem Speicherlimit und Last nachprüfen statt übernehmen
• Testcontainers für den Agenten über Rootless-Docker oder Podman statt über den Socket des Hosts
• Neue Temurin- oder Distroless-Tags aus Agentenvorschlägen pinnen und vor dem Merge scannen

Praxisprojekt: Bestellservice mit Spring Boot, PostgreSQL und Kafka

• Dasselbe Image per Layered-JAR-Dockerfile, Jib und Buildpacks bauen; Größe, Bauzeit und Start vergleichen
• Lokale Umgebung mit PostgreSQL, Kafka, Prometheus und Grafana als Compose-Stack
• Integrationstests mit Testcontainers und @ServiceConnection, Lauf in GitHub Actions
• Speicherlimit 512 MB: JVM-Einstellungen abstimmen, bis der Dienst unter Last stabil läuft