[JAVA] Ich habe versucht, Docker und Maven / Netbean mit Jib gut zu integrieren

Ich habe Docker für eine Weile verwendet, um eine Java-Umgebung zu erstellen, aber es erstellt übrigens ein Docker-Image mit Maven, ohne eine Docker-Datei [Jib] zu schreiben (https://github.com/GoogleContainerTools/jib). Ich dachte es und versuchte es.

Um ehrlich zu sein, habe ich nicht viel darauf geachtet, weil ich dachte "Ist es nicht in Ordnung, eine Docker-Datei normal zu schreiben?", Aber es ist überraschend bequem zu verwenden.

Dieses Mal habe ich eine Java 11-Umgebung mit meiner Hauptentwicklungsumgebung Mac + NetBeans erstellt, daher werde ich beschreiben, wie das geht. Es gab auch eine kleine Falle, also werde ich das auch auflisten.

Das fertige Produkt ist unten. https://github.com/koduki/example-jib

Erstellen eines Programms zur Ausführung

Schreiben Sie natürlich zuerst den auszuführenden Code. Alles ist in Ordnung, aber sobald es wie folgt aussieht. Es scheint, dass "public static void main" als Endpunkt notwendig ist.

public class Main {

    public static void main(String[] args) {
        System.err.printf("%s %s, %s %s" + System.lineSeparator(),
                System.getProperty("os.name"),
                System.getProperty("os.version"),
                System.getProperty("java.vm.name"),
                System.getProperty("java.vm.version")
        );
        System.out.println("Hello World.");
    }
}

Zugabe von Fock

Dann fügen wir trotzdem Jib hinzu. Es ist so einfach wie das Hinzufügen eines Plug-Ins zu pom.xml.

<plugin>
    <groupId>com.google.cloud.tools</groupId>
    <artifactId>jib-maven-plugin</artifactId>
    <version>1.0.0-rc2</version>
    <configuration>
        <from>
            <image>openjdk:11-jdk-slim</image>
        </from> 
        <to>
            <image>example-jib</image>
        </to>
        <container>
            <jvmFlags>
                <jvmFlag>-Xmx512m</jvmFlag>
                <jvmFlag>-Xdebug</jvmFlag>
            </jvmFlags>
        </container>
    </configuration>
</plugin>

Weitere Informationen finden Sie unter Offizielles Dokument, aber es gibt einige Punkte. Zuerst das Tag "to / image", das den Bildnamen nach dem Erstellen angibt. Und das Tag "from / image", das das Originalbild angibt.

from / image ist optional. In diesem Fall wird standardmäßig gcr.io / Distroless / Java verwendet. Da es sich bei dieser Umgebung jedoch um Java8 handelt, müssen Sie ein JDK wie Java11 explizit angeben, wenn Sie es verwenden möchten. Seien Sie also vorsichtig. Mit container können Sie verschiedene Dinge wie JVM-Optionen angeben. Obwohl diesmal nicht angegeben, verwenden Sie extraDirectory. Sie können auch das Äquivalent von "ADD" in der Docker-Datei ausführen. Die Dateien in src / resouces werden jedoch automatisch zum Container hinzugefügt, sodass sie möglicherweise nicht so häufig ins Spiel kommen.

Wenn Sie auf komplizierte Weise mit dem Container spielen möchten, ist es meiner Meinung nach einfacher, mit Jib ein Basis-Image zu erstellen und es als FROM zu verwenden.

Mit Jib ein Image erstellen

Als nächstes wird das Bild erstellt.

$ mvn compile jib:dockerBuild

Dies allein überspringt die Erstellung der Docker-Datei und erstellt ein Bild. Sie sollten sehen können, dass das Bild wie unten gezeigt ordnungsgemäß erstellt wurde.

% docker images|grep example-jib      
example-jib                    latest              8ec59091042c        49 years ago        491MB

Im Fall von "dockerBuild" wird das Image im lokalen Docker-Daemon registriert. Wenn Sie jedoch direkt auf eine Fernbedienung wie DockerHub übertragen möchten, verwenden Sie "jib: build".

Wenn Sie Docker für Mac zu diesem Zeitpunkt verwenden, wird möglicherweise der folgende Fehler angezeigt.

Failed to execute goal com.google.cloud.tools:jib-maven-plugin:1.0.0-rc2:dockerBuild (default-cli) on project example-jib: Build to Docker daemon failed, perhaps you should make sure Docker is installed and you have correct privileges to run it -> [Help 1]

Dies liegt einfach daran, dass Jib den Docker-Daemon nicht gefunden hat. Wenn Sie jedoch den Docker-Befehl direkt drücken, funktioniert er normal? ?? ?? Es war so. Es ist jedoch einfach, die Seeds anzuzeigen, und wenn Docker für Mac direkt über die Befehlszeile aufgerufen wird, muss "DOCKER_HOST" nicht angegeben werden, sodass es nicht in der Umgebungsvariablen enthalten war. Es ist notwendig, der Umgebungsvariablen mit dem folgenden Befehl usw. DOCKER_HOST hinzuzufügen.

export DOCKER_HOST=unix:///var/run/docker.sock

Ich möchte, dass Sie diesen Bereich in READ ME erwähnen, aber ich frage mich, ob er für diejenigen, die damit vertraut sind und sich niemand darum kümmert, zu offensichtlich war. .. ..

Führen Sie den Container von Maven aus

Als nächstes folgt die Ausführung des Containers von Maven. Sie können "Docker Run" normal ausführen, dies ist jedoch unpraktisch, da Sie das Terminal separat starten müssen. .. .. Also habe ich versucht, dies auch von Maven aus zu ermöglichen.

Jib selbst scheint Build-spezifisch zu sein und es scheint keinen Mechanismus zu geben, um es auszuführen. Deshalb habe ich ein anderes Plug-In namens Fabric8io / Docker-Maven-Plugin eingefügt. Ich tat. Aus diesem Grund habe ich pom.xml Folgendes hinzugefügt.

<plugin>
    <groupId>io.fabric8</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.28.0</version>
    <configuration>
        <showLogs>true</showLogs>
        <images>
            <image>
                <name>example-jib</name>
                <run>
                    <log>
                        <enabled>true</enabled>    
                    </log>
                    <wait>
                        <exit>0</exit>
                    </wait>
                </run>
            </image>
        </images>
        <keepContainer>false</keepContainer>
    </configuration>
</plugin>

Weitere Informationen finden Sie in der offiziellen Dokumentation. Geben Sie jedoch das Image an, das mit "image / name" ausgeführt werden soll. Wenn Sie ein Volume oder einen Port benötigen, ist dies wie das Hinzufügen zum Ausführen.

Die Punkte sind "showLogs", "image / run / log / enabled", "image / run / wait / exit". Wenn dieser Bereich nicht angegeben wird, wird das Ausführungsergebnis nicht an die Standardausgabe ausgegeben. showLogs und image / run / log / enabled sind Optionen zur Ausgabe des Ausführungsergebnisses als Protokoll. Dies reicht jedoch nicht aus, und wenn Sie etwas im Tag "wait" nicht registrieren, wird die Ausführung sofort beendet und es wird nichts auf dem Bildschirm angezeigt. Daher habe ich "exit 0" aktiviert, um den normalen Abschluss zu bestätigen.

Wenn Sie dies tun, erhalten Sie:

% mvn docker:start   
[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------< cn.orz.pascal:example-jib >----------------------
[INFO] Building example-jib 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- docker-maven-plugin:0.28.0:start (default-cli) @ example-jib ---
[INFO] DOCKER> [example-jib:latest]: Start container ec75063ae514
ec7506> Linux 4.9.125-linuxkit, OpenJDK 64-Bit Server VM 11.0.1+13-Debian-2bpo91
ec7506> Hello World.
[INFO] DOCKER> [example-jib:latest]: Waited on exit code 0 964 ms
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  5.142 s
[INFO] Finished at: 2019-01-13T20:09:12-08:00
[INFO] ------------------------------------------------------------------------

Da der Betriebssystemteil des Ausführungsergebnisses Linux anstelle von Mac ist, können Sie sehen, dass es im Container ordnungsgemäß gestartet wurde.

Integration in den Maven / Netbeans-Erstellungsprozess

Wenn Sie alles über die Befehlszeile bedienen möchten, können Sie jedes Mal jib: dockerBuildoderdocker: start` drücken, aber normalerweise entwickeln Sie mit IDE, oder? Es ist Java. Mit NetBeans können Sie benutzerdefinierte Maven-Ziele registrieren, aber ich habe keine Lust, die IDE zu verwenden, daher werde ich sie etwas integrierter einrichten.

Führen Sie jib: dockerBuild auf NetBeans Build aus

Bei NetBeans ist es üblich, ein Build-Image mit "Build" im Menü zu erstellen. Wenn es Java ist, wird jar erstellt, und wenn es JavaEE ist, ist Krieg angemessen. Warum Mavens "Paket" -Phase überschreiben, damit das Docker-Image weiterhin generiert wird?

<plugin>
    <groupId>com.google.cloud.tools</groupId>
    <artifactId>jib-maven-plugin</artifactId>
...
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>dockerBuild</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Ich habe das Execution-Tag zuvor zum Plug-In-Einstellungsteil hinzugefügt. Jetzt können Sie jib: dockerBuild mit mvn package wie unten ausführen.

% mvn package
[INFO] Scanning for projects...
...
[INFO] --- jib-maven-plugin:1.0.0-rc2:dockerBuild (default) @ example-jib ---
[INFO] 
[INFO] Containerizing application to Docker daemon as example-jib...
[INFO] The base image requires auth. Trying again for openjdk:11-jdk-slim...
[INFO] 
[INFO] Container entrypoint set to [java, -Xmx512m, -Xdebug, -cp, /app/resources:/app/classes:/app/libs/*, cn.orz.pascal.example_jib.Main]
...
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  19.345 s
[INFO] Finished at: 2019-01-13T20:07:28-08:00
[INFO] ------------------------------------------------------------------------

Da der "Build" von NetBeans die "Paket" -Phase von Maven aufruft, kann die NetBeans-Seite normalerweise "Build" über das Menü ausführen, ohne ein benutzerdefiniertes Ziel festzulegen.

Docker ausführen: Beginnen Sie mit "Ausführen" von NetBeans

Als nächstes folgt die Ausführung des Containers. Tatsächlich gibt es in Mavens Standardlebenszyklus keine äquivalente Ausführungsphase. Eigentlich führe ich org.codehaus.mojo: exec-maven-plugin: 1.5.0: exec aus, aber da es nur durch direkte Angabe des Ziels ausgeführt wird, wie kann ich dies auf der Maven-Seite einbinden? Ich wusste nicht, ob es getan werden sollte.

Also beschloss Maven, nur die NetBeans-Einstellungen aufzugeben und zu ändern. Bearbeiten Sie die Datei nbactions.xml direkt unter dem Projekt, um Standardaktionen wie "Ausführen" anzupassen.

<?xml version="1.0" encoding="UTF-8"?>
<actions>
    <action>
        <actionName>run</actionName> 
        <goals>
            <goal>docker:start</goal>
        </goals>
    </action>
</actions>

Wenn Sie nun Run from NetBeans ausführen, wird "docker: start" anstelle von "exec: exec" ausgeführt.

Zusammenfassung

Hier ist eine Zusammenfassung, wie Docker, Maven und NetBeans gut in Jib integriert werden können. Wenn Sie in Java entwickeln, ist es etwas bequemer, verschiedene Dinge zu tun, die in die IDE und nicht in die CLI integriert sind. Ich bin froh, dass ich dies tun konnte, da es keinen Sinn für die Integration mit benutzerdefinierten Zielen gibt.

Dieses Mal habe ich CLI-basiertes Java geschrieben, aber es scheint, dass Java EE problemlos mit Jib abgebildet werden kann. Daher möchte ich diesen Bereich beim nächsten Mal untersuchen.

Ich frage mich, ob dies ein Fortschritt für die Verwendung von Docker bei der Arbeit ist.

Dann viel Spaß beim Hacken!