Tutorial zur Erstellung einer Java-Anwendung in Docker mit Jenkins

Die Einführung neuer Tools wie Jenkins und Docker hat zu einer Steigerung der Produktivität beigetragen. In den letzten Jahren hat sich die Art und Weise, wie wir Software entwickeln, stark verändert. Heutzutage können Entwickler neue Technologien innerhalb weniger Monate erstellen und bereitstellen. In diesem Tutorial werden wir Jenkins in einem Docker-Container einrichten und ein Groovy-Skript verwenden, um eine einfache Java-App zu erstellen und auszuführen.

Wir können das Erstellen, Testen und Bereitstellen von Software mit Hilfe von Tools wie Jenkins automatisieren. Dies erleichtert die kontinuierliche Integration (CI) und die kontinuierliche Bereitstellung (CD). Durch die Aufnahme von laufenden Anwendungen in Docker werden auch mehrere Inkompatibilitätsprobleme gelöst.

1. Unser Ziel: Jenkins in einem Docker-Container einrichten und ein Groovy-Skript zum Erstellen und Ausführen einer einfachen Java-Anwendung verwenden.

In diesem Tutorial werden wir Jenkins in einem Docker-Container einrichten und ein Groovy-Skript verwenden, um eine einfache Java-Anwendung zu erstellen und auszuführen.

Voraussetzungen:

• Grundkenntnisse der Kommandozeile, Git, Java und Maven
• Verständnis von Docker und seinen Befehlen. 
• Eine Java-IDE - In diesem Tutorial werden wir IntelliJ Idea verwenden, aber Sie können jede IDE Ihrer Wahl verwenden 
• Sie können Arbeitsdateien aus unserem Test-Repository herunterladen. https://github.com/joto2itgix/java-hello-world

Erstellen einer Java-Demo-Anwendung:

Das Ziel dieses Tutorials ist es nicht, uns beizubringen, wie man eine Java-App mit Maven erstellt. Daher werden wir das von https://github.com/niwasawa/java-hello-world-with-maven erstellte Beispiel verwenden .

Um eine Java-Anwendung erstellen zu können, benötigen wir eine pom.xml-Datei. Zu Ihrer Erleichterung wurde das Beispiel in das Projektverzeichnis hochgeladen. Unsere pom.xml-Datei sieht wie folgt aus.

<project  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>info.maigo.lab.hello</groupId>
  <artifactId>maigolab_hello</artifactId>
  <packaging>jar</packaging>
  <version>1.0.0</version>
  <name>maigolab_hello</name>
  <url>http://maven.apache.org</url>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.6.0</version>
        <configuration>
          <mainClass>info.maigo.lab.hello.App</mainClass>
          <arguments>
            <argument>niwasawa</argument>
            <argument>maigolab</argument>
          </arguments>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <dependencies>

    <!-- https://mvnrepository.com/artifact/com.mashape.unirest/unirest-java -->
    <dependency>
      <groupId>com.mashape.unirest</groupId>
      <artifactId>unirest-java</artifactId>
      <version>1.4.9</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.json/json -->
    <dependency>
      <groupId>org.json</groupId>
      <artifactId>json</artifactId>
      <version>20170516</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>

</project>

2. Einrichten von Jenkins in Docker

Der erste Schritt besteht darin, ein Docker-Netzwerk zu erstellen:

Durch die Einrichtung eines Netzwerks können wir den Zugriff auf den Jenkins-Container und dessen Verwaltung erleichtern und vereinfachen.

Wenn wir Jenkins in Docker einrichten, müssen wir uns an das Ziel unserer Einrichtung erinnern: Erstellen und Ausführen einer Java-Anwendung mit einem Container. Dazu müssen wir einige Befehle innerhalb des Containers ausführen. Um dies zu tun, müssen wir einige Abhängigkeiten bereitstellen.

Erstellen Sie ein Dockerfile in einem beliebigen Verzeichnis, und fügen Sie in das Dockerfile ein:

