[Microservice-Bereitstellung] 3. Detaillierte Erläuterung der Schritte zum Packen und Bereitstellen des SpringBoot-Anwendungs-Docker-Images mit dem Jenkins+Maven-Plug-in-Jib

  Zuvor haben wir das K8S+Docker+Maven-Plug-In zum Packen und Bereitstellen von SpringCloud-Microservice-Projekten eingeführt. Im eigentlichen Anwendungsprozess verwenden viele Projekte nicht K8S und Microservices, sondern Docker und SpringBoot. Daher stellen wir es hier vor, wenn Sie möchten Verwenden Sie das Jenkins-Plugin +jib-maven-plugin, um das Docker-Image des SpringBoot-Projekts zu paketieren und bereitzustellen.
  Es gibt eine Vielzahl von Anleitungen für Docker-Paketierungs-Plug-Ins im Internet. Die am häufigsten erläuterte ist die Open-Source-Anweisung von Spotify. Spotify empfiehlt offiziell nicht mehr die Verwendung des Docker-Maven-Plugin-Plug-Ins für die Verpackung, sondern den neuesten Docker-Paket-Plug -in Dockerfile-Maven-Plugin. Das Dockerfile-Maven-Plugin wurde jedoch schon lange nicht mehr aktualisiert und weist auch Einschränkungen in der Verwendung auf. Beispielsweise unterstützt es nur Image-Erstellung, Tag und Push auf dem lokalen Docker .
  Nach dem Vergleich mehrerer Plug-Ins haben wir festgestellt, dass das Open-Source-Jib-Plug-In von Google leistungsfähiger ist. Es kann Docker-Pakete implementieren, ohne eine Docker-Datei zu schreiben, und muss keine Docker-Umgebung lokal installieren. Außerdem wird es ständig aktualisiert, so dass wir Wählen Sie dieses Plug-in als unser Docker. Paketierungs-Plugins.
  Jib erstellt die Docker- und OCI-Images von Java, ohne dass der Docker-Daemon lokal installiert werden muss und es sind auch keine fundierten Kenntnisse der Best Practices von Docker erforderlich. Es ist als Plugin für Maven und Gradle sowie als Java-Bibliothek verfügbar.
  Im Folgenden wird beschrieben, wie Jib (Jib-Maven-Plugin-Plug-In) SpringBoot-Anwendungen in Schichten packt, um Docker-Images zu packen. Dabei wird der Bild-Layer-Wiederverwendungsmechanismus von Docker vollständig genutzt, um das Problem der Netzwerkeinschränkungen zu lösen und viel Speicherplatz zu belegen.
Drei Parameter für den Jib-Build (Jib-Maven-Plugin-Plug-In):

• buildTar: Lokal erstellen, das Image kann ohne Docker-Daemon in eine TAR-Datei generiert und im Zielverzeichnis des Projekts gespeichert werden
• dockerBuild: Speichern Sie das erstellte Image im Docker-Daemon in der aktuellen Umgebung
• Build: Schieben Sie das erstellte Image in ein entferntes Lager, ein offizielles Lager oder ein privates Harbor-Lager

1. Konfigurationsanweisungen für das SpringBoot-Projekt jib-maven-plugin

  Wir verwenden hier hauptsächlich den Befehl buildTar, um die Docker-Image-Datei lokal zu packen und sie dann auf dem Server zu veröffentlichen, damit sie über das Jenkins-Plug-in ausgeführt werden kann. Dadurch entfällt die Notwendigkeit, das private Docker-Image-Warehouse Harbor zu erstellen und zu verwenden.

• Verpackungsbefehl:
  -Dimage kann den Bildnamen und die Version beim Packen anpassen. Dies kann in Jenkins-Skripten verwendet werden. Wenn nicht konfiguriert, werden standardmäßig der in pom.xml konfigurierte Bildname und die Version verwendet. Wenn die Version nicht festgelegt ist, Die Standardversion ist die neueste.

clean package -Ptest -Dimage=gitegg:1.0.1 jib:buildTar -f pom.xml

