Docker erstellt eine Jenkins+Maven-Plattform zum Erstellen und Bereitstellen von Code

Aufgrund der Projektentwicklung ist es häufig erforderlich, einige Umgebungen lokal für die Entwicklung oder Tests einzurichten. Wie wir alle wissen, sind das Einrichten von Umgebungen, das Installieren von Software und die Installation von Middleware sehr mühsam. Die Installation mancher Software kann die Installation anderer Umgebungen erfordern. Beispielsweise erfordert die Installation von rabbitmq zuerst die Erlang-Sprachumgebung. Die Installation eines ganzen Sets ist nicht nur zeitaufwändig, sondern verursacht auch verschiedene Probleme, die den Entwicklungsfortschritt ernsthaft beeinträchtigen. Für Entwickler ist das Leben kurz. Tun Sie alles, um die Entwicklungseffizienz zu verbessern.

Das Aufkommen von Docker ist zweifellos ein Meilenstein für die Technologie-Community. Docker wird von IT-Experten aufgrund seines umfangreichen Anwendungs-Image-Repositorys, seiner Benutzerfreundlichkeit und Portabilität sehr geschätzt. Die Verwendung von Docker zum Bereitstellen oder Installieren entsprechender Anwendungen erfordert keinen zu großen Zeitaufwand für den Installationsvorgang, die Details und die Abhängigkeiten und kann wirklich sofort verwendet werden. In diesem Artikel wird die Erstellung von Jenkins als Beispiel verwendet, um die grundlegenden Betriebsabläufe von Docker zu veranschaulichen: Abrufen von Bildern, Ausführen von Containern, Einbinden von Dateien, Verfolgen von Vorgängen, Herunterfahren von Containern usw. Ich hoffe, dass er für Technikbegeisterte hilfreich ist, die gerade erst mit Docker beginnen.

Grundlegende Konzepte von Docker

Docker ist eine Open-Source-Anwendungscontainer-Engine, die es Entwicklern ermöglicht, ihre Anwendungen und Abhängigkeiten in einen portablen Container zu packen und diesen dann auf allen gängigen Linux-Rechnern zu veröffentlichen. Tatsächlich ist das klassischste Bild von Docker der „Delfin, der Container auf seinem Rücken trägt“, der die Beziehung zwischen der Docker-Engine und dem Container vollständig veranschaulicht.
Die Beherrschung von Images, Containern und Warehouses verschafft Ihnen grundsätzlich ein gutes Verständnis von Docker und ermöglicht Ihnen die korrekte Verwendung von Docker.

• Bild: kann als „Quellcode“ oder .exe Installationsdatei der Anwendung verstanden werden.
• Container: Es ist eine Instanz eines Bildes, nachdem es ausgeführt wurde. Seine Beziehung zum Bild ist genau wie die Beziehung zwischen einem „Objekt“ und einer „Klasse“.
• Warehouse: Ein Warehouse zum Veröffentlichen von Bildern. Verschiedene Bilder (Anwendungen) können aus dem Warehouse heruntergeladen oder abgerufen werden. Docker ist die Engine, die zum Ausführen eines Containers erforderlich ist. Alle Container werden in der Engine ausgeführt.

Docker-Installationsprozess (Centos6.9)

Aktualisieren des Kernels

Centos6.9 muss die Kernelversion aktualisieren, bevor Docker installiert werden kann. Der Aktualisierungsprozess ist wie folgt
1. Schlüssel einführen

rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org 
rpm -Uvh http://www.elrepo.org/elrepo-release-6-8.el6.elrepo.noarch.rpm 

2.yum-Installation

yum --enablerepo=elrepo-kernel -y installiere kernel-lt 

3. Änderung der Bootdatei ( grub.conf )

vim /etc/grub.conf 

Standard auf 0 setzen, Standard=0

4. Neustart

Installieren Sie docker-io

1. EPEL-Quelle installieren

yum installieren http://mirrors.yun-idc.com/epel/6/x86_64/epel-release-6-8.noarch.rpm 

2. Installieren Sie docker-io

yum -y installiere Docker-IO 

3. Starten Sie den Docker-Dienst

Dienst Docker starten

Jenkins-Installation basierend auf Docker

Pull-Anwendung

Bevor Sie den Container/die Instanz ausführen, müssen Sie das entsprechende Image aus dem Docker-Hub-Repository abrufen. Auf der offiziellen Website finden Sie einige Einführungen zum Jenkins-Image, die detaillierte Anweisungen zu Installationsbefehlen, Konfigurationsinformationen und Dateiverzeichnissen enthalten.
Ziehen Sie die neuesten Jenkins aus dem Repository docker pull jenkins und ziehen Sie andere Versionen mit dem Befehl docker pull jenkins:<version>

Ausführen des Containers

