Einrichtung einer einfachen CI/CD-Pipeline mit Github und Jenkins auf einer AWS EC2 Linux-Instanz

von howtoforge · November 10, 2021

In diesem Artikel werden wir uns die Schritte zur Implementierung einer einfachen CI/CD-Pipeline mit Jenkins ansehen. Wir verwenden einen Java-Beispielcode, den wir als .war-Datei auf dem Apache Tomcat Web-Server bereitstellen werden. Wir werden Maven als Build-Tool verwenden. Du findest den Java-Beispielcode in meinem Github Repository (repo). Bevor wir fortfahren, sollten wir die Grundlagen der Tools und Technologien verstehen, die wir für die Einrichtung der CI/CD-Pipeline verwenden werden.

EC2-Instanz: Die EC2-Instanz ist eine virtuelle Maschine (VM) in der AWS Cloud. Wir werden Apache Tomcat und Jenkins auf einer EC2-Instanz bereitstellen.
Apache Tomcat: Apache Tomcat ist ein Open-Source-Web-Server. Wir werden unsere Java-Beispielanwendung in Apache Tomcat als .war-Datei bereitstellen.
Github: Github ist eine Code-Hosting-Plattform. Im Grunde ist es ein Versions- und Quellcodeverwaltungssystem. Wir werden unseren Java-Beispielcode auf Github bereitstellen.
Github Webhook: Github Webhook wird verwendet, um Integrationen zu erstellen und einzurichten. Wir werden einen Webhook erstellen, der einen Jenkins-Job auslöst, sobald ein neuer Commit im Github-Repository stattfindet.
Jenkins: Jenkins ist ein kostenloses Open-Source-Automatisierungstool. Wir werden einen Job für Jenkins schreiben, der eine .war-Datei mit dem Code der Java-Beispielanwendung erstellt und auf dem Apache Tomcat-Server bereitstellt.
Maven:Maven ist ein Build-Automatisierungstool, das hauptsächlich zum Erstellen von Java-Projekten verwendet wird.

Vorraussetzungen

AWS-Konto (Erstelle wenn du noch keines hast)
Grundlegendes Verständnis von Github.
Grundlegendes Verständnis von Jenkins.
Grundlegendes Verständnis von Linux Server und Befehlen

Was werden wir tun?

Eine EC2-Instanz erstellen
Java installieren
Jenkins installieren
Apache Tomcat einrichten
Mein Github Repo forken
Jenkins aufrufen und konfigurieren
Einrichten eines Jenkins-Jobs für das .war-Deployment
Webhook auf dem Github Repo einrichten
Auto Build bei jedem Commit testen

Eine VM oder eine EC2-Instanz erstellen

Um eine EC2-Instanz zu erstellen, kannst du dir das Dokumenthier ansehen.

Hier habe ich eine neue EC2-Instanz in meinem AWS-Konto erstellt. Auf dieser Instanz läuft das Betriebssystem Ubuntu 18.

Du kannst sehen, dass dieInstanzIch werde diese Instanz nutzen, um Java oder die Abhängigkeiten zu installieren und auch Apache Tomcat und Jenkins.

Java installieren

Um Java auf deinem Ubuntu 18 System zu installieren, kannst du die folgenden Befehle verwenden. Mit dem folgenden Befehl wird Java 8 installiert. Nach der Installation kannst du auch die Version überprüfen.

sudo apt-get update
sudo apt install openjdk-8-jdk
java -version

Jenkins installieren

Verwende die folgenden Befehle, um Jenkins auf deiner Instanz zu installieren.

sudo apt-get update
wget -q -O – https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add –
sudo sh -c ‚echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list‘
sudo apt-get update
sudo apt-get install jenkins

Sobald du Jenkins installiert hast, kannst du es mit folgendem Befehl starten und seinen Status überprüfen.

sudo systemctl start jenkins #Jenkins starten
service jenkins status#Jenkins-Status prüfen