• Der Docker-Image-Ladebefehl
  „Docker Load“ wird zum Laden des Image-Pakets verwendet, das geladene Image kann jedoch nicht umbenannt werden; Docker-Import wird zum Laden des Containerpakets verwendet, aber beide werden im Image wiederhergestellt, und es kann ein neuer Name für angegeben werden das Image; nach dem Testen kann die vom Plug-in jib-maven-plugin generierte Docker-Imagedatei jib-image.tar nur über Docker Load geladen werden, und OCI kann nicht als Format in der pom.xml-Konfiguration ausgewählt werden (OCI ist wird für K8S verwendet), andernfalls kann es nicht geladen werden.

docker load --input  jib-image.tar

• Der Paketierungsbefehl des Plug-Ins jib-maven-plugin kann an den Lebenszyklus von Maven gebunden werden

                    <executions>
                        <execution>
                            <phase>install</phase>
                            <goals>
                                <goal>build</goal>
                            </goals>
                        </execution>
                    </executions>

• Schieben Sie das Docker-Image in das private Image-Warehouse Harbor. Natürlich ist es hier nicht erforderlich, aber Sie können den Image-Namen und die Image-Version konfigurieren. Wenn Sie den Verpackungsbefehl ausführen, ohne den Parameter -Dimage hinzuzufügen, wird die Konfiguration hier übernommen.

                        <to>
                            <image>私有仓库地址/项目名称/${project.artifactId}:${project.version}</image>
                            <auth>
                                <username>私有仓库用户名</username>
                                <password>私有仓库密码</password>
                            </auth>
                        </to>

• volumes erstellt ein Verzeichnis innerhalb des Containers. Wenn das SpringBoot-Projekt eine benutzerdefinierte Verzeichnisadresse für die Protokollierung usw. erfordert, muss das Verzeichnis innerhalb des Containers hier definiert werden; der eingebettete Tomcat-Container, der von SpringBoot verwendet wird, verwendet standardmäßig /tmp als Arbeitsverzeichnis , und / müssen hier nicht konfiguriert werden. Werte von tmp.

                            <!-- 容器内的目录 -->
                            <volumes>
                                <value>/tmp</value>
                                <value>/log</value>
                            </volumes>

• WorkingDirectory Das Arbeitsverzeichnis im Container. Die beim Start des Containers ausgeführten Befehle werden in diesem Verzeichnis im Container ausgeführt.

<workingDirectory>/gitegg</workingDirectory>

• Format Verwenden Sie OCI, um OCI-Container-Images zu erstellen. Kommentieren Sie es hier direkt aus und verwenden Sie es nicht, da es sonst beim Laden von Docker nicht geladen werden kann, aber in K8S verwendet werden kann, daher wird dieses Format hier nicht verwendet.

 <!--K8S时，使用OCI，单独只用docker load会报错，所以这里不使用这个format-->
<format>OCI</format>

Das Folgende sind die Konfigurationsinformationen des Jib-Maven-Plugin-Plug-Ins von pom.xml im SpringBoot-Projekt:

······
    <properties>
······
        <!-- jib-maven-plugin插件版本，代码打包docker -->
        <jib.maven.plugin.version>3.3.2</jib.maven.plugin.version>
······
    </properties>
······
                <!-- Docker 打包插件 -->
                <plugin>
                    <groupId>com.google.cloud.tools</groupId>
                    <artifactId>jib-maven-plugin</artifactId>
                    <version>${jib.maven.plugin.version}</version>
                    <!-- 绑定到Maven的install生命周期 ，此处如果不使用https，会有问题，需要设置sendCredentialsOverHttp=true-->
                    <executions>
                        <execution>
                            <phase>install</phase>
                            <goals>
                                <goal>build</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <!--允许非https-->
                        <allowInsecureRegistries>true</allowInsecureRegistries>
                        <!-- 相当于Docerkfile中的FROM -->
                        <from>
                            <image>openjdk:11-jre</image>
                        </from>
                        <to>
                            <image>${docker.harbor.addr}/${docker.harbor.project}/${project.artifactId}:${project.version}</image>
                            <auth>
                                <username>${docker.harbor.username}</username>
                                <password>${docker.harbor.password}</password>
                            </auth>
                        </to>
                        <container>
                            <!--jvm内存参数-->
                            <jvmFlags>
                                <jvmFlag>-Xms512m</jvmFlag>
                                <jvmFlag>-Xmx8g</jvmFlag>
                            </jvmFlags>
                            <!-- 容器内的目录-->
                            <volumes>
                                <value>/tmp</value>
                                <value>/log</value>
                            </volumes>
                            <workingDirectory>/gitegg</workingDirectory>
                            <environment>
                                <TZ>Asia/Shanghai</TZ>
                            </environment>
                            <!--使用该参数保证镜像的创建时间与系统时间一致-->
                            <creationTime>USE_CURRENT_TIMESTAMP</creationTime>
                            <!--K8S时，使用OCI，非K8S时，load会报错-->