FROM jenkins/jenkins:lts

USER root

RUN apt-get update
RUN apt-get 
    --yes --allow-downgrades 
    install 
    curl 
    vim 
    telnet 
    wget 
    maven

RUN java -version

RUN chown -R jenkins /var/jenkins_home

RUN chmod 777 /tmp

Wir werden das offizielle Jenkins-Image aus dem Docker-Hub verwenden und einfache Anwendungen wie maven, wget, telnet und vim installieren. Java wird nicht installiert, da Jenkins auf Java basiert und es bereits mitgeliefert wird.
Jetzt erstellen wir das neue Image.

docker build . -t devops_jenkins:1

Sobald wir den Docker-Build-Prozess angestoßen haben, wird es einige Zeit dauern, bis er abgeschlossen ist.

Sending build context to Docker daemon  3.584kB 
Step 1/6 : FROM jenkins/jenkins:lts 
lts: Pulling from jenkins/jenkins 
647acf3d48c2: Extracting [==============================================>]  51.25MB/54.93MB 
832e288237bc: Download complete 
ea194d1bd1da: Download complete 
98569593b9fd: Download complete 
dfe249e8cdf2: Download complete 
0f6f2e6d37bb: Download complete 
07fcb98649b6: Download complete 
1e33c26b1882: Download complete 
7b24f0e29fe1: Downloading [====================> ]  29.09MB/72.01MB 
4d90ef3a8f3b: Download complete 
d98c8e675bea: Download complete 
b45fc2bf9fd7: Downloading [=> ] 1.617MB/76.39MB 
d6e1fda9effc: Waiting 
3635a44047f2: Pulling fs layer 
486e1776d3bc: Pulling fs layer 
41233d151800: Waiting 
14a67803c2b3: Waiting 


Step 2/6 : USER root 
---> Running in 3311c3136571 
Removing intermediate container 3311c3136571 
---> 82d327b83686
Step 3/7 : RUN apt-get update 
---> Running in 81502814f6c8 
Get:1 http://security.debian.org/debian-security bullseye-security InRelease [44.1 kB] 
Get:2 http://security.debian.org/debian-security bullseye-security/main amd64 Packages [102 kB] 
Get:3 http://deb.debian.org/debian bullseye InRelease [116 kB]
…...


Step 4/7 : RUN apt-get     --yes --allow-downgrades     install     curl     vim     telnet     wget     maven     default-jdk 
---> Running in 6d1151f768c7 
Reading package lists... 
Building dependency tree... 
Reading state information... 
The following additional packages will be installed: 
alsa-topology-conf alsa-ucm-conf at-spi2-core ca-certificates-java dbus 
default-jdk-headless default-jre default-jre-headless fonts-dejavu-extra 
java-common libaopalliance-java libapache-pom-java libapparmor1 libasound2 
libasound2-data libatinject-jsr330-api-java libatk-bridge2.0-0 
libatk-wrapper-java libatk-wrapper-java-jni libatk1.0-0 libatk1.0-data 
libatspi2.0-0 libavahi-client3 libavahi-common-data libavahi-common3 
libcdi-api-java libcommons-cli-java libcommons-io-java libcommons-lang3-java 
libcommons-parent-java libcups2 libcurl4 libdbus-1-3 libdrm-amdgpu1 
libdrm-common libdrm-intel1 libdrm-nouveau2 libdrm-radeon1 libdrm2 libe
….
Step 5/7 : RUN java -version 
---> Running in 74344eed09f2 
openjdk version "11.0.13" 2021-10-19 
OpenJDK Runtime Environment Temurin-11.0.13+8 (build 11.0.13+8)                                                                                                                                                                                                                
OpenJDK 64-Bit Server VM Temurin-11.0.13+8 (build 11.0.13+8, mixed mode)                                                                                                                                                                                                       
Removing intermediate container 74344eed09f2                                                                                                                                                                                                                                   
---> cb41b5bbc3fe 
Step 6/7 : RUN chown -R jenkins /var/jenkins_home 
---> Running in 5bd07d9e37b7 
Removing intermediate container 5bd07d9e37b7 
---> 4e6d6fd447cf 
Step 7/7 : RUN chmod 777 /tmp 
---> Running in ea72a1b2f8d1 
Removing intermediate container ea72a1b2f8d1 
---> 0260f6f8eb8e 
Successfully built 0260f6f8eb8e 
Successfully tagged devops_jenkins:1