Auf dem folgenden Screenshot kannst du sehen, dass der Jenkins-Dienst gestartet wurde. Der Jenkins-Dienst wurde auf Port 8080 gestartet.

Apache Tomcat einrichten

Apache Tomcat installieren

Bevor wir Apache Tomcat herunterladen und installieren, müssen wir ein Verzeichnis erstellen, in das wir das Apache Tomcat-Paket herunterladen können.

Verwende die folgenden Befehle, um ein Verzeichnis in /opt zu erstellen

cd /opt/
sudo mkdir Innovecture

Ändere den Eigentümer des Verzeichnisses mit dem folgenden Befehl. Wir ändern die Eigentümerschaft auf den Benutzer Ubuntu und die Gruppe Ubuntu, damit der Ubuntu-Benutzer den Apache Tomcat-Dienst starten kann und wir keine root- oder user- oder sudo-Rechte verwenden müssen.

sudo chown -R ubuntu:ubuntu Innovecture
cd Innovecture/

Lade Apache Tomcat herunter und entpacke ihn mit den folgenden Befehlen. Wenn du eine andere Version von Apache Tomcat verwenden möchtest, kannst du sie herunterladen und entpacken.

wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.31/bin/apache-tomcat-9.0.31.tar.gz
tar -zxvf apache-tomcat-9.0.31.tar.gz
cd apache-tomcat-9.0.31/

Nimm die erforderlichen Konfigurationen in Apache Tomcat mit dem folgenden Befehl vor. Die folgenden Screenshots zeigen, welche Konfigurationen vorgenommen werden müssen. In den folgenden Konfigurationen weisen wir einen Benutzer und ein Passwort zu, mit denen du dich bei der Manager-Anwendung von Apache Tomcat anmelden kannst. Notiere dir diesen Benutzernamen und das Passwort, da wir diese Anmeldedaten später noch benötigen werden.

Apache Tomcat konfigurieren

vim conf/tomcat-users.xml

Sieh dir den folgenden Screenshot an und vergewissere dich, dass deine context.xml die gleiche Konfiguration enthält.

vim webapps/manager/META-INF/context.xml

Ändere in der Datei server.xml im Verzeichnis conf den Port, auf dem Apache Tomcat läuft, d.h. ändere Port 8080 in 8090, da unser Jenkins-Dienst bereits auf Port 8080 läuft.

vim conf/server.xml

Ändere auch die localhost-Konfiguration in der Datei server.xml mit der IP des Servers, damit dein Server aus dem Internet erreichbar ist.

Apache Tomcat starten

Verwende den folgenden Befehl, um den Apache Tomcat-Dienst zu starten.

bin/startup.sh

Im folgenden Screenshot kannst du sehen, dass der Apache Tomcat Dienst auf Port 8090 und der Jenkins Dienst auf Port 8080 läuft. Um dein System zu überprüfen, verwende den folgenden Befehl.

netstat -tulpn

In der Tomcat Manager App anmelden

Um zu sehen, ob wir uns mit den zuvor angegebenen Anmeldedaten bei der Manager-Anwendung von Apache Tomcat anmelden können, rufe die URL von Apache Tomcat http://IP-of-Apache-Tomcat:8090/manager auf. Du wirst aufgefordert, den Benutzernamen „tomcat-manager“ und das Passwort einzugeben, die wir in conf/tomcat-users.xml konfiguriert haben.

Sobald du dich erfolgreich angemeldet hast, siehst du den folgenden Bildschirm

Github Repo forken

Du kannst mein unten stehendes Repo forken oder klonen. Dieses Repository enthält den Java-Beispielcode. Du kannst entweder diesen Code verwenden oder, wenn du ein eigenes Repository hast, auch dieses.

URL des Repos:https://github.com/shivalkarrahul/Innovecture.git

Jenkins aufrufen und konfigurieren

Um auf Jenkins zuzugreifen, rufe die URL auf http://IP-of-Jenkins:8080.