<!--                            <format>OCI</format>-->
                        </container>
                    </configuration>
                </plugin>

2. Konfiguration der Server-Docker-Betriebsumgebung

  Zuvor haben wir über die Installation von Docker und zugehörigen Konfigurationen gesprochen, daher gehen wir hier nicht auf Details ein. Installieren und konfigurieren Sie Docker einfach entsprechend der tatsächlichen Situation Ihres eigenen Servers. Hier erklären wir, wie Sie die Umgebung für die Ausführung von SpringBoots Fat Jar vorbereiten und erläutern Sie die Übertragung des Bildpakets. Bereitstellungsskript, das nach Erreichen des Servers ausgeführt werden soll.

1. Bereitstellung und Vorbereitung des Sicherungsverzeichnisses

• Erstellen Sie ein neues /opt/tmp-Verzeichnis für Jenkins, um das Paket nach dem Packen über das Publish Over SSH-Plug-in in das temporäre Verzeichnis des Servers zu übertragen.
• Erstellen Sie ein neues Verzeichnis /opt/bak, um alle bereitgestellten Paketsicherungen zu speichern, um das Rollback nachfolgender Versionen zu erleichtern. Dieses Verzeichnis kann viel Platz beanspruchen, daher müssen Sie ein Mount-Verzeichnis mit viel Speicherplatz wählen.
• Erstellen Sie ein neues Verzeichnis /opt/script, das zum Ausführen zugehöriger Befehlsskripts für Installations- und Sicherungsvorgänge verwendet wird, nachdem Jenkins das Paket übertragen hat.
• Erstellen Sie ein neues Verzeichnis /data/container/docker_server/tmp, um das Verzeichnis /tmp im Container zuzuordnen. Das Verzeichnis /tmp ist das Standardlaufverzeichnis des integrierten Tomcat von SpringBoot.
• Erstellen Sie ein neues Verzeichnis /data/container/docker_server/logs, um das Verzeichnis /var/log im Container zuzuordnen. Das Verzeichnis /var/log ist das vom Projekt konfigurierte Protokollspeicherverzeichnis. Nach der Zuordnung zum Host ist es praktisch Protokolle verschiedener Ebenen anzeigen.

mkdir -p /opt/tmp /opt/bak /opt/script /data/container/docker_server/tmp /data/container/docker_server/logs

chmod -R 777 /opt/tmp /opt/bak /opt/script /data/container/docker_server/tmp /data/container/docker_server/logs

2. Anweisungen zum Schreiben von Bereitstellungsskripten

• Definieren Sie Eingabeparameter. Sie können Parameter über Jenkins-Aufgaben an das Skript übergeben. Wir haben die folgenden 5 Parameter definiert:
  Containername=gitegg-server: Containername
  image_name=gitegg-server: Bildname
  version=latest: Bildversion
  image_port=8182: Host Host-Port-Zuordnung
  server_port=8080: Service-Port im Container
• Überprüfen Sie die Parameter, um festzustellen, ob keine Parameter übergeben wurden. Sie können dies anhand Ihrer tatsächlichen Situation beurteilen. Welche Parameter müssen beispielsweise übergeben werden? Stellen Sie die Anzahl der Parameter auf mindestens eine bestimmte Zahl ein.

