{"id":501,"date":"2024-09-03T10:24:34","date_gmt":"2024-09-03T09:24:34","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=501"},"modified":"2024-09-26T10:29:05","modified_gmt":"2024-09-26T09:29:05","slug":"dockerisieren-einer-java-anwendung-mit-maven-und-jib","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=501","title":{"rendered":"Dockerisieren einer Java-Anwendung mit Maven und Jib"},"content":{"rendered":"\n

In der heutigen Welt der Softwareentwicklung ist die Containerisierung von Anwendungen eine bew\u00e4hrte Methode, um die Bereitstellung und Skalierbarkeit zu vereinfachen. Docker ist hierbei eine der am weitesten verbreiteten Technologien. In diesem Artikel werde ich Schritt f\u00fcr Schritt erkl\u00e4ren, wie du eine Java-Anwendung mit Maven und Jib dockerisieren kannst.<\/p>\n\n\n\n

Warum Dockerisieren?<\/h3>\n\n\n\n

Das Dockerisieren einer Anwendung hat zahlreiche Vorteile:<\/p>\n\n\n\n

    \n
  1. Konsistente Umgebungen:<\/strong> Durch das Containerisieren k\u00f6nnen Entwickler sicherstellen, dass die Anwendung in verschiedenen Umgebungen (Entwicklung, Test, Produktion) identisch l\u00e4uft.<\/li>\n\n\n\n
  2. Einfache Bereitstellung:<\/strong> Container k\u00f6nnen einfach zwischen verschiedenen Hosts verschoben werden, ohne dass Abh\u00e4ngigkeiten neu installiert oder konfiguriert werden m\u00fcssen.<\/li>\n\n\n\n
  3. Skalierbarkeit:<\/strong> Mit Container-Orchestrierungstools wie Kubernetes ist es einfach, mehrere Instanzen der Anwendung zu starten und zu verwalten.<\/li>\n\n\n\n
  4. Isolierte Laufzeitumgebung:<\/strong> Container bieten eine isolierte Umgebung, wodurch Konflikte mit anderen Anwendungen auf demselben Host vermieden werden.<\/li>\n<\/ol>\n\n\n\n

    Traditionell erfordert die Dockerisierung eine Dockerfile, um ein Docker-Image zu erstellen. Mit dem Jib-Plugin f\u00fcr Maven (oder Gradle) ist es jedoch m\u00f6glich, 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\u00f6tigen.<\/p>\n\n\n\n

    Was ist Jib?<\/h3>\n\n\n\n

    Jib ist ein Open-Source-Plugin, das von Google entwickelt wurde. Es erm\u00f6glicht Entwicklern, Docker-Images f\u00fcr Java-Anwendungen zu erstellen, ohne ein explizites Dockerfile schreiben zu m\u00fcssen oder sich direkt mit Docker-Befehlen auseinanderzusetzen. Jib integriert sich nahtlos in Maven und Gradle und automatisiert den Prozess der Image-Erstellung.<\/p>\n\n\n\n

    Jib bietet dabei mehrere Vorteile:<\/p>\n\n\n\n

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

      Voraussetzungen<\/h3>\n\n\n\n

      Bevor wir beginnen, sollten folgende Voraussetzungen erf\u00fcllt sein:<\/p>\n\n\n\n

        \n
      1. Java 8 oder h\u00f6her<\/strong> installiert.<\/li>\n\n\n\n
      2. Maven<\/strong> installiert.<\/li>\n\n\n\n
      3. Docker<\/strong>, falls du die Images lokal testen m\u00f6chtest.<\/li>\n\n\n\n
      4. Ein DockerHub-Konto<\/strong> (optional), um das Image zu ver\u00f6ffentlichen.<\/li>\n<\/ol>\n\n\n\n

        Schritt 1: Einrichten eines Maven-Projekts<\/h3>\n\n\n\n

        Zuerst erstellen wir ein einfaches Maven-Projekt. Falls du bereits ein Maven-Projekt hast, kannst du diesen Schritt \u00fcberspringen.<\/p>\n\n\n\n

          \n
        1. Erstelle ein neues Verzeichnis f\u00fcr deine Anwendung:<\/li>\n<\/ol>\n\n\n
             mkdir meine-java-anwendung\n   cd meine-java-anwendung<\/code><\/span><\/pre>\n\n\n
            \n
          1. Initialisiere ein Maven-Projekt:<\/li>\n<\/ol>\n\n\n
               mvn archetype:generate -DgroupId=com.beispiel.app -DartifactId=meine-java-anwendung -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
              \n
            1. Wechsle in das neu erstellte Verzeichnis:<\/li>\n<\/ol>\n\n\n
                 cd meine-java-anwendung<\/code><\/span><\/pre>\n\n\n
                \n
              1. \u00d6ffne die pom.xml<\/code>-Datei in deinem bevorzugten Texteditor.<\/li>\n<\/ol>\n\n\n\n
                Schritt 2: Jib-Plugin hinzuf\u00fcgen<\/h3>\n\n\n\n
                Um Jib in dein Maven-Projekt zu integrieren, musst du das Jib-Plugin in deiner pom.xml<\/code> hinzuf\u00fcgen. F\u00fcge das Plugin innerhalb des <plugins><\/code>-Abschnitts hinzu:<\/p>\n\n\n
                <build<\/span>><\/span>\n    <plugins<\/span>><\/span>\n        <plugin<\/span>><\/span>\n            <groupId<\/span>><\/span>com.google.cloud.tools<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>jib-maven-plugin<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>3.3.1<\/version<\/span>><\/span>\n        <\/plugin<\/span>><\/span>\n    <\/plugins<\/span>><\/span>\n<\/build<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
                Dieses Plugin erm\u00f6glicht es dir, Docker-Images direkt aus Maven heraus zu erstellen.<\/p>\n\n\n\n
                Schritt 3: Anwendungscode hinzuf\u00fcgen<\/h3>\n\n\n\n
                F\u00fcr unser Beispiel f\u00fcgen wir eine einfache Java-Anwendung hinzu, die eine Nachricht auf der Konsole ausgibt. \u00d6ffne die src\/main\/java\/com\/beispiel\/app\/App.java<\/code>-Datei und ersetze den Inhalt durch Folgendes:<\/p>\n\n\n
                package com.beispiel.app;\n\npublic class<\/span> App<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        System.out.println(\"Hallo, Docker-Welt!\"<\/span>);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                Dies ist eine sehr einfache Anwendung, die lediglich den Text „Hallo, Docker-Welt!“ ausgibt.<\/p>\n\n\n\n
                Schritt 4: Image-Erstellung mit Jib<\/h3>\n\n\n\n
                Mit dem Jib-Plugin k\u00f6nnen wir nun ein Docker-Image f\u00fcr unsere Anwendung erstellen. Es gibt verschiedene Optionen, um dies zu tun:<\/p>\n\n\n\n
                Option 1: Image in ein lokales Docker-Repository erstellen<\/h4>\n\n\n\n
                Wenn du Docker installiert hast und das Image lokal testen m\u00f6chtest, kannst du Jib anweisen, das Image in dein lokales Docker-Repository zu laden:<\/p>\n\n\n
                mvn<\/span> compile<\/span> jib<\/span>:dockerBuild<\/span><\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                Dieser Befehl erstellt das Docker-Image und speichert es in deinem lokalen Docker-Repository. Du kannst das erstellte Image mit dem folgenden Befehl anzeigen:<\/p>\n\n\n
                docker images<\/code><\/span><\/pre>\n\n\n
                Um den Container zu starten, verwende:<\/p>\n\n\n
                docker run --rm meine-java-anwendung<\/code><\/span><\/pre>\n\n\n
                Option 2: Image in eine Container-Registry pushen<\/h4>\n\n\n\n
                Falls du das Image auf eine externe Container-Registry wie DockerHub pushen m\u00f6chtest, kannst du dies ebenfalls mit Jib tun. F\u00fcge dazu die Zugangsdaten f\u00fcr DockerHub in deine pom.xml<\/code>-Datei ein:<\/p>\n\n\n
                <configuration<\/span>><\/span>\n    <to<\/span>><\/span>\n        <image<\/span>><\/span>docker.io\/dein-benutzername\/meine-java-anwendung<\/image<\/span>><\/span>\n        <auth<\/span>><\/span>\n            <username<\/span>><\/span>${env.DOCKERHUB_USERNAME}<\/username<\/span>><\/span>\n            <password<\/span>><\/span>${env.DOCKERHUB_PASSWORD}<\/password<\/span>><\/span>\n        <\/auth<\/span>><\/span>\n    <\/to<\/span>><\/span>\n<\/configuration<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
                Nun kannst du das Image direkt auf DockerHub hochladen:<\/p>\n\n\n
                mvn<\/span> compile<\/span> jib<\/span>:build<\/span><\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                Das Image wird dann in dein DockerHub-Repository hochgeladen. Du kannst es mit dem folgenden Befehl auf einem anderen Host ziehen:<\/p>\n\n\n
                docker pull dein-benutzername\/meine-java-anwendung<\/code><\/span><\/pre>\n\n\n
                Schritt 5: Weitere Jib-Konfigurationen<\/h3>\n\n\n\n
                Jib bietet viele zus\u00e4tzliche Konfigurationsoptionen, die n\u00fctzlich sein k\u00f6nnen, um das erstellte Image zu optimieren. Hier sind einige Beispiele:<\/p>\n\n\n\n
                Basis-Image anpassen<\/h4>\n\n\n\n
                Jib verwendet standardm\u00e4\u00dfig ein leichtgewichtiges Java-Basis-Image (z.B. gcr.io\/distroless\/java<\/code>). Falls du ein anderes Image verwenden m\u00f6chtest, kannst du dies wie folgt konfigurieren:<\/p>\n\n\n
                <from<\/span>><\/span>\n    <image<\/span>><\/span>openjdk:11-jre-slim<\/image<\/span>><\/span>\n<\/from<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
                Umgebungsvariablen hinzuf\u00fcgen<\/h4>\n\n\n\n
                Du kannst Umgebungsvariablen hinzuf\u00fcgen, die w\u00e4hrend der Laufzeit des Containers gesetzt werden:<\/p>\n\n\n
                <container<\/span>><\/span>\n    <environment<\/span>><\/span>\n        <JAVA_OPTS<\/span>><\/span>-Xms512m -Xmx1024m<\/JAVA_OPTS<\/span>><\/span>\n    <\/environment<\/span>><\/span>\n<\/container<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
                Portfreigaben konfigurieren<\/h4>\n\n\n\n
                Falls deine Anwendung auf einem bestimmten Port l\u00e4uft (z.B. eine Webanwendung auf Port 8080), kannst du dies ebenfalls konfigurieren:<\/p>\n\n\n
                <container<\/span>><\/span>\n    <ports<\/span>><\/span>\n        <port<\/span>><\/span>8080<\/port<\/span>><\/span>\n    <\/ports<\/span>><\/span>\n<\/container<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
                Fazit<\/h3>\n\n\n\n
                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, \u00fcbernimmt Jib diesen Prozess nahtlos im Rahmen deines Maven-Workflows. Es bietet eine effiziente M\u00f6glichkeit, Docker-Images zu erstellen und direkt in Container-Registrys zu pushen.<\/p>\n\n\n\n
                Durch die Integration in Maven (oder Gradle) und die Bereitstellung vieler Konfigurationsm\u00f6glichkeiten erm\u00f6glicht Jib eine einfache, flexible und performante Dockerisierung von Java-Anwendungen. Insbesondere f\u00fcr Teams, die ihre Build-Prozesse automatisieren und beschleunigen m\u00f6chten, ist Jib eine hervorragende L\u00f6sung.<\/p>\n","protected":false},"excerpt":{"rendered":"
                In der heutigen Welt der Softwareentwicklung ist die Containerisierung von Anwendungen eine bew\u00e4hrte Methode, um die Bereitstellung und Skalierbarkeit zu vereinfachen. Docker ist hierbei eine der am weitesten verbreiteten Technologien. In diesem Artikel werde ich Schritt f\u00fcr Schritt erkl\u00e4ren, wie du eine Java-Anwendung mit Maven und Jib dockerisieren kannst. Warum Dockerisieren? Das Dockerisieren einer Anwendung […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-501","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/501","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=501"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/501\/revisions"}],"predecessor-version":[{"id":502,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/501\/revisions\/502"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=501"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=501"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=501"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}