Folge den angezeigten Bildschirmen, um Jenkin freizuschalten und die vorgeschlagenen Plugins zu installieren

Sobald du Jenkin freigeschaltet und die vorgeschlagenen Plugins installiert hast, siehst du den folgenden Bildschirm.

Du musst den Benutzernamen und das Passwort eingeben, die du konfigurieren musst, und auf Speichern und Weiter klicken, um fortzufahren.

Github-Authentifizierungs-Plugin ohne Neustartinstallieren

Sobald du dich erfolgreich eingeloggt hast, gehst du auf Manage Jenkins > Manage Plugins.Unter dem Verfügbar Registerkarte Suche nach git. Wähle das Plugin „GithubAuthentication“ und klicke auf Installieren ohne Neustart.

Maven-Integrations-Plugin ohne Neustart installieren

Installiere auf die gleiche Weise das Maven Integration Plugin und installiere es ohne Neustart

Installiere das Deploy to container Plugin ohne Neustart

Um das Deployment einer .war-Datei auf Apache Tomcat zu automatisieren, benötigen wir ein „Deploy to container“-Plugin. Installiere das“Deploy tocontainer“ -Plugin auf die gleiche Weise wie das Git- und Maven-Plugin.

Einrichten eines Jenkins-Jobs für das .war-Deployment

Jetzt ist es an der Zeit, einen Freestyle-Job zu erstellen. Gehe zum Haupt-Dashboard und klicke auf Job erstellen. Wähle den Freestyle-Job aus und fahre fort.

Github Repo unter dem Reiter Allgemein hinzufügen

Aktiviere auf der Registerkarte Allgemein das Kontrollkästchen „Github-Projekt“ und füge die URL deines Quellcode-Repos oder die URL des Repos hinzu, das du von meinem Repo geforkt hast.

Github-URL unter Quellcodeverwaltung hinzufügen

Unter der Registerkarte „Quellcodeverwaltung“ klickst du auf das Kontrollkästchen „Git“ und fügst die Repository-URL wie unten gezeigt hinzu. Da mein Repository nicht privat, sondern öffentlich ist, musste ich keine Anmeldedaten hinzufügen.

Wähle den Github-Hook-Trigger

Wähle „GitHub hook trigger for GitSCM polling“ unter der Registerkarte Build Triggers

Build-Schritte hinzufügen

Klicke unter der Build-Umgebung auf „Build-Schritt hinzufügen“ und wähle „Maven-Targets auf oberster Ebene aufrufen“.

Gib für die Ziele clean und package an und speichere den Job.

Build testen

Um zu testen, ob der Job in der Lage ist, unseren Code zu ziehen und zu bauen, klicke auf Jetzt bauen.

Post-Build-Aktionenzum Deployment hinzufügen

Jetzt, da wir sicher sind, dass unser Code gezogen und gebaut wird, können wir eine Post-Build-Aktion hinzufügen. Um eine Post-Build-Aktion hinzuzufügen, klicke auf Post-Build-Aktion unter Build-Umgebung und wähle „Deploy war to a container“.

Füge dann die URL des Tomcat-Servers und die Anmeldedaten hinzu. Um die Zugangsdaten hinzuzufügen, klicke auf „Hinzufügen“, befolge die angezeigten Schritte und speichere den Job.

Manuelle Erstellung testen

Teste nun, ob unser Job in der Lage ist, den Code auf den Apache Tomcat Server zu ziehen, zu bauen und zu verteilen. Klicke auf „Jetzt bauen“, um unseren Job zu testen.

Wie du auf dem obigen Screenshot siehst, war der manuelle Build erfolgreich und wurde auf dem Apache Tomcat Server bereitgestellt.

Um zu testen, ob der War wirklich bereitgestellt wurde, rufe den Apache Tomcathttp://IP-of-Apache-Tomcat:8090/manager um auf die Manager-Anwendung zuzugreifen.