Beim Ausführen eines Containers/einer Instanz müssen Sie die Zuordnung der lokalen Ports zum Docker-Container berücksichtigen, damit auf diesen über den lokalen Host zugegriffen werden kann. Da der Container selbst keine Dateien persistent speichert, empfiehlt Docker, keine dateibezogenen Schreibvorgänge im Container durchzuführen. Er wird nur als „Container“ verwendet. Wenn während des Betriebs der Containeranwendung viele wichtige Daten gespeichert oder konfiguriert werden müssen, z. B. MySQL-Datenbankdateien, Jenkins-Plug-Ins, Konfigurationsdateien usw., wird empfohlen, die Containerdateien lokal bereitzustellen, d. h. eine Volume-Zuordnung durchzuführen.

docker run -p 8080:8080 -p 50000:50000 -v /usr/local/docker_volume/jenkins:/var/jenkins_home -v /usr/local/apps/maven-3.3.9:/var/maven_home -v /usr/local/apps/maven-3.3.9/repo:/usr/local/apps/maven-3.3.9/repo --name my_jenkins -d jenkins

Wobei -p für Port-Mapping steht, d. h. die Zuordnung des Ports auf dem lokalen Computer zum Port auf dem Container.
-v bedeutet Dateizuordnung, d. h. der lokale Computer und der Container teilen sich die Zuordnung und mounten die Datei
Hinweis : Da Jenkins zum Erstellen von Maven-Projekten auf Maven-Projekte angewiesen ist, wird das lokale Maven_home beim Ausführen des Containers mit dem Container geteilt. Da der Container während der Ausführung in die lokal freigegebene Datei schreiben muss, ist eine Schreibberechtigung erforderlich. sudo chown -R 1000 sudo chown -R 1000:1000 /usr/local/docker_volume/jenkins sudo chown -R 1000:1000 sudo chown -R 1000:1000

Wenn Sie den obigen Befehl ausführen, wird die Container-ID im Fenster gedruckt. Sie können den laufenden Containerstatus und zugehörige Informationen über docker ps anzeigen.

Verfolgen von Anwendungsprotokollen

Geben Sie docker logs <CONTAINER ID> ein, um das Container-Druckprotokoll zu verfolgen. Wenn Sie Jenkins zum ersten Mal starten, wird das Kennwort im Protokoll gedruckt. Kopieren Sie es und verwenden Sie es, um sich bei Jenkins anzumelden.

Offenen Behälter verschließen

Herunterfahren: docker stop <CONTAINER ID>
Öffnen: docker start <CONTAINER ID>

Tomcat-Kontokonfiguration

In diesem Beispiel wird der von Maven kompilierte War auf dem Remote-Tomcat bereitgestellt. Sie müssen daher die Bereitstellungsberechtigungen in Tomcat festlegen, die Konfigurationsdatei /con/tomcat-users.xml bearbeiten und das Konto hinzufügen

<Rolle Rollenname="Tomcat"/>
<Rolle Rollenname="Administrator"/>
<Rolle Rollenname="admin-gui"/>
<Rolle Rollenname="Manager"/>
<Rolle Rollenname="manager-gui"/>
<Rolle Rollenname="Manager-Skript"/>
<Rolle Rollenname="manager-jmx"/>
<Rolle Rollenname="Manager-Status"/>
<Benutzer Benutzername="admin" Passwort="admin" Rollen="admin,manager,tomcat,manager-gui,manager-script,manager-jmx,manager-status"/>
<Benutzer Benutzername="root" Passwort="admin" Rollen="admin,manager,tomcat,manager-gui,manager-script,manager-jmx,manager-status,admin-gui"/>

Konfigurieren Sie Jenkins zum Erstellen und Bereitstellen von War-Anwendungen

An diesem Punkt können Sie auf die Jenkins-Plattform zugreifen, indem Sie http://本機ip:8080 aufrufen, das Standardinstallations-Plugin auswählen und nach erfolgreicher Installation die Kontoeinstellungen usw. auswählen.

Konfigurieren Sie JDK, Maven und andere Parameter

Fügen Sie die JDK-Installation in „Systemeinstellungen -> Globale Toolkonfiguration“ hinzu, wie unten gezeigt

Installieren Sie das Plugin „Deploy to container Plugin“ zum Bereitstellen von War-Programmen unter „Systemeinstellungen -> Plugins verwalten -> Optionale Plugins“.

Erstellen Sie eine neue Aufgabe zum Erstellen und Bereitstellen

Fügen Sie die SVN-Quellcodeadresse und die Tomcat-Bereitstellungsadresse hinzu

Tomcat-Bereitstellungskonfiguration, konfigurieren Sie das Konto für die Anmeldung bei Tomcat

Stellen Sie das Maven-Projekt über ein SSH-Skript auf dem angegebenen Tomcat bereit

Die Verwendung der oben beschriebenen Methode zum Implementieren der Bereitstellung in der integrierten Bereitstellung von Tomcat beansprucht viel Serverleistung und verursacht häufig Probleme wie einen Speicherüberlauf, was zu einem Bereitstellungsfehler führt. Die Bereitstellungsmethode per SSH-Skript ist wesentlich bequemer und schneller und verbraucht nicht so viel Speicher.

Konfigurieren des Plugins „Publish Over SSH“

