Java einfach erklärt

Plain Java

Dockerisieren einer Java-Anwendung mit Maven und Jib

In der heutigen Welt der Softwareentwicklung ist die Containerisierung von Anwendungen eine bewährte Methode, um die Bereitstellung und Skalierbarkeit zu vereinfachen. Docker ist hierbei eine der am weitesten verbreiteten Technologien. In diesem Artikel werde ich Schritt für Schritt erklären, wie du eine Java-Anwendung mit Maven und Jib dockerisieren kannst.

Warum Dockerisieren?

Das Dockerisieren einer Anwendung hat zahlreiche Vorteile:

  1. Konsistente Umgebungen: Durch das Containerisieren können Entwickler sicherstellen, dass die Anwendung in verschiedenen Umgebungen (Entwicklung, Test, Produktion) identisch läuft.
  2. Einfache Bereitstellung: Container können einfach zwischen verschiedenen Hosts verschoben werden, ohne dass Abhängigkeiten neu installiert oder konfiguriert werden müssen.
  3. Skalierbarkeit: Mit Container-Orchestrierungstools wie Kubernetes ist es einfach, mehrere Instanzen der Anwendung zu starten und zu verwalten.
  4. Isolierte Laufzeitumgebung: Container bieten eine isolierte Umgebung, wodurch Konflikte mit anderen Anwendungen auf demselben Host vermieden werden.

Traditionell erfordert die Dockerisierung eine Dockerfile, um ein Docker-Image zu erstellen. Mit dem Jib-Plugin für Maven (oder Gradle) ist es jedoch möglich, diesen Prozess zu vereinfachen, indem direkt aus dem Java-Build-System heraus Docker-Images erstellt werden, ohne eine Docker-Daemon oder eine Dockerfile zu benötigen.

Was ist Jib?

Jib ist ein Open-Source-Plugin, das von Google entwickelt wurde. Es ermöglicht Entwicklern, Docker-Images für Java-Anwendungen zu erstellen, ohne ein explizites Dockerfile schreiben zu müssen oder sich direkt mit Docker-Befehlen auseinanderzusetzen. Jib integriert sich nahtlos in Maven und Gradle und automatisiert den Prozess der Image-Erstellung.

Jib bietet dabei mehrere Vorteile:

  • Keine Docker-Daemon-Abhängigkeit: Jib kann Images direkt in ein Container-Registry (z.B. DockerHub) laden, ohne dass Docker auf deinem System installiert sein muss.
  • Effizientes Layering: Jib erstellt effizientere Images, indem es die Schichten der Anwendung optimal organisiert. Das bedeutet schnellere Builds und Pulls.
  • Kleine Images: Da Jib das Java-Image für deine Anwendung optimiert, sind die erstellten Images oft kleiner als bei manueller Dockerfile-Erstellung.

Voraussetzungen

Bevor wir beginnen, sollten folgende Voraussetzungen erfüllt sein:

  1. Java 8 oder höher installiert.
  2. Maven installiert.
  3. Docker, falls du die Images lokal testen möchtest.
  4. Ein DockerHub-Konto (optional), um das Image zu veröffentlichen.

Schritt 1: Einrichten eines Maven-Projekts

Zuerst erstellen wir ein einfaches Maven-Projekt. Falls du bereits ein Maven-Projekt hast, kannst du diesen Schritt überspringen.

  1. Erstelle ein neues Verzeichnis für deine Anwendung:
   mkdir meine-java-anwendung
   cd meine-java-anwendung
  1. Initialisiere ein Maven-Projekt:
   mvn archetype:generate -DgroupId=com.beispiel.app -DartifactId=meine-java-anwendung -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=falseCode-Sprache: JavaScript (javascript)
  1. Wechsle in das neu erstellte Verzeichnis:
   cd meine-java-anwendung
  1. Öffne die pom.xml-Datei in deinem bevorzugten Texteditor.

Schritt 2: Jib-Plugin hinzufügen

Um Jib in dein Maven-Projekt zu integrieren, musst du das Jib-Plugin in deiner pom.xml hinzufügen. Füge das Plugin innerhalb des <plugins>-Abschnitts hinzu:

<build>
    <plugins>
        <plugin>
            <groupId>com.google.cloud.tools</groupId>
            <artifactId>jib-maven-plugin</artifactId>
            <version>3.3.1</version>
        </plugin>
    </plugins>
</build>Code-Sprache: HTML, XML (xml)