echo "param validate"
if [ $# -lt 1 ]; then  
  echo "you must use like this : ./publish_docker_server.sh <container_name> <image_name> <version> [image port] [server port]"  
  exit  
fi 

• Zuweisung von Eingabeparametern. Wenn Parameter übergeben werden, werden die Dienstparameter übernommen. Wenn keine Parameter übergeben werden, werden die Standardwerte übernommen.

if [ "$1" != "" ]; then
   container_name="$1"
fi
echo "container_name=" $container_name
if [ "$2" != "" ]; then
   image_name="$2"
fi
if [ "$3" != "" ]; then
   version="$3"
fi
echo "version=" $version
if [ "$4" != "" ]; then
   image_port="$4"
fi
echo "image_port=" $image_port
if [ "$5" != "" ]; then
   server_port="$5"
fi
echo "server_port=" $server_port

• Stoppen und löschen Sie den Container

echo "执行docker ps"
docker ps 
if [[ "$(docker inspect $container_name 2> /dev/null | grep $container_name)" != "" ]]; 
then 
  echo $container_name "容器存在，停止并删除"
  echo "docker stop" $container_name
  docker stop $container_name
  echo "docker rm" $container_name
  docker rm $container_name
else 
  echo $container_name "容器不存在"
fi

• Stoppen Sie und löschen Sie das Bild

# 删除镜像
echo "执行docker images"
docker images
if [[ "$(docker images -q $image_name 2> /dev/null)" != "" ]]; 
then 
  echo $image_name '镜像存在，删除镜像'
  docker rmi $(docker images -q $image_name 2> /dev/null) --force
else 
  echo $image_name '镜像不存在'
fi

• Sichern Sie dieses Installations-Image-Paket

#bak image
echo "bak image" $image_name
BAK_DIR=/opt/bak/docker/$image_name/`date +%Y%m%d`
mkdir -p "$BAK_DIR"
cp "/opt/tmp/jib-image.tar" "$BAK_DIR"/"$image_name"_`date +%H%M%S`.tar

• Führen Sie den Befehl aus, um das Image-Paket zu installieren

echo "docker load" $image_name
docker load --input /opt/tmp/jib-image.tar

• Ausführungsbefehl ausführen

echo "docker run" $image_name
docker run -d -p $image_port:$server_port --name=$container_name --restart=always -v /data/container/docker_server/tmp:/tmp -v /data/container/docker_server/logs:/var/log $image_name

• Löschen Sie die Installationsdateien. Da diese zuvor gesichert wurden, werden die temporären Installationsdateien hier gelöscht.

echo "remove tmp " $image_name
rm -rf /opt/tmp/jib-image.tar

• Abgeschlossene Befehle drucken

echo "Docker Server is starting,please try to access $container_name conslone url"

3. Schließen Sie das Installations- und Bereitstellungsskript ab

container_name=gitegg-server
image_name=gitegg-server
version=latest
image_port=8181
server_port=8080
echo "param validate"
if [ $# -lt 1 ]; then  
  echo "you must use like this : ./publish_docker_server.sh <container_name> <image_name> <version> [image port] [server port]"  
  exit  
fi
if [ "$1" != "" ]; then
   container_name="$1"
fi
echo "container_name=" $container_name
if [ "$2" != "" ]; then
   image_name="$2"
fi
if [ "$3" != "" ]; then
   version="$3"
fi
echo "version=" $version
if [ "$4" != "" ]; then
   image_port="$4"
fi
echo "image_port=" $image_port
if [ "$5" != "" ]; then
   server_port="$5"
fi
echo "server_port=" $server_port

echo "执行docker ps"
docker ps 
if [[ "$(docker inspect $container_name 2> /dev/null | grep $container_name)" != "" ]]; 
then 
  echo $container_name "容器存在，停止并删除"
  echo "docker stop" $container_name
  docker stop $container_name
  echo "docker rm" $container_name
  docker rm $container_name
else 
  echo $container_name "容器不存在"
fi
# 删除镜像
echo "执行docker images"
docker images
if [[ "$(docker images -q $image_name 2> /dev/null)" != "" ]]; 
then 
  echo $image_name '镜像存在，删除镜像'
  docker rmi $(docker images -q $image_name 2> /dev/null) --force
else 
  echo $image_name '镜像不存在'
fi

#bak image
echo "bak image" $image_name
BAK_DIR=/opt/bak/docker/$image_name/`date +%Y%m%d`
mkdir -p "$BAK_DIR"
cp "/opt/tmp/jib-image.tar" "$BAK_DIR"/"$image_name"_`date +%H%M%S`.tar

echo "docker load" $image_name
docker load --input /opt/tmp/jib-image.tar
echo "docker run" $image_name
docker run -d -p $image_port:$server_port --name=$container_name --restart=always -v /data/container/docker_server/tmp:/tmp -v /data/container/docker_server/logs:/var/log $image_name
echo "remove tmp " $image_name
rm -rf /opt/tmp/jib-image.tar

echo "Docker Server is starting,please try to access $container_name conslone url"

3. Erstellen Sie eine neue Jenkins-Konfigurationspaketierungsaufgabe und stellen Sie das Docker-Image des SpringBoot-Projekts bereit

1. Dashboard > Neue Aufgabe erstellen, den Aufgabennamen eingeben, „Maven-Projekt erstellen“ auswählen und auf „OK“ klicken.

2. Projektkonfiguration, rufen Sie die Aufgabenkonfigurationsseite auf

• Alte Builds verwerfen: Geben Sie 5 ein, um die maximale Anzahl der Builds zu behalten. Natürlich können Sie es entsprechend Ihrer eigenen Situation ausfüllen, andernfalls sind die alten Build-Pakete immer vorhanden und belegen Speicherplatz.
  
• Quellcodeverwaltung: Konfigurieren Sie die Git-Code-Adresse, den Benutzernamen und das Kennwort sowie den Versionszweig. Wenn es sich um eine Git-Bibliothek handelt, die einen Benutzernamen und ein Kennwort erfordert, müssen Sie unten den Benutzernamen und das Kennwort für den Zugriff auswählen. Die Methode für Benutzername und Kennwort muss angegeben werden kann hier verwendet werden. Die Token-Methode kann nicht ausgewählt werden. . Sie können es unten hinzufügen oder in den globalen Anmeldeinformationen von Jenkins hinzufügen, um die Verwendung anderer Aufgaben zu erleichtern.
  

• Build-Trigger: Optional oder nicht, Sie können dies entsprechend Ihren eigenen Anforderungen und den Umständen auswählen, unter denen die Aufgabe erstellt werden soll.
  
• Build-Umgebung: Hier ist keine Auswahl erforderlich. Wenn Sie mit der Erstellung eines NodeJS-Projekts beginnen, müssen Sie die NodeJS-Umgebung auswählen.
  
• Erstellen: Geben Sie hier den Maven-Verpackungsbefehl ein. Sie können Parameter hinzufügen, um den Verpackungsumgebungstest oder das Produkt auszuwählen, den Imagenamen und die Version zu definieren usw.

clean package -Dmaven.test.skip=true -Ptest -Dimage=gitegg jib:buildTar -f pom.xml

• Post-Schritte: Senden Sie die gepackte Datei an den Server und führen Sie das festgelegte Skript aus. Wählen Sie hier „Nur ausführen, wenn der Build erfolgreich ist“ und „Posten, wenn der Build erfolgreich ist“ aus.

• Exec-Befehl: Nachdem das Paket für die Umgebung freigegeben wurde, wird der Bereitstellungsskriptbefehl in der Umgebung ausgeführt. „publish_docker_server.sh“ ist eine Skriptdatei. Das erste Gitegg ist der Containername, das zweite Gitegg ist der Imagename, „Latest“ ist die Imageversion, 8181 ist die Host-Portnummer und 8080 ist die Service-Portnummer im Container.

/opt/script/publish_docker_server.sh gitegg gitegg latest 8181 8080

3. Führen Sie die Build-Aufgabe aus

• Jetzt bauen
  

• Sehen Sie sich das Build-Protokoll an: Nachdem Sie auf „Jetzt erstellen“ geklickt haben, wird unten ein Fortschrittsbalken angezeigt. Klicken Sie auf den Fortschrittsbalken, um die Build-Log-Schnittstelle aufzurufen.
  

• Nachdem der Build erfolgreich war, wird unten eine erfolgreiche Build-Eingabeaufforderung angezeigt. Melden Sie sich zu diesem Zeitpunkt beim Remote-Server an, um zu überprüfen, ob die Datei erfolgreich bereitgestellt wurde.
  

4. Nachdem das Docker-Image erfolgreich bereitgestellt wurde, können Sie die folgenden allgemeinen Docker-Befehle verwenden, um den Ausführungsstatus zu überprüfen

• Bild ansehen

docker images

• Sehen Sie, welche Container ausgeführt werden

docker ps

• Behälter stoppen

docker stop 容器id

• Container löschen, Bild löschen

docker rm 容器id
docker rmi 镜像id

• Sehen Sie sich die Ausführungsprotokolle des Containers an

docker logs -f 容器id

• Betreten Sie den Container

docker exec -it 容器id /bin/bash