Der Prozess durchläuft 3 Hauptschritte:

• Offizielle Jenkins-Image-Cache-Schichten herunterladen
• Zusätzliche Abhängigkeiten installieren
• Berechtigungen von Arbeitsordnern aktualisieren

Nachdem wir das neue Image erfolgreich erstellt haben, können wir es ausführen.

docker run 
    -v /tmp/jenkins/home:/var/jenkins_home 
    --net jenkins --ip 172.68.0.10 
    --detach 
    --name devops_jenkins devops_jenkins:1

Wir führen den Container mit dem neu erstellten Image aus. Zu diesem Zweck verbinden wir ihn mit dem Jenkins-Netzwerk und wählen eine zufällige IP-Adresse aus dem verfügbaren Netzwerkbereich.

Der zweite wichtige Schritt ist die Zuordnung des Jenkins-Home-Ordners. Dadurch geht bei jedem Neustart des Containers kein Fortschritt verloren, den wir gemacht haben.

Sobald der Container ausgeführt wird, können wir mit folgendem Befehl überprüfen, ob er verfügbar ist.

docker container ls 

Mit dem obigen Befehl wird überprüft, ob der Jenkins-Container aktiv ist und läuft.

Der Bootvorgang wird einige Zeit in Anspruch nehmen. Wir können mit dem folgenden Befehl überprüfen, ob der Container ordnungsgemäß gebootet wird:

docker logs devops_jenkins --follow

2022-01-04 13:40:35.372+0000 [id=34]    INFO    jenkins.InitReactorRunner$1#onAttained: Completed initialization 
2022-01-04 13:40:35.604+0000 [id=24]    INFO    hudson.WebAppMain$3#run: Jenkins is fully up and running

3. Erster Lauf

Jetzt können wir in jedem modernen Browser http://172.168.0.10:8080 eingeben. Dieselbe IP, die wir zuvor gewählt haben. 

Wir werden ein paar einfache Seiten für die Erstkonfiguration durchgehen.

• Freischalten. Die erste Aufgabe besteht darin, das Webportal freizuschalten. Dies geschieht durch die Eingabe eines zufällig generierten Passworts, das im Arbeitsordner von jenkins gespeichert ist.

Wenn Sie den gleichen Einhängepunkt wie im Beispiel /var/jenkins_home -> /tmp/jenkins/home wählen, können Sie diesen Befehl verwenden, um den Wert abzurufen.

cat /tmp/jenkins/home/secrets/initialAdminPassword

Fügen Sie es in das Feld "Administrationspasswort" ein und drücken Sie die Eingabetaste.

• Plugins auswählen. Jenkins wird mit allen für unser Ziel benötigten Plugins vorinstalliert. Plugins können immer über das Menü "Einstellungen" installiert werden. Es ist also sicher, einfach auf die Schaltfläche "Vorgeschlagene Plugins installieren" zu klicken.

Und warten Sie auf die Installation aller grundlegenden Plugins.

• Erstellen Sie ein Administratorkonto. Es wird dringend empfohlen, keine einfachen Anmeldedaten zu verwenden, wenn Jenkins öffentlich zugänglich sein soll.

Nachdem wir all diese Schritte abgeschlossen haben, können wir nun Jenkins verwenden.

4. Erster Job in Jenkins

Sobald wir auf die erste Seite weitergeleitet werden, können wir einen neuen Auftrag erstellen. Entweder durch Anklicken dieses Banners oder über das linke Navigationsmenü.