Hier kannst du sehen, dass die Datei web_ex.war erfolgreich auf dem Apache Tomcat Server installiert wurde.

Java-Beispielanwendung testen

Um zu testen, ob die Java-Anwendung läuft, rufe die URLhttp://IP-of-Apache-Tomcat:8090/web_ex.

Webhook im Github Repo einrichten

Einen Webhook erstellen

Um einen Webhook zu erstellen, logge dich in dein Konto ein und befolge die unten stehenden Schritte.

Gehe zu den Einstellungen deines Repo, klicke im linken Panel auf Webhooks und dann auf „Webhook hinzufügen“.

Füge in der Payload URL http://Jenkins-URL:8080/github-webhook hinzu.

Du kannst die Ereignisse auswählen, die diesen Webhook auslösen sollen, oder du wählst „Send me everything“, wenn du den Jenkins-Job bei jedem Ereignis auslösen willst. Klicke auf „Update Webhook“, um ihn zu speichern.

Auto Build bei Commit testen

Jetzt können wir unseren Auto-Build-Job testen.

Um zu testen, ob unser Jenkins-Job den Code bei jedem Commit aus unserem Github-Repository abruft, gibst du die folgenden Befehle ein.

Um das Repo lokal zu klonen, habe ich den folgenden Befehl verwendet. Wenn du dein eigenes Repository hast, gehe einfach auf dein lokales System.

git clone https://github.com/shivalkarrahul/Innovecture.git
cd Innovecture/

Nimm einige Änderungen am Repository vor, damit wir sie pushen können. Hier habe ich lokal eine neue Datei hinzugefügt, die ich in mein Remote-Repository pushen werde

README.md berühren

Um den Benutzernamen und die E-Mail-ID für Git zu konfigurieren, verwende die folgenden Befehle.

git config user.name „Rahul Shivalkar“
git config user.email „rahulshivalkar@rediffmail.com“

Um deine Änderungen zu übertragen und zu pushen, verwende die folgenden Befehle

git commit -m „Test Commit“
git push

Sobald wir unsere Änderungen an das Repository auf Github übertragen, wird unser Jenkins-Job ausgelöst, den wir im Github-Webhook hinzugefügt haben.

Du kannst dies im „Polling Log“ des Jobs sehen, siehe dazu den folgenden Screenshot.

Wenn du die Konsolenausgabe des Jobs aufrufst, siehst du, dass der Job erfolgreich ausgeführt und das War in Apache Tomcat deployed wurde.

Teste erneut

Ändere nun den Code, um zu testen, ob der neueste Code bereitgestellt wird oder nicht. Ich werde die Meldung ändern, die im Browser angezeigt wird.

Wenn du deinen eigenen Bericht verwendest, nimmst du die erforderlichen Änderungen in deinem Code vor. In diesem Fall ändere ich nur die Beispiel-Datei index.jsp, die die Meldung im Browser ausgibt.

vim src/main/webapp/index.jsp

Jetzt wollen wir sehen, ob der geänderte Code übernommen wird oder nicht.

Übertrage die Änderungen, die du an deinem Code vorgenommen hast, mit den folgenden Befehlen.

git add src/main/webapp/index.jsp
git commit -m „Geänderter Code in Hello World New!“
git push

Rufe die Apache Tomcat URLhttp://IP-of-Apache-Tomcat:8090/web_ex um auf unsere Beispielanwendung zuzugreifen.

Du kannst sehen, dass der neueste Code gebaut und auf Apache Tomcat bereitgestellt wurde. Das bedeutet, dass die Anwendung erfolgreich bereitgestellt und die Pipeline erfolgreich ausgelöst wurde.

Wie du siehst, hat mein vorheriger Code nur „Hello World!“ angezeigt. Als ich nun Änderungen an der index.jsp vorgenommen und diese übertragen habe, zeigt die aktuelle Anwendung“Hello World New!“.

Fazit