Dieses Plugin ermöglicht es dir, Docker-Images direkt aus Maven heraus zu erstellen.

Schritt 3: Anwendungscode hinzufügen

Für unser Beispiel fügen wir eine einfache Java-Anwendung hinzu, die eine Nachricht auf der Konsole ausgibt. Öffne die src/main/java/com/beispiel/app/App.java-Datei und ersetze den Inhalt durch Folgendes:

package com.beispiel.app;

public class App {
    public static void main(String[] args) {
        System.out.println("Hallo, Docker-Welt!");
    }
}Code-Sprache: JavaScript (javascript)

Dies ist eine sehr einfache Anwendung, die lediglich den Text „Hallo, Docker-Welt!“ ausgibt.

Schritt 4: Image-Erstellung mit Jib

Mit dem Jib-Plugin können wir nun ein Docker-Image für unsere Anwendung erstellen. Es gibt verschiedene Optionen, um dies zu tun:

Option 1: Image in ein lokales Docker-Repository erstellen

Wenn du Docker installiert hast und das Image lokal testen möchtest, kannst du Jib anweisen, das Image in dein lokales Docker-Repository zu laden:

mvn compile jib:dockerBuildCode-Sprache: CSS (css)

Dieser Befehl erstellt das Docker-Image und speichert es in deinem lokalen Docker-Repository. Du kannst das erstellte Image mit dem folgenden Befehl anzeigen:

docker images

Um den Container zu starten, verwende:

docker run --rm meine-java-anwendung

Option 2: Image in eine Container-Registry pushen

Falls du das Image auf eine externe Container-Registry wie DockerHub pushen möchtest, kannst du dies ebenfalls mit Jib tun. Füge dazu die Zugangsdaten für DockerHub in deine pom.xml-Datei ein:

<configuration>
    <to>
        <image>docker.io/dein-benutzername/meine-java-anwendung</image>
        <auth>
            <username>${env.DOCKERHUB_USERNAME}</username>
            <password>${env.DOCKERHUB_PASSWORD}</password>
        </auth>
    </to>
</configuration>Code-Sprache: HTML, XML (xml)

Nun kannst du das Image direkt auf DockerHub hochladen:

mvn compile jib:buildCode-Sprache: CSS (css)

Das Image wird dann in dein DockerHub-Repository hochgeladen. Du kannst es mit dem folgenden Befehl auf einem anderen Host ziehen:

docker pull dein-benutzername/meine-java-anwendung

Schritt 5: Weitere Jib-Konfigurationen

Jib bietet viele zusätzliche Konfigurationsoptionen, die nützlich sein können, um das erstellte Image zu optimieren. Hier sind einige Beispiele:

Basis-Image anpassen

Jib verwendet standardmäßig ein leichtgewichtiges Java-Basis-Image (z.B. gcr.io/distroless/java). Falls du ein anderes Image verwenden möchtest, kannst du dies wie folgt konfigurieren:

<from>
    <image>openjdk:11-jre-slim</image>
</from>Code-Sprache: HTML, XML (xml)

Umgebungsvariablen hinzufügen

Du kannst Umgebungsvariablen hinzufügen, die während der Laufzeit des Containers gesetzt werden:

<container>
    <environment>
        <JAVA_OPTS>-Xms512m -Xmx1024m</JAVA_OPTS>
    </environment>
</container>Code-Sprache: HTML, XML (xml)

Portfreigaben konfigurieren

Falls deine Anwendung auf einem bestimmten Port läuft (z.B. eine Webanwendung auf Port 8080), kannst du dies ebenfalls konfigurieren:

<container>
    <ports>
        <port>8080</port>
    </ports>
</container>Code-Sprache: HTML, XML (xml)

Fazit

Die Dockerisierung einer Java-Anwendung kann durch die Nutzung des Jib-Plugins erheblich vereinfacht werden. Anstatt eine Dockerfile manuell zu erstellen und den gesamten Build-Prozess zu steuern, übernimmt Jib diesen Prozess nahtlos im Rahmen deines Maven-Workflows. Es bietet eine effiziente Möglichkeit, Docker-Images zu erstellen und direkt in Container-Registrys zu pushen.

Durch die Integration in Maven (oder Gradle) und die Bereitstellung vieler Konfigurationsmöglichkeiten ermöglicht Jib eine einfache, flexible und performante Dockerisierung von Java-Anwendungen. Insbesondere für Teams, die ihre Build-Prozesse automatisieren und beschleunigen möchten, ist Jib eine hervorragende Lösung.