Installieren Sie das Plug-In (Publish Over SSH) unter „Systemeinstellungen -> Verwaltungs-Plug-Ins -> Optionale Plug-Ins“ und legen Sie dann die Anmeldeinformationen des zu veröffentlichenden Linux-Servers unter „Systemverwaltung -> Systemeinstellungen -> Publish over SSH“ fest. Die Konfigurationen und ihre spezifischen Bedeutungen sind in der folgenden Abbildung dargestellt. Klicken Sie nach Abschluss der Konfiguration auf die Schaltfläche [Konfiguration testen], um zu testen, ob die Verbindung hergestellt wurde. Wenn „Erfolgreich“ angezeigt wird, bedeutet dies, dass die Konfiguration erfolgreich war.

Schreiben Sie ein Bereitstellungs-SSH-Skript

Speichern Sie das folgende Shell-Skript deploy.sh im Verzeichnis /home/admin/data des Servers und erteilen Sie die Ausführungsberechtigung chomd +x deploy.sh , also im Verzeichnis „ Remote Directory im obigen Diagramm zur SSH-Anmeldekonfiguration. Diese Konfiguration bedeutet, dass Sie, nachdem sich Jenkins beim Linux-Server angemeldet hat, auf dem sich Tomcat befindet, ./deploy.sh verwenden können, um Bereitstellungsvorgänge durchzuführen. Wenn demploy.sh in einem anderen Verzeichnis abgelegt ist, können Sie für die Ausführung den absoluten Pfad /..dir../..dir../deploy.sh verwenden.

#!/bin/bash
# Datei: set ff=unix
#definiert 
export JAVA_HOME=/usr/local/java
#Tomcat-BereitstellungsortTOMCAT_HOME="/home/admin/data/tomcat-jenkins"
# Das Server-Benutzerverzeichnis nach der Anmeldung ist dasselbe wie die in der obigen Abbildung konfigurierte Remote-Verzeichniseinstellung LOGIN_HOME="/home/admin/data"
TOMCAT_PORT=10092
PROJEKT="$1"
#param validieren
wenn [ $# -lt 1 ]; dann
  echo "Sie müssen es wie folgt verwenden: ./deploy.sh <Projektname> [Tomcat-Port] [Tomcat-Home-Verzeichnis]"  
  Ausfahrt
fi
wenn [ "$2" != "" ]; dann
   TOMCAT_PORT=$2
fi
wenn [ "$3" != "" ]; dann
   TOMCAT_HOME="$3"
fi
#Tomcat herunterfahren
#"$TOMCAT_HOME"/bin/shutdown.sh
#echo "Tomcat herunterfahren"
#Tomcat-Prozess prüfen

#tomcat_pid=`/usr/sbin/lsof -n -P -t -i :$TOMCAT_PORT`
tomcat_pid=`ps -ef | grep $TOMCAT_HOME | grep -v 'grep\|tail\|more\|bash\|less'| awk '{print $2}'`
echo "aktuell:" $tomcat_pid
während [ -n "$tomcat_pid" ]
Tun
 Schlaf 5
 tomcat_pid=`ps -ef | grep $TOMCAT_HOME | grep -v 'grep\|tail\|more\|bash\|less'| awk '{print $2}'`
 echo "Tomcat-PID scannen:" $tomcat_pid
 wenn [ -n "$tomcat_pid" ]; dann
   echo "Tomcat töten:" $tomcat_pid
   töten -9 $tomcat_pid
 fi
Erledigt
#Projekt veröffentlichen
echo "scan keine Tomcat-PID, $PROJECT-Veröffentlichung"
rm -rf "$TOMCAT_HOME"/webapps/$PROJECT
cp "$LOGIN_HOME"/war/$PROJECT.war "$TOMCAT_HOME"/webapps/$PROJECT.war
#bak-Projekt
#BAK_DIR=/home/web_as/war/bak/$PROJECT/`Datum +%Y%m%d`
#mkdir -p "$BAK_DIR"
#cp "$TOMCAT_HOME"/webapps/$PROJECT.war "$BAK_DIR"/"$PROJECT"_`date +%H%M%S`.war
#tmp entfernen
rm -rf "$LOGIN_HOME"/war/$PROJECT.war
#Tomcat starten
"$TOMCAT_HOME"/bin/startup.sh
echo "Tomcat wird gestartet. Bitte versuchen Sie, auf die Conslone-URL von $PROJECT zuzugreifen."

Projektbuildkonfiguration

Nachdem Sie die Konfiguration wie unten gezeigt gespeichert haben, können Sie das Maven-Projekt erstellen. Jenkins kopiert das kompilierte War-Projekt in den Tomcat-Pfad, der 192.168.1.12 entspricht, und startet dann Tomcat, um das Projekt bereitzustellen.

Dies ist das Ende dieses Artikels über die Verwendung von Docker zum Erstellen einer Jenkins + Maven-Codeerstellungs- und Bereitstellungsplattform. Weitere verwandte Inhalte zur Verwendung von Docker zum Erstellen von Jenkins + Maven finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!