• Erstellen. Zunächst erstellen wir einen Job mit der vordefinierten Groovy-Skriptsprache von Jenkins.
  • Geben Sie in dem neuen Fenster einen beliebigen Namen ein. Wir werden "Build" verwenden, damit klar ist, was das Ziel der Aufgabe ist. 
  • Wählen Sie aus allen Optionen "Pipeline". Dies ist der Auftragstyp, der Groovy-Skripte unterstützt.
  • Und klicken Sie auf OK.

Blättern Sie in den Joboptionen nach unten, wo Sie den Abschnitt "Pipeline" finden, und fügen Sie ihn ein:

pipeline {
    agent any
    stages {
        stage('Clone java repo') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        git branch: "master",
                        url: "https://github.com/joto2itgix/java-hello-world.git"
                    }
                }
            }
        }
        stage('MVN Install') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        sh "mvn compile"
                    }
                }
            }
        }
    }
}

Was ist also die Aufgabe dieses Jobs? Sie ist in zwei Schritte unterteilt, die "Stages" genannt werden:

• Zuerst wird unser Git-Repository in das Arbeitsverzeichnis "${WORKSPACE}" des Jenkins-Jobs heruntergeladen. Sie können die Ausgabe hier sehen /tmp/jenkins/home/workspace/Build
• Führen Sie anschließend "mvn compile" aus, um das Maven-Projekt zu erstellen.

Sie können das Projekt speichern und erstellen, indem Sie im linken Navigationsmenü auf "Jetzt erstellen" klicken.

5. Java-Anwendung testen

Mit den gleichen Schritten wie beim Build-Auftrag können wir einen Auftrag erstellen, der die Anwendung testet.

Wir nennen es "Test" und der Groovy-Code lautet wie folgt:

pipeline {
    agent any
    stages {
        stage('Clone java repo') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        git branch: "master",
                        url: "https://github.com/joto2itgix/java-hello-world.git"
                    }
                }
            }
        }
        stage('MVN Install') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        sh "mvn compile"
                    }
                }
            }
        }
        stage('MVN Test') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        sh "mvn test"
                    }
                }
            }
        }
    }
}

Hier können wir einen zusätzlichen Schritt sehen, der einen weiteren Befehl "mvn test" ausführt. Damit wird der Test ausgeführt, nachdem das Projekt erstellt wurde.

Wie Sie sehen können, sieht der Status der Testpipeline anders aus und enthält einen Schritt mehr.

Wenn Sie das Ergebnis des Testbefehls sehen möchten, fahren Sie mit der Maus über das Listenfeld und klicken Sie auf die Schaltfläche "Logs".

6. Auftrag ausführen

Der letzte zu erstellende Auftrag ist ein Auftrag, der unsere Testanwendung tatsächlich ausführt.

pipeline {
    agent any
    stages {
        stage('Clone java repo') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        git branch: "master",
                        url: "https://github.com/joto2itgix/java-hello-world.git"
                    }
                }
            }
        }
        stage('MVN Install') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        sh "mvn compile"
                    }
                }
            }
        }
        stage('MVN Execute') {
            steps {
                script {
                    dir("${WORKSPACE}") {
                        sh "mvn exec:java"
                    }
                }
            }
        }
    }
}

Der Auftrag sieht dem "Test" sehr ähnlich. Der einzige Unterschied ist der Befehl, der im letzten Schritt ausgeführt wird.

Wir ersetzen "mvn test" durch "mvn exec:java".

Auch hier können wir das Ergebnis im Abschnitt Logs überprüfen.

7. Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir gelernt haben, wie man Jenkins mit Docker einrichtet und ausführt. Außerdem haben wir eine Java-Anwendung erstellt, getestet und ausgeführt, die auf GitHub gehostet wird. Für weitere fachkundige Inhalte und Tutorials besuchen Sie bitte unseren Blog-Bereich. Wenn Sie nicht finden, wonach Sie suchen, kontaktieren Sie uns für eine Beratung zu Ihrem genauen Fall.