Aufbau einer CI/CD-Pipeline mit AWS, K8S, Docker, Ansible, Git, Github, Apache Maven und Jenkins

In meinem vorherigen Artikel habe ich mich mit der faszinierenden Welt der Microservices befasst – Microservice-Architekturmuster Teil 1: Zerlegungsmuster . Dies war der Beginn meiner umfassenden Artikelserie über Microservices und ihre Muster.

Obwohl es der logische Schritt wäre, mit Teil 2 dieser Serie fortzufahren, habe ich beschlossen, dass ich als nächstes den entscheidenden Prozess der nahtlosen Bereitstellung dieser Microservices für den Endbenutzer untersuchen und Ihnen erzählen möchte.

Inhaltsübersicht

• Motivation
• [Modul 1]: Virtueller AWS EC2-Server
• [Modul 2]: Jenkins Server
• [Modul 3]: Git und Github
• [Modul 4]: Apache Maven
• [Modul 5]: Docker
• [Modul 6]: Ansible
• [Modul 7]: Kubernetes
• Abschluss
• Über den Autor

Motivation

CI/CD ist eine Technik zur Bereitstellung von Apps für Kunden, die durch die Automatisierung verschiedener Phasen der App-Entwicklung erreicht wird. Ich glaube, dass das Verständnis von CI/CD (Continuous Integration und Continuous Deployment) Entwicklern dabei helfen kann, ein besseres Verständnis dafür zu erlangen, wie Backend-Projektartefakte über die Grenzen des Projekt-Repositorys hinaus existieren. Dieses Verständnis kann auch zu einem grundlegenden Wandel in der Perspektive eines Entwicklers führen. Anstatt ihre Arbeit lediglich als Codezeilen zu betrachten, können sie beginnen, den breiteren Kontext ihres Projekts als wertvolles Produkt zu betrachten.

In diesem Artikel möchten wir den CI/CD-Prozess durch praktische Anwendung entmystifizieren. Wir führen Sie durch ein Schritt-für-Schritt-Tutorial, in dem Sie Modul für Modul aufschlüsseln und eine CI/CD-Pipeline manuell erstellen. Dazu nutzen wir die Leistungsfähigkeit moderner DevOps-Tools wie AWS, Docker, Kubernetes, Ansible, Git, Apache Maven und Jenkins . Also, lasst uns diese Reise beginnen!

[Modul 1]: Virtueller AWS EC2-Server

Dieses Modul ist der Erstellung einer AWS EC2 Virtual Server-Instanz gewidmet. Im Rahmen dieses Artikels richten Sie drei EC2-Instanzen für Jenkins, Ansible und Kubernetes ein. Sie können zunächst mit den nächsten Modulen fortfahren und dieses Modul in den Abschnitten „[Modul 2]: Jenkins“, „[Modul 6]: Ansible“ und „[Modul 7]: Kubernetes“ noch einmal besuchen.

Schritt 1: Erstellen Sie ein AWS-Konto

Gehen Sie zu https://aws.amazon.com.

Klicken Sie auf die Schaltfläche AWS-Konto erstellen .

Befolgen Sie die Anweisungen auf der Webseite zum Erstellen eines Kontos.

Schritt 2: Melden Sie sich bei Ihrem AWS-Konto an

Gehen Sie zu https://console.aws.amazon.com/console/home. Klicken Sie auf die Schaltfläche „Anmelden“ .

Geben Sie auf dieser Webseite alle erforderlichen Anmeldeinformationen ein.

Schritt 3: Suchen Sie den virtuellen EC2-Server

Suchen Sie im Suchfeld nach EC2.

Wählen Sie „EC2 Virtual Server“, indem Sie auf „EC2 Service“ klicken.

Klicken Sie auf die Schaltfläche Instanz starten .

Schritt 4: Konfigurieren Sie den Abschnitt „Name und Tags“.

Gehen Sie zum Abschnitt „Name und Tags“ .

Geben Sie im Abschnitt „Name“ einen Namen für eine neue AWS EC2 Virtual Server-Instanz ein.

Sie können Ihrem virtuellen Server auch zusätzliche Tags hinzufügen, indem Sie auf „Zusätzliche Tags hinzufügen“ klicken.

Schritt 5: Konfigurieren Sie den Abschnitt „Anwendungs- und Betriebssystem-Images (Amazon Machine Image)“.

Gehen Sie zum Abschnitt „Anwendungs- und Betriebssystem-Images (Amazon Machine Image)“ .

Schritt 6: Konfigurieren Sie den Abschnitt „Instanztyp“.

Gehen Sie zum Abschnitt „Instanztyp“ .

Schritt 7: Konfigurieren Sie den Abschnitt „Speicher konfigurieren“.

Gehen Sie zum Abschnitt „Speicher konfigurieren“ .

Schritt 8: Konfigurieren Sie den Abschnitt „Netzwerkeinstellungen“.

Gehen Sie zum Abschnitt „Netzwerkeinstellungen“ .

Sie müssen die Sicherheit Ihres virtuellen Servers einrichten. Um dies zu tun,

1. Klicken Sie auf die Schaltfläche „Sicherheitsgruppe erstellen“ .
2. Fügen Sie den Namen Ihrer neuen Sicherheitsgruppe im Abschnitt „Name der Sicherheitsgruppe“ hinzu.
3. Fügen Sie im Abschnitt „Beschreibung“ eine Beschreibung Ihrer neuen Sicherheitsgruppe hinzu.

Standardmäßig ist Ihr virtueller Server über ( Typ – SSH, Protokoll – TCP, Port – 22 ) zugänglich. Wenn Sie zusätzliche Verbindungstypen benötigen, fügen Sie diese hinzu, indem Sie zusätzliche Regeln für eingehende Sicherheitsgruppen hinzufügen.

Schritt 9: Konfigurieren Sie den Abschnitt „Schlüsselpaar (Anmeldung)“.

Gehen Sie zum Abschnitt „Schlüsselpaar (Login)“ .

Erstellen Sie ein neues Schlüsselpaar, falls Sie es noch nicht erstellt haben.

Wenn Sie noch kein „Schlüsselpaar“ erstellt haben:

1. Klicken Sie auf die Schaltfläche „Neues Schlüsselpaar erstellen“ .
2. Geben Sie Ihrem neuen Schlüsselpaar im Abschnitt „Schlüsselpaarname“ einen Namen.
3. Wählen Sie den Schlüsselpaartyp RSA oder ED25519 aus. Ich wähle den RSA- Typ.
4. Wählen Sie das Dateiformat für den privaten Schlüssel aus. Auswahl zwischen .pem und .ppk . Ich wähle das .pem- Format.
5. Klicken Sie auf die Schaltfläche „Schlüsselpaar erstellen“ .
6. Sie erhalten ein Popup-Fenster, das Sie auffordert, die private Schlüsseldatei herunterzuladen. Stimmen Sie zu und laden Sie die Datei auf Ihren Computer herunter.

Schritt 10: Starten Sie die EC2 Virtual Server-Instanz

Starten Sie die EC2 Virtual Server-Instanz, indem Sie auf die Schaltfläche „Instanz starten“ klicken.

Nach Abschluss des Erstellungsprozesses der EC2 Virtual Server-Instanz sehen Sie Folgendes.

Dann sollten Sie zum Abschnitt „Instanzen“ gehen, indem Sie auf die Schaltfläche „Alle Instanzen anzeigen“ klicken.

Jetzt können Sie sehen, dass Ihre AWS EC2 Virtual Server-Instanz ausgeführt wird.

[Modul 2]: Jenkins Server

Jetzt konfigurieren wir JenkinsServer auf der EC2 Virtual Server-Instanz.

Schritt 1: Erstellen Sie eine AWS EC2 Virtual Server-Instanz

Sie benötigen einen virtuellen Server, um Jenkins auszuführen.

Befolgen Sie die Anweisungen aus [Modul 1]: Abschnitt „AWS EC2 Virtual Server“ dieses Tutorials, um diesen Schritt abzuschließen und eine EC2 Virtual Server-Instanz mit dem Namen JenkinsServer zu erstellen.

Schritt 2: Stellen Sie eine Verbindung zu einer AWS EC2 Virtual Server-Instanz her

Gehen Sie zur Startseite der AWS-Konsole → EC2 Management Console Dashboard → Instanzen.

Dann sollten Sie JenkinsServer auswählen und dann auf die Schaltfläche „Verbinden“ klicken.

Dann sehen Sie diese Webseite. Sie sollten erneut auf die Schaltfläche „Verbinden“ klicken.

Jetzt können Sie das Online-Terminal der virtuellen EC2-Serverinstanz sehen.

Schritt 3: Laden Sie das Jenkins-Repository herunter

Jetzt müssen Sie Jenkins auf Ihre virtuelle EC2-Serverinstanz herunterladen.

Befolgen Sie diese Anweisungen:

1. Gehen Sie zur Jenkins-Download -Webseite .

2. Sie können die Optionen für stabile (LTS) und reguläre Veröffentlichungen (wöchentlich) sehen. Wählen Sie die Option Red Hat/Fedora/Alma/Rocky/CentOS LTS.

   
   

Sie werden diese Webseite sehen.

3. Kopieren Sie den Befehl „sudo get..“ und führen Sie ihn aus, um Jenkins-Dateien aus dem Jenkins-Repository im Internet herunterzuladen und sie am angegebenen Speicherort auf Ihrer virtuellen EC2-Serverinstanz zu speichern.

 sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo

Jetzt wird Jenkins heruntergeladen.

Schritt 4: Jenkins-Schlüssel importieren

Um die Jenkins-Installation abzuschließen, müssen wir den Jenkins-Schlüssel importieren.

Um den Jenkins-Schlüssel zu importieren, müssen wir den Befehl „sudo rpm..“ kopieren und ausführen.

 sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

Schritt 5: Java installieren

Um Jenkins auszuführen, müssen wir Java auf unserer virtuellen EC2-Serverinstanz installieren.

Um Java zu installieren, verwenden Sie diesen Befehl.

 sudo amazon-linux-extras install java-openjdk11 -y

Überprüfen Sie mit diesem Befehl, ob Java korrekt installiert wurde:

 java -version

Sie werden so etwas sehen.

Schritt 6: Fontconfig installieren

Um Jenkins auszuführen, müssen Sie „fontconfig“ auf unserer virtuellen EC2-Serverinstanz installieren.

Verwenden Sie diesen Befehl.

 sudo yum install fontconfig java-11-openjdk -y

Schritt 7: Installieren Sie Jenkins

In früheren Schritten haben Sie Ihre virtuelle EC2-Serverinstanz für die Verwendung eines bestimmten Jenkins-Repositorys konfiguriert und anschließend den mit diesem Repository verknüpften GPG-Schlüssel importiert. Jetzt müssen Sie den Befehl ausführen, der alle bekannten Repositorys durchsucht, einschließlich des von Ihnen hinzugefügten Jenkins-Repositorys, um das Jenkins-Paket zu finden. Sobald das Jenkins-Paket im Jenkins-Repository gefunden wird, wird es heruntergeladen und installiert.

Lassen Sie uns diesen Befehl ausführen.

 sudo yum install jenkins -y

Schritt 8: Starten Sie Jenkins

Mit diesem Befehl können Sie Jenkins starten.

 sudo systemctl start jenkins

Um zu überprüfen, ob Jenkins ausgeführt wird, verwenden Sie diesen Befehl.

 sudo systemctl status jenkins

Sie sehen die Ausgabe wie im Screenshot unten:

Jenkins sollte jetzt betriebsbereit sein.

Schritt 9: Greifen Sie auf Jenkins zu

Um auf die Jenkins-Anwendung zuzugreifen, öffnen Sie einen beliebigen Webbrowser und geben Sie die öffentliche IP-Adresse oder den Domänennamen Ihrer EC2-Instanz gefolgt von Port 8080 ein.

 http://<your-ec2-ip>:8080

Wenn Sie zum ersten Mal auf Jenkins zugreifen, wird es mit einem automatisch generierten Passwort gesperrt.

Sie müssen dieses Passwort mit dem folgenden Befehl anzeigen.

 sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Kopieren Sie dieses Passwort, kehren Sie zu Ihrem Browser zurück, fügen Sie es in das Feld „Administratorpasswort“ ein und klicken Sie auf „Weiter“.

Dann können Sie diese Webseite sehen.

Jetzt können Sie Ihren Jenkins-Server verwenden.

Schritt 10: Erstellen Sie eine neue Jenkins-Pipeline

Da Jenkins nun einwandfrei funktioniert, können Sie mit der Erstellung der Jenkins-Pipeline beginnen. Um eine Jenkins-Pipeline zu erstellen, müssen Sie ein neues „Freestyle-Projekt“ erstellen. Um ein neues „Freestyle-Projekt“ zu erstellen, müssen Sie zum Jenkins-Dashboard gehen und auf die Schaltfläche „Neues Element“ klicken.

Geben Sie den Namen des Github-„Freestyle-Projekts“ ein (der Name „Pipeline“ wird weiterhin verwendet) und klicken Sie dann auf die Schaltfläche „OK“ .

Geben Sie dann die Beschreibung der Pipeline an.

Klicken Sie anschließend auf die Schaltfläche „Übernehmen“ und „Speichern“. Danach bedeutet das, dass Sie das Fundament der Pipeline erstellt haben, die in diesem Tutorial erstellt wird.

[Modul 3]: Git und Github

Da Jenkins nun auf der AWS EC2 Virtual Server-Instanz ausgeführt wird, können Sie Git mit der Pipeline konfigurieren.

Mit Git als beliebtestem Versionskontrollsystem können wir den neuesten Code aus dem Github-Repository Ihres Projekts auf Ihre virtuelle EC2-Serverinstanz übertragen, auf der Ihr Jenkins installiert ist.

Schritt 1: Git installieren

Verwenden Sie diesen Befehl, um Git zu installieren.

 sudo yum install git -y

Überprüfen Sie nun mit diesem Befehl, ob Git funktioniert.

 git --version

Jetzt funktioniert Git einwandfrei auf der EC2 Virtual Server-Instanz.

Schritt 2: Öffnen Sie das Jenkins-Dashboard

Da Git auf der EC2 Virtual Server-Instanz einwandfrei funktioniert, können wir Jenkins jetzt in Git integrieren.

Um diese Integration zu starten, installieren wir das Jenkins Github-Plugin.

Gehen Sie zum Jenkins-Dashboard-Bereich.

Schritt 3: Öffnen Sie den Jenkins Plugin Manager

Klicken Sie auf die Schaltfläche „Jenkins verwalten“ und dann auf die Schaltfläche „Plugins verwalten“ .

Schritt 4: Suchen Sie das Github Jenkins-Plugin

Klicken Sie auf die Schaltfläche „Verfügbare Plugins“ .

Suchen Sie das Suchfeld des Github -Plugins.

Wählen Sie das Github- Plugin aus.

Schritt 5: Installieren Sie das Github Jenkins-Plugin

Wählen Sie das Github- Plugin aus. Klicken Sie anschließend auf die Schaltfläche „Ohne Neustart installieren“ .

Warten Sie, bis der Download des Github-Plugins abgeschlossen ist.

Ja! Das Jenkins Github-Plugin ist installiert.

Schritt 6: Github Jenkins Plugin konfigurieren

Da nun das GitHub Jenkins-Plugin installiert ist, können Sie dieses Plugin so konfigurieren, dass es Jenkins endlich in Git integriert. Dazu müssen Sie zur Hauptseite zurückkehren, indem Sie auf die Schaltfläche „Zurück zur Startseite“ klicken.

Dann müssen Sie auf der Hauptseite auf die Schaltfläche „Jenkins verwalten“ und dann auf die Schaltfläche „Globale Toolkonfiguration“ klicken.

Gehen Sie dann auf der Webseite „Globale Tool-Konfiguration“ zum Abschnitt „Git“.

Im Abschnitt „Git“ müssen Sie Git konfigurieren, indem Sie den Namen und den Pfad zu Git auf dem Computer angeben.

Klicken Sie dann auf die Schaltflächen „Übernehmen“ und „Speichern“ **.**

Hier haben Sie die Konfiguration des Jenkins Github-Plugins abgeschlossen.

Schritt 7: Git in die Pipeline integrieren

Da das Jenkins Github-Plugin nun installiert und konfiguriert ist, können Sie dieses Plugin nun in Ihrer Pipeline verwenden. Dadurch kann Ihre Pipeline, die Sie in Modul 2 erstellt haben, Ihren Projektcode aus dem angegebenen GitHub-Repository abrufen.

Nun, um dieses Plugin in Ihre Pipeline zu integrieren, müssen Sie zum Abschnitt „Quellcodeverwaltung“ gehen und Git in Ihrer Pipeline auswählen. Anschließend müssen Sie die URL Ihres Projekt-Repositorys angeben. Wenn Ihr Projekt-Repository auf Github öffentlich ist, müssen Sie keine Anmeldeinformationen angeben. Wenn das Projekt-Repository auf Github privat ist, müssen Sie Anmeldeinformationen angeben.

Sie können mein Projekt mit der nächsten Repositiry-URL verwenden: https://github.com/Sunagatov/Hello.git .

Kopieren Sie es einfach und fügen Sie es in die Eingabe „ Repository-URL“ ein. Klicken Sie dann auf die Schaltflächen „Übernehmen“ und „Speichern“ , um die Integration von Git mit der Pipeline abzuschließen.

Schritt 8: Testen Sie Git, das in die Pipeline integriert ist

Jetzt können Sie Ihre aktualisierte Pipeline verwenden, um ein Projekt von Github abzurufen. Dazu müssen Sie auf die Schaltfläche **„Jetzt erstellen“** klicken. Als Ergebnis sehen Sie einen erfolgreichen Build im Build-Verlauf.

Öffnen Sie den ersten Build aus dem Build-Verlauf.

Jetzt können Sie das erfolgreiche Jobergebnis des ersten Builds sehen. Wenn Sie Ihr AWS EC2-Terminal öffnen. Sie können überprüfen, ob die Pipeline ordnungsgemäß funktioniert.

Verwenden Sie einfach diesen Befehl.

 cd /var/lib/jenkins/workspace/{your pipeline name}

Auf diese Weise können Sie sehen, dass Ihr Projekt von Github auf Ihre virtuelle AWS EC2-Serverinstanz übertragen wurde.

[Modul 4]: Apache Maven

Nachdem Sie Git nun in die Pipeline integriert haben, können Sie die Pipeline durch die Einbindung von Apache Maven weiter verbessern, wodurch Sie Ihr Projekt erstellen, testen und verpacken können. Dazu müssen Sie Apache Maven auf Ihrer AWS EC2 Virtual Server-Instanz installieren, auf der Jenkins und Git installiert wurden.

Schritt 1: Laden Sie Apache Maven herunter

Um Apache Maven herunterzuladen, gehen Sie in das Verzeichnis „/opt“ .

 cd /opt

Und dann verwenden Sie diesen Befehl.

 sudo wget https://dlcdn.apache.org/maven/maven-3/3.9.4/binaries/apache-maven-3.9.4-bin.tar.gz

Dieser Befehl lädt den neuesten offiziellen Apache Maven herunter (überprüfen Sie die neueste Version auf der offiziellen Apache Maven-Website). Um die neueste offizielle Apache Maven-Version zu finden, verwenden Sie den Link https://maven.apache.org/download.cgi .

Schritt 2: Extrahieren Sie Apache Maven aus dem Archiv

Verwenden Sie diesen Befehl, um Apache Maven aus dem heruntergeladenen Archiv zu extrahieren:

 sudo tar -xvzf apache-maven-*.tar.gz

Schritt 3: Fügen Sie JAVA_HOME und M2_HOME hinzu

Wechseln Sie mit diesem Befehl in den Stammordner.

 cd ~

Bearbeiten Sie die Datei .bash_profile mit diesem Befehl.

 vi .bash_profile

Fügen Sie die Variablen JAVA_HOME und M2_HOME hinzu.

Weisen Sie den Pfad zu JDK11 für JAVA_HOME und den Pfad zum Maven-Verzeichnis für die Variable M2_HOME zu.

Verwenden Sie diesen Befehl, um den JDK-Pfad zu finden.

 sudo find / -name java 

Speichern Sie die Änderungen.

Führen Sie dann diesen Befehl aus, um die Systemvariablen zu aktualisieren.

 source .bash_profile

Verwenden Sie diesen Befehl, um $PATH zu überprüfen.

 echo $PATH

Verwenden Sie diesen Befehl, um Apache Maven zu überprüfen.

 mvn -v

Wenn Sie alles richtig gemacht haben, können Sie die Version von Apache Maven anzeigen.

Schritt 4: Installieren Sie das Apache Maven Jenkins-Plugin

Da Apache Maven auf einer EC2-Instanz verwendet werden kann, können Sie das Apache Maven-Plugin installieren, um es in die Pipeline zu integrieren.

Um dies zu erreichen, gehen Sie folgendermaßen vor:

1. Navigieren Sie zu „Dashboard“ → „Jenkins verwalten“ → „Plugins verwalten“ → „Verfügbar“.
2. Geben Sie im Suchfeld „Maven“ ein.
3. Wählen Sie das Plugin „Maven Integration“ .

Warten Sie, bis der Downloadvorgang abgeschlossen ist.

Klicken Sie anschließend auf die Schaltfläche „Zurück zur Startseite“ .

Schritt 5: Konfigurieren Sie das Apache Maven Jenkins-Plugin

Mit der erfolgreichen Installation des Apache Maven Jenkins-Plugins können Sie dieses Plugin nun innerhalb der Pipeline verwenden, die Sie in den Modulen 2 und 3 erstellt und aktualisiert haben.

Gehen Sie dazu folgendermaßen vor:

1. Gehen Sie zu „Dashboard“ → „Jenkins verwalten“ → „Global Tool Coonfiguration“ → „JDK“
2. Klicken Sie auf die Schaltfläche „JDK hinzufügen“.
3. Deaktivieren Sie „Automatisch installieren“.

Gehen Sie dann zum Abschnitt „Maven“ . Klicken Sie auf die Schaltfläche „Maven hinzufügen“ . Deaktivieren Sie „Automatisch installieren“.

Fügen Sie dann den Namen und den MAVEN_HOME -Pfad hinzu.

Klicken Sie auf die Schaltflächen „Übernehmen“ und „Speichern“ .

Hier haben Sie die Konfiguration des Apache Maven Jenkins-Plugins abgeschlossen.

Schritt 6: Integrieren Sie Apache Maven in die Pipeline

Da das Apache Maven GitHub-Plugin nun installiert und konfiguriert ist, können Sie Apache Maven in Ihrer Pipeline verwenden. Dadurch kann Ihre Pipeline, die Sie im „[Modul 2]: Jenkins Server“ erstellt haben, Ihren Projektcode erstellen, um ein JAR-Artefakt zu erstellen.

Um Apache Maven in die Pipeline zu integrieren, müssen Sie die folgenden Schritte ausführen:

1. Navigieren Sie zu „Dashboard“ → „CI_CD_Pipeline“ → „Konfigurieren“ → „Build Steps“.
2. Klicken Sie auf die Schaltfläche „Build-Schritt hinzufügen“ .
3. Wählen Sie die Option „Maven-Ziele der obersten Ebene aufrufen“ .
4. Wählen Sie „Apache-Maven“ als „Maven-Version“.
5. Fügen Sie den Befehl „Paket bereinigen“ zur Eingabe „Ziele“ hinzu.
6. Klicken Sie auf die Schaltfläche „Erweitert“ .
7. Fügen Sie „pom.xml“ zur „POM“ -Eingabe hinzu.

Abschließend sollten Sie auf die Schaltflächen „Übernehmen“ und „Speichern“ klicken, um die Integration von Apache Maven in die Pipeline abzuschließen.

Schritt 7: Testen Sie den in die Pipeline integrierten Apache Maven

Jetzt können Sie Ihre aktualisierte Pipeline zum Erstellen Ihres Github-Projekts verwenden. Dazu müssen Sie auf die Schaltfläche **„Jetzt erstellen“** klicken. Als Ergebnis sehen Sie im Build-Verlauf ein erfolgreiches Jobergebnis.

Wenn Sie Ihr AWS EC2-Terminal öffnen. Sie können überprüfen, ob die Pipeline ordnungsgemäß funktioniert.

Verwenden Sie einfach diesen Befehl.

 cd /var/lib/jenkins/workspace/{your pipeline name}/target

Auf diese Weise können Sie das JAR-Artefakt sehen, das den erfolgreichen Build Ihres Projekts von GitHub anzeigt.

[Modul 5]: Docker

Erstellen wir nun eine neue EC2-Instanz mit dem Namen „Ansible Server“, auf der Sie Docker und Ansible installieren.

Schritt 1: Starten Sie eine AWS EC2 Virtual Server-Instanz

Befolgen Sie die Anweisungen im Abschnitt „ Starten einer AWS EC2 Virtual Server-Instanz“ dieses Tutorials, um diesen Schritt abzuschließen. Vergessen Sie nicht, ein Sicherheitsgruppen-Setup hinzuzufügen. Dadurch können Docker und SSH an den Ports 8080 bzw. 22 arbeiten.

Schritt 2: Stellen Sie eine Verbindung zu einer AWS EC2 Virtual Server-Instanz her

Klicken Sie auf die Schaltfläche „Verbinden“.

Jetzt können Sie das Online-Terminal der EC2 Virtual Server-Instanz sehen.

 sudo chown ansible-admin:ansible-admin /opt/docker

Schritt 3: Installieren Sie Docker auf dem virtuellen Ansible EC2-Server.

Jetzt müssen Sie Docker auf Ihrer Ansible EC2-Instanz installieren. Dazu müssen Sie einen neuen Docker-Ordner erstellen.

 sudo mkdir /opt/docker

Installieren Sie dann Docker, indem Sie den nächsten Befehl ausführen.

 sudo yum install docker -y

Schritt 4: Aktuellen Benutzer zur Docker-Gruppe auf dem virtuellen Ansible EC2-Server hinzufügen

Sie müssen den aktuellen Benutzer „ansible-admin“ zur Docker-Gruppe auf dem virtuellen EC2-Server „AnsibleServer“ hinzufügen, um Docker-Administratorrechte zu erteilen.

 sudo usermod -a -G docker ansible-admin

Damit diese Änderungen wirksam werden, müssen Sie sich abmelden und erneut anmelden.

Anschließend können Sie den nächsten Befehl ausführen

 id ansible-admin

um zu sehen, dass der neue Docker-Benutzer existiert.

Schritt 5: Starten Sie Docker

Da Docker nun auf der Ansible EC2-Instanz installiert ist, können Sie es starten, indem Sie den nächsten Befehl ausführen.

 sudo systemctl start docker

Sobald Docker gestartet ist, können Sie den nächsten Befehl ausführen

 sudo systemctl status docker

um zu sehen, dass Docker jetzt aktiv ist und ausgeführt wird.

Schritt 6: Docker-Datei erstellen

In der endgültigen Version der Pipeline umfasst der Prozess die Erstellung eines neuen Docker-Images aus Ihrem GitHub-Projekt und dessen Übertragung an Docker Hub. Um dies zu erreichen, sollte Ihr GitHub-Projekt eine Docker-Datei enthalten.

Wenn Sie das Projekt „Hello“ verwendet haben, das im Modul „ [Modul 3]: Git und Github“ angeboten wurde, müssen Sie kein neues Dockerfile erstellen, da dieses Projekt-Repository bereits Dockerfile enthält.

 FROM eclipse-temurin:17-jre-jammy ENV HOME=/opt/app WORKDIR $HOME ADD hello-0.0.1-SNAPSHOT.jar $HOME ENTRYPOINT ["java", "-jar", "/opt/app/hello-0.0.1-SNAPSHOT.jar" ]

Wenn Sie Ihr eigenes Projekt-Repository verwendet haben und dieses keine Docker-Datei enthielt, müssen Sie eine neue Docker-Datei erstellen.

Um eine neue Docker-Datei zu erstellen, führen Sie den folgenden Befehl aus, wodurch die neue Datei erstellt wird.

 sudo touch Dockerfile

Anschließend können Sie diese Datei mit einer Befehlsfolge füllen, die beschreibt, wie eine containerisierte Anwendungsumgebung erstellt wird. Zu diesen Befehlen gehören Aktionen wie das Kopieren von Dateien in das Image, das Installieren von Software, das Festlegen von Umgebungsvariablen und das Konfigurieren des Containers.

Um die Docker-Datei mit diesen Befehlen zu füllen, führen Sie den folgenden Befehl aus.

 vim Dockerfile

Die Docker-Datei ist einsatzbereit.

Schritt 7: Melden Sie sich bei Docker an

Nachdem Ihre Docker-Datei nun für die Verwendung vorbereitet ist, kopieren Sie das JAR-Artefakt Ihres Projekts von der EC2-Instanz „JenkinsServer“ und fügen es in die EC2-Instanz „AnsibleServer“ ein. Es ist wichtig zu beachten, dass diese Übertragung durch die Pipeline weiter automatisiert wird.

Wenn Sie diesen Schritt abschließen, können Sie Ihre Docker-Datei zusammen mit der von Ihnen eingerichteten Docker-Umgebung testen.

Bevor Sie mit dem Testen beginnen, stellen Sie sicher, dass Sie sich bei Dockerhub authentifizieren. Führen Sie den folgenden Befehl aus.

 docker login

Mit diesem Befehl werden Sie aufgefordert, Ihre Dockerhub-Anmeldeinformationen anzugeben, einschließlich Ihres Benutzernamens und Passworts.

Damit haben Sie den Anmeldevorgang bei Docker abgeschlossen und können nun mit dem Testen fortfahren.

Schritt 8: Testen der Docker-Umgebung und Dockerfile

Nachdem Sie sich erfolgreich bei Dockerhub angemeldet haben, können Sie nun mit dem Testen der von Ihnen vorbereiteten Docker-Datei beginnen.

Führen Sie diesen Befehl aus, um ein Docker-Image zu erstellen.

 docker build -t hello:latest .

Führen Sie als Nächstes den folgenden Befehl aus, um ein Tag einzurichten, das das Hochladen des Bildes auf Dockerhub erleichtert:

 docker tag hello:latest zufarexplainedit/hello:latest

Fahren Sie abschließend damit fort, das Docker-Image durch die Ausführung dieses Befehls an Dockerhub zu übertragen.

 docker push zufarexplainedit/hello:latest

Navigieren Sie nach diesen Schritten zu Ihrem Dockerhub-Konto, um zu überprüfen, ob Sie ein neues Bild sehen können oder nicht.

Sie sollten nun feststellen, dass das Bild effektiv hinzugefügt wurde. Dieses Ergebnis bestätigt die erfolgreiche Installation der Docker-Umgebung und dass Ihre Docker-Datei korrekt ist.

[Modul 6]: Ansible

Lassen Sie uns nun den Ansible Server auf der EC2 Virtual Server-Instanz konfigurieren.

Schritt 1: Erstellen Sie eine AWS EC2 Virtual Server-Instanz

Sie benötigen einen virtuellen Server, um Ansible auszuführen.

Befolgen Sie die Anweisungen aus [Modul 1]: Abschnitt „AWS EC2 Virtual Server“ dieses Tutorials, um diesen Schritt abzuschließen und eine EC2 Virtual Server-Instanz für Ansible zu erstellen.

Schritt 2: Stellen Sie eine Verbindung zu einer AWS EC2 Virtual Server-Instanz her

Gehen Sie zur Startseite der AWS-Konsole → EC2 Management Console Dashboard → Instanzen → AnsibleServer.

Klicken Sie dann auf die Schaltfläche „Verbinden“ .

Dann sehen Sie diese Webseite. Sie sollten erneut auf die Schaltfläche „Verbinden“ klicken.

Jetzt können Sie das Online-Terminal der virtuellen EC2-Serverinstanz sehen.

Jetzt konfigurieren wir Ansible Server auf der virtuellen EC2-Serverinstanz.

Schritt 3: Ändern Sie den Hostnamen der AWS EC2 Virtual Server-Instanz „AnsibleServer“.

Wenn Sie AnsibleServer auf einer virtuellen EC2-Serverinstanz konfigurieren möchten, müssen Sie zunächst den Hostnamen ändern.

Lass es uns tun. Führen Sie diesen Befehl aus, um die Hostnamendatei zu öffnen:

 sudo vi /etc/hostname

Sie sollten etwa Folgendes sehen:

Ersetzen Sie diesen Hostnamen durch „ansible-server“. Starten Sie es dann neu.

 sudo init 6 

Schritt 4: Fügen Sie einen neuen Benutzer in der AWS EC2 Virtual Server-Instanz „AnsibleServer“ hinzu und konfigurieren Sie ihn

Fügen wir nun einen neuen Ansible-Admin- Benutzer zur AWS EC2 Virtual Server-Instanz hinzu.

Verwenden Sie dazu diesen Befehl:

 sudo useradd ansible-admin

Legen Sie dann das Passwort für den Benutzer „ansible-admin“ fest.

 sudo passwd ansible-admin

Außerdem müssen Sie Benutzerrechte konfigurieren, indem Sie die sudoers- Datei bearbeiten.

 sudo visudo

Fügen Sie „ansible-admin ALL=(ALL) ALL“ zu dieser Sudoers- Datei hinzu.

Außerdem müssen Sie die Datei /etc/ssh/sshd_config bearbeiten, um PasswordAuthentication zu aktivieren.

 sudo vi /etc/ssh/sshd_config 

Anschließend müssen Sie den Dienst neu laden, um diese Änderungen zu bestätigen.

 sudo service sshd reload

Als Ergebnis der Ausführung dieses Befehls sehen Sie:

 sudo su - ansible-admin

Schritt 5: Schlüssel in einer AWS EC2 Virtual Server-Instanz generieren

Im weiteren Verlauf dieses Artikels planen Sie die Verwaltung von Remote-Servern wie den virtuellen EC2-Serverinstanzen von K8. Aus diesem Grund müssen Sie SSH-Schlüssel einrichten.

 ssh-keygen

Als Ergebnis der Ausführung dieses Befehls sehen Sie:

Jetzt sind SSH-Schlüssel generiert und einsatzbereit.

Schritt 6: Ansible installieren

Jetzt können Sie Ansible auf Ihrer virtuellen EC2-Serverinstanz „AnsibleServer“ installieren.

Lass es uns tun.

Führen Sie diesen Befehl aus, um Ansible zu installieren.

 sudo amazon-linux-extras install ansible2

Um Ansible zu überprüfen, verwenden Sie diesen Befehl:

 ansible --version

Als Ergebnis der Ausführung dieses Befehls sehen Sie:

Schritt 7: Installieren Sie das Jenkins-Plugin „Publish over SSH“ auf der JenkinsServer EC2-Instanz

Da Ansible auf Ihrer virtuellen EC2-Serverinstanz „AnsibleServer“ installiert ist, können Sie Jenkins für die Integration mit Ansible konfigurieren. Sie müssen das Plugin „Publish over SSH“ installieren, um Jenkins mit der EC2 Virtual Server-Instanz zu integrieren, auf der Ansible installiert ist, und mit anderen EC2 Virtual Server-Instanzen, auf denen Kubernetes installiert ist.

Gehen Sie zu „Dashboard“ → „ Jenkins verwalten“ → „System konfigurieren“ → „Verfügbare Plugins“ .

Geben Sie dann „Publish over SSH“ in das Suchfeld ein.

Klicken Sie auf die Schaltfläche „Ohne Neustart installieren“ . Warten Sie, bis der Downloadvorgang abgeschlossen ist.

Jetzt ist das Plugin „Publish over SSH“ auf der Jenkins EC2 Virtual Server-Instanz installiert.

Schritt 8: Konfigurieren Sie das Jenkins-Plugin „Publish over SSH“.

Mit der erfolgreichen Installation des Apache Maven Jenkins-Plugins können Sie dieses Plugin nun innerhalb der Pipeline verwenden, die Sie in den Modulen 2 und 3 erstellt und aktualisiert haben.

Gehen Sie dazu folgendermaßen vor:

Gehen Sie zu „Dashboard“ → „Jenkins verwalten“ → „System konfigurieren“ → „Über SSH veröffentlichen“ .

Geben Sie alle erforderlichen Daten wie auf dem Screenshot ein, einschließlich Hostname, Benutzername und privatem Schlüssel (oder ggf. Passwort).

Klicken Sie dann auf die Schaltflächen „Übernehmen“ und „Speichern“ .

Hier haben Sie die Konfiguration des Jenkins-Plugins „Publish over SSH“ abgeschlossen.

Klicken Sie anschließend auf „Konfiguration testen“, um zu überprüfen, ob das Plugin ordnungsgemäß funktioniert.

Auf der linken Seite sehen Sie, dass der Konfigurationsstatus des Test-Plugins „Erfolgreich“ lautet. Dies bedeutet, dass die Plugin-Konfiguration korrekt ist.

Schritt 9: Erstellen Sie ein neues Docker-Verzeichnis in AnsibleServer

Sie müssen einen neuen Ordner auf der AnsibleServer EC2-Instanz erstellen, in dem die Projekt-JAR gespeichert wird. Dieses JAR wird später zum Erstellen eines Docker-Images verwendet.

Lasst uns beginnen.

Gehen Sie zum Ordner „/opt“ in der AnsibleServer EC2-Instanz.

 cd /opt

Erstellen Sie dort einen neuen Ordner „Docker“ .

 sudo mkdir docker

Erteilen Sie diesem „Docker“ -Ordner Berechtigungen.

 sudo chown ansible-admin:ansible-admin docker

Überprüfen Sie nun die Berechtigungen des Ordners „Docker“ , indem Sie diesen Befehl ausführen.

 ll

Sie können sehen, dass der Ordner „docker“ mit dem Benutzer „ansible-admin“ zugänglich ist.

Schritt 10: Integrieren Sie das Github-Plugin „Publish over SSH“ in die Pipeline

Nachdem das Github-Plugin „Publish over SSH“ installiert und konfiguriert ist, können Sie es nun in die Pipeline integrieren, die Sie im „[Modul 2]: Jenkins Server“ erstellt haben, um ein Projekt-JAR-Artefakt von „ JenkinsServer“ nach zu übertragen „AnsibleServer“ .

Um das Github-Plugin „Publish over SSH“ in die Pipeline zu integrieren, müssen Sie die folgenden Schritte ausführen:

1. Navigieren Sie zu „Dashboard“ → „CI_CD_Pipeline“ → „Konfigurieren“ → „Post-Build-Aktionen“.
2. Klicken Sie auf die Schaltfläche „Post-Build-Aktion hinzufügen“ .
3. Wählen Sie die Option „Build-Artefakte über SSH senden“ .
4. Fügen Sie „AnsibleServer“ zur Eingabe „Name“ im Abschnitt „SSH-Server“ hinzu**.**
5. Fügen Sie „target/*.jar“ zur Eingabe „Quelldateien“ im Abschnitt „Übertragungssatz“ hinzu**.**
6. Fügen Sie „target/“ zur Eingabe „Präfix entfernen“ im Abschnitt „Übertragungssatz“ hinzu**.**
7. Fügen Sie „//opt/docker/“ zur Eingabe „Remote-Verzeichnis“ im Abschnitt „Transfer Set“ hinzu**.**
8. Geben Sie vorerst einfach eine leere Zeichenfolge in die Eingabe „Exec-Befehl“ im Abschnitt „Übertragungssatz“ ein.

Abschließend sollten Sie auf die Schaltflächen „Übernehmen“ und „Speichern“ klicken, um die Integration des „Publish over SSH“ -Plugins mit der Pipeline abzuschließen.

Schritt 11: Testen Sie das in die Pipeline integrierte Github-Plugin „Publish over SSH“.

Jetzt können Sie Ihre aktualisierte Pipeline verwenden, um ein Projekt-JAR-Artefakt von „ JenkinsServer“ nach „AnsibleServer“ zu übertragen. Dazu müssen Sie auf die Schaltfläche „Jetzt erstellen“ klicken. Als Ergebnis sehen Sie in der Build-Historie ein erfolgreiches Jobergebnis.

Wenn Sie Ihr AWS EC2-Terminal „AnsibleServer“ öffnen. Sie können überprüfen, ob die Pipeline ordnungsgemäß funktioniert.

Verwenden Sie einfach diesen Befehl.

 cd /opt/docker

Auf diese Weise können Sie das JAR-Artefakt sehen, das den erfolgreichen Build Ihres Projekts von GitHub anzeigt.

Schritt 12: Ansible-Hosts konfigurieren

Wenn Sie ein Ansible-Playbook ausführen, geben Sie die Hosts an, auf denen es ausgeführt werden soll. Sie können dies auf zwei Arten tun:

1. Geben Sie Hosts direkt im Playbook an: In Ihrem Playbook können Sie den Parameter hosts auf eine Liste von IP-Adressen oder Hostnamen festlegen.
2. Verwenden Sie eine Inventardatei: Mit Ansible können Sie eine Liste von Hosts in einer Inventardatei definieren und auf diese Datei verweisen, wenn Sie Ihr Playbook ausführen. Die Standardinventardatei ist /etc/ansible/hosts .

Durch Bearbeiten von /etc/ansible/hosts können Sie Gruppen von Hosts einfach verwalten, ohne deren IP-Adressen jedes Mal ausschreiben zu müssen, wenn Sie ein Playbook ausführen.

Lassen Sie uns den AnsibleServer EC2-Instanzhost ermitteln, indem wir den folgenden Befehl ausführen.

 sudo ifconfig 

Nachdem Sie den AnsibleServer EC2-Instanzhost ermittelt haben, können Sie ihn der Ansible-Hosts-Datei hinzufügen, indem Sie den folgenden Befehl ausführen.

 sudo vi /etc/ansible/hosts

Sie können auch „[ansible]“ als Referenz hinzufügen

Schritt 13: Konfigurieren Sie die passwortlose SSH-Authentifizierung für localhost für Ansible

Ansible ist für die Automatisierung von Aufgaben auf Remote-Servern konzipiert. Durch die passwortlose SSH-Authentifizierung kann Ansible eine Verbindung zu diesen Servern herstellen, ohne dass eine manuelle Passworteingabe erforderlich ist.

Führen Sie diesen Befehl aus, um mithilfe des SSH-Schlüssels des Benutzers „ansible-admin“ eine sichere Verbindung von Ihrem Computer zu einem anderen Computer (z. B. dem mit der IP-Adresse 172.31.34.41) herzustellen.

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

In meinem Fall sieht es so aus.

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Jetzt sehen Sie „Anzahl der hinzugefügten Schlüssel: 1“ . Dies bedeutet, dass die Installation der passwortlosen SSH-Authentifizierung erfolgreich abgeschlossen wurde.

Schritt 14: Erstellen Sie ein neues Ansible-Playbook für Docker-Aufgaben

Nachdem Ansible nun vollständig eingerichtet und einsatzbereit ist, können Sie ein neues Ansible-Playbook für Ihre Pipeline erstellen. Mit diesem Playbook kann Ansible ein neues Docker-Image erstellen und an Dockerhub senden.

So können Sie es machen:

1. Erstellen Sie zunächst eine neue Ansible-Playbook-Datei. Verwenden Sie einfach diesen Befehl.

 touch hello-app.yml

2. Bearbeiten Sie dann die neu erstellte Datei hello-app.yml . Öffnen Sie es mit diesem Befehl zur Bearbeitung.

 vi hello-app.yml

3. Geben Sie in die Datei Folgendes ein:

 --- - hosts: ansible user: root tasks: - name: create docker image command: docker build -t hello:latest . args: chdir: /opt/docker - name: create tag to push image onto dockerhub command: docker tag hello:latest zufarexplainedit/hello:latest - name: push docker image onto dockerhub command: docker push zufarexplainedit/hello:latest

Das Ansible-Playbook für Docker-Aufgaben ist einsatzbereit.

Schritt 13: Testen Sie das Ansible-Playbook mit Docker-Aufgaben

Nachdem Ansible, Ansible Playbook, AnsibleServer und JenkinsServer ordnungsgemäß konfiguriert sind, ist es an der Zeit, das Ansible Playbook zu testen.

Navigieren Sie zum Speicherort Ihres Ansible-Playbooks.

 cd /opt/docker

Führen Sie dann den folgenden Befehl aus.

 sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml

Nach Abschluss sehen Sie das erfolgreiche Ausführungsergebnis Ihres Ansible-Playbooks.

Nehmen Sie sich außerdem einen Moment Zeit, um Ihr Dockerhub-Konto zu besuchen und zu überprüfen, ob jetzt ein neues Bild sichtbar ist.

Sie sollten das neu hinzugefügte Bild sehen. Dieses Ergebnis bestätigt, dass Ihr Ansible-Playbook korrekt ist.

Schritt 14: Ansible Docker-Aufgaben in die Pipeline integrieren

Da nun das Github-Plugin „Publish over SSH“ , Ansible und Docker installiert und konfiguriert sind, können Sie sie alle in die Pipeline integrieren, die Sie im „[Modul 2]: Jenkins Server“ erstellt haben, um ein Projekt-JAR-Artefakt zu übertragen von „ JenkinsServer“ zu „AnsibleServer“ und erstellen Sie dann ein neues Docker-Image aus Ihrem Projekt und übertragen Sie dieses Docker-Image dann auf Dockerhub.

Um dies zu erreichen, müssen Sie die folgenden Schritte ausführen:

1. Navigieren Sie zu „Dashboard“ → „CI_CD_Pipeline“ → „Konfigurieren“ → „Post-Build-Aktionen“ → „Build-Artefakte über SSH senden“.
2. Fügen Sie den Befehl „sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml“ zur Eingabe „Exec-Befehl“ hinzu.

Klicken Sie abschließend auf die Schaltflächen „Übernehmen“ und „Speichern“ , um die Integrationsaufgaben von Ansible Docker mit der Pipeline abzuschließen.

Schritt 15: Testen Sie das in die Pipeline integrierte „Ansible Playbook mit Docker-Aufgaben “.

Jetzt können Sie Ihre aktualisierte Pipeline testen, um ein Projekt-JAR-Artefakt nahtlos von „ JenkinsServer“ auf „AnsibleServer“ zu übertragen, dann ein neues Docker-Image aus Ihrem Projekt erstellen und dieses Docker-Image dann auf Dockerhub übertragen. Dazu müssen Sie auf die Schaltfläche „Jetzt erstellen“ klicken. Als Ergebnis sehen Sie in der Build-Historie ein erfolgreiches Jobergebnis.

Nehmen Sie sich außerdem einen Moment Zeit, um Ihr Dockerhub-Konto zu besuchen und zu überprüfen, ob jetzt ein neues Bild sichtbar ist.

Sie sollten das neu hinzugefügte Bild sehen. Dieses Ergebnis bestätigt, dass Ihr Ansible-Playbook mit Docker-Aufgaben erfolgreich in die Pipeline integriert wurde.

[Modul 7]: Kubernetes

Lassen Sie uns nun K8s auf der EC2-Instanz konfigurieren. Sie werden eine neue EC2-Instanz erstellen und deren kubectl-Befehlszeilentool für die weitere Interaktion mit einem Kubernetes- Cluster installieren.

Schritt 1: Starten Sie eine AWS EC2 Virtual Server-Instanz

Befolgen Sie die Anweisungen im Abschnitt „ Starten einer AWS EC2 Virtual Server-Instanz“ dieses Tutorials, um diesen Schritt abzuschließen.

Schritt 2: Stellen Sie eine Verbindung zu einer AWS EC2 Virtual Server-Instanz her

Klicken Sie auf die Schaltfläche „Verbinden“.

Jetzt können Sie das Online-Terminal der EC2 Virtual Server-Instanz sehen.

Schritt 3: Ändern Sie den Hostnamen der AWS EC2 Virtual Server-Instanz „KubernetesServer“.

Wenn Sie KuberenetesServer auf einer virtuellen EC2-Serverinstanz konfigurieren möchten, müssen Sie zunächst den Hostnamen ändern.

Lass es uns tun. Führen Sie diesen Befehl aus, um die Hostnamendatei zu öffnen:

 sudo vi /etc/hostname

Sie sollten so etwas sehen.

Ersetzen Sie diesen Hostnamen durch „kubernetes-server“ und starten Sie ihn dann neu.

 sudo init 6

Ihr Hostname wurde geändert.

Schritt 4: Überprüfen Sie die AWS CLI-Version

Verwenden Sie diesen Befehl, um die AWS- Version zu überprüfen.

 aws --version

Auf diese Weise können Sie Ihre aktuelle aws-cli-Version sehen.

Wenn Sie die Version aws-cli/1.18 sehen, sollten Sie die neueste Version herunterladen.

Schritt 5: AWS CLI aktualisieren

Da Sie nun herausgefunden haben, dass Sie eine alte aws-cli-Version auf Ihrer EC2-Instanz haben, müssen Sie diese aktualisieren. Gehen Sie dazu zu AWS → Dokumentation → AWS Command Line Interface → Benutzerhandbuch für Version 2.

Kopieren Sie den Curl-Befehl und fügen Sie ihn ein.

Führen Sie zunächst diesen Befehl aus, um awscli Version 2 herunterzuladen.

 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

Warten Sie, bis der Downloadvorgang beginnt.

Sie sollten so etwas sehen.

Zweitens müssen Sie diesen Befehl ausführen, um das Archiv von awscli Version 2 zu entpacken.

 unzip awscliv2.zip

Drittens sollten Sie diesen Befehl ausführen, um awscli Version 2 zu installieren.

 sudo ./aws/install

Laden Sie dann das Online-Terminal der Kubernetes EC2 Virtual Server-Instanz neu.

Verwenden Sie als Nächstes diesen Befehl, um die AWS-Version zu überprüfen

 aws --version

Sie können sehen, dass aws cli aws-cli/2 hat.

Schritt 6: Kubectl installieren

Jetzt müssen Sie das Befehlszeilentool kubectl installieren, um weiter mit einem Kubernetes-Cluster interagieren zu können. Dazu müssen Sie zu AWS → Dokumentation → Amazon EKS → Benutzerhandbuch → Kubectl installieren oder aktualisieren → Linux gehen.

Oder klicken Sie einfach auf den Link https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html .

Führen Sie zunächst diesen Befehl aus, um kubectl herunterzuladen.

 curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/1.27.1/2023-04-19/bin/linux/amd64/kubectl

Warten Sie auf den Downloadvorgang.

Sie werden so etwas sehen.

Erteilen Sie kubectl die Erlaubnis.

 chmod +x kubectl

Verschieben Sie kubectl in den Ordner /usr/local/bin.

 sudo mv kubectl /usr/local/bin

Überprüfen Sie die Version von kubectl.

 kubectl version --output=yaml

Schritt 7: Installieren Sie eksctl

Führen Sie den Befehl aus, um kubectl herunterzuladen.

 curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

Verschieben Sie eksctl in den Ordner /usr/local/bin.

 sudo mv /tmp/eksctl /usr/local/bin

Überprüfen Sie die Version von eksctl.

 eksctl version

Sie sollten die Version sehen

Schritt 8: Erstellen Sie eine IAM-Rolle für eksctl

Sie müssen eine IAM-Rolle erstellen und diese an Ihre EC2-Instanz „KubernetesServer“ anhängen.

Dazu müssen Sie EC2 im Suchfeld finden.

Wählen Sie EC2 Virtual Server aus, indem Sie auf den Link https://us-east-1.console.aws.amazon.com/ec2 / klicken.

Gehen Sie zu IAM Dashboard → Rollen .

Klicken Sie auf der IAM- Rollen-Webseite auf die Schaltfläche „Rolle erstellen“ .

Wählen Sie dann „AWS-Dienst“, „EC2“. Und klicken Sie auf die Schaltfläche „Weiter“ .

Suchen Sie dann im Suchfeld nach „AmazonEC2FullAccess“ , „AmazonEC2FullAccess“ , „IAMFullAccess“ , „AWSCloudFormationFullAccess“ und klicken Sie dann auf die Schaltfläche „Berechtigungen hinzufügen“ .

Klicken Sie anschließend auf die Schaltfläche „Weiter“ .

Geben Sie dann „Eksctl_Role“ in die Eingabe „Rollenname“ ein.

Und klicken Sie auf die Schaltfläche „Rolle erstellen“ .

Die Rolle wird schließlich erstellt.

Schritt 9: IAM-Rolle mit eksctl verbinden

Gehen Sie zur Webseite der AWS EC2-Instanz. Wählen Sie „KuberbetesServer“. Klicken Sie dann auf „Aktionen“ → „Sicherheit“ → „IAM-Rolle ändern“.

Wählen Sie „Eksctl_Role“ und klicken Sie dann auf die Schaltfläche „IAM-Rolle aktualisieren“ .

Jetzt ist Ihre IAM-Rolle mit Ihrem „EKS_Server“ und dem eksctl-Tool verbunden.

Schritt 10: Erstellen Sie einen eksctl-Cluster

Jetzt ist es an der Zeit, Ihren EKS-Cluster einzurichten.

Um dies zu erreichen, gehen Sie folgendermaßen vor:

1. Ändern Sie den folgenden Befehl mit Ihren spezifischen Informationen.

 eksctl create cluster --name cluster-name \ --region region-name \ --node-type instance-type \ --nodes-min 2 \ --nodes-max 2 \ --zones <AZ-1>,<AZ-2>

In meinem Fall sieht es zum Beispiel so aus.

 eksctl create cluster --name zufarexplainedit \ --region eu-north-1 \ --node-type t3.micro

2. Führen Sie den geänderten Befehl aus und warten Sie geduldig auf den Abschluss des Clustererstellungsprozesses. Sie werden feststellen, dass der EKS-Clusterstatus auf der AWS CloudFormation-Webseite als „wird erstellt“ angezeigt wird.

   
   

Der Clustererstellungsvorgang dauert normalerweise etwa 20 Minuten. Sobald der Vorgang abgeschlossen ist, zeigt das Terminal das Ergebnis des Vorgangs an.

Darüber hinaus können Sie den erfolgreichen EKS-Cluster- Erstellungsstatus auf der AWS CloudFormation-Webseite überprüfen.

Schritt 11: Erstellen Sie eine Kubernetes-Bereitstellungs-YAML-Datei

Da nun Kubernetes-Cluster, eksctl und kubectl installiert und konfiguriert sind, können Sie eine Kubernetes-Bereitstellungs-YAML-Datei erstellen.

Sie können dies tun, indem Sie den folgenden Befehl ausführen.

 touch hello-app-deployment.yaml

Bearbeiten Sie dann diese Datei, indem Sie den folgenden Befehl ausführen.

 vi hello-app-deployment.yaml

Fügen Sie diesen Inhalt zur hello-app-deployment.yaml hinzu.

 apiVersion: apps/v1 kind: Deployment metadata: name: zufarexplainedit-hello-app labels: app: hello-app spec: replicas: 2 selector: matchLabels: app: hello-app template: metadata: labels: app: hello-app spec: containers: - name: hello-app image: zufarexplainedit/hello imagePullPolicy: Always ports: - containerPort: 8080 strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 maxUnavailable: 1

Jetzt ist hello-app-deployment.yaml erstellt und einsatzbereit.

Schritt 12: Erstellen Sie eine Kubernetes-Service-YAML-Datei

Wenn Kubernetes-Cluster, eksctl und kubectl installiert und konfiguriert sind, können Sie eine Kubernetes-Service-YAML-Datei erstellen.

Dazu müssen Sie eine Kubernetes Service-YAML-Datei erstellen, indem Sie den folgenden Befehl ausführen.

 touch hello-app-service.yaml

Bearbeiten Sie dann diese Datei, indem Sie den folgenden Befehl ausführen.

 vi hello-app-service.yaml

Fügen Sie diesen Inhalt zur hello-app-deployment.yaml hinzu.

 apiVersion: v1 kind: Service metadata: name: zufarexplainedit-hello-app-service labels: app: hello-app spec: selector: app: hello-app ports: - port: 8080 targetPort: 8080 type: LoadBalancer

Jetzt ist hello-app-service.yaml erstellt und einsatzbereit.

Schritt 13: Testen Sie den Kubernetes-Cluster mit kubectl

Nachdem Ihr Kubernetes EKS-Cluster erfolgreich installiert und konfiguriert wurde und Ihre Kubernetes-Dienst- und Bereitstellungsdateien bereit sind, ist es an der Zeit, die Dinge mit kubectl-Befehlen auf die Probe zu stellen.

1. Bereitstellung anwenden.

   Verwenden Sie den folgenden Befehl, um die Bereitstellungskonfiguration anzuwenden.

 kubectl apply -f hello-app-deployment.yaml

Dadurch wird eine Bereitstellung mit der angegebenen Anzahl von Replikaten und einer fortlaufenden Update-Strategie erstellt, die die Verfügbarkeit und Verwaltbarkeit Ihrer Anwendung gewährleistet.

2. Service anwenden.

Wenden Sie als Nächstes die Dienstkonfiguration an.

 kubectl apply -f hello-app-service.yaml

Dadurch wird ein Dienst vom Typ LoadBalancer eingerichtet, der Ihre Anwendung dem Internet zugänglich macht.

Beachten Sie, dass es eine Weile dauern kann, bis der LoadBalancer bereitgestellt wird und eine externe IP-Adresse erhält.

3. Überprüfen Sie den LoadBalancer-Status.

   Überwachen Sie den Status Ihres Dienstes mit.

 kubectl get service zufarexplainedit-hello-app-service

Wenn eine externe IP zugewiesen ist, können Sie fast auf Ihre Anwendung zugreifen.

4. Greifen Sie auf Ihre Anwendung zu.

   Geben Sie über einen Webbrowser die zugewiesene externe IP-Adresse gefolgt von :8080 ein. Nach einem kurzen Moment wird die Seite geladen und zeigt die Meldung „HelloWorld“ an. Beachten Sie, dass das erste Laden einige Sekunden dauern kann.

   
   

   

   
   

 kubectl delete deployments --all

 kubectl delete pods --all

 kubectl delete services --all

 eksctl delete cluster --name {your cluster name} --region {your region name}

 eksctl delete cluster --name zufarexplainedit --region eu-north-1

Schritt 14: Fügen Sie einen neuen Benutzer in der AWS EC2 Virtual Server-Instanz „KubernetesServer“ hinzu und konfigurieren Sie ihn

Fügen wir nun einen neuen Ansible-Admin- Benutzer zur AWS EC2 Virtual Server-Instanz „KubernetesServer“ hinzu.

Verwenden Sie dazu diesen Befehl.

 sudo useradd ansible-admin

Legen Sie dann das Passwort für den Benutzer „ansible-admin“ fest.

 sudo passwd ansible-admin

Außerdem müssen Sie Benutzerrechte konfigurieren, indem Sie die sudoers- Datei bearbeiten.

 sudo visudo

Fügen Sie „ansible-admin ALL=(ALL) ALL“ zu dieser Sudoers- Datei hinzu.

Außerdem müssen Sie die Datei /etc/ssh/sshd_config bearbeiten, um PasswordAuthentication zu aktivieren.

 sudo vi /etc/ssh/sshd_config 

Anschließend müssen Sie den Dienst neu laden, um diese Änderungen vorzunehmen.

 sudo service sshd reload

Als Ergebnis der Ausführung dieses Befehls sehen Sie:

 sudo su - ansible-admin

Schritt 15: Schlüssel in einer AWS EC2 Virtual Server-Instanz generieren

Im weiteren Verlauf dieses Artikels planen Sie, Remote-Server wie die virtuelle EC2-Serverinstanz von K8 zu verwalten. Aus diesem Grund müssen Sie SSH-Schlüssel einrichten.

 ssh-keygen

Als Ergebnis der Ausführung dieses Befehls sehen Sie:

Jetzt sind SSH-Schlüssel generiert und einsatzbereit.

Schritt 16: Konfigurieren Sie die passwortlose SSH-Authentifizierung für localhost für Ansible

Ansible ist für die Automatisierung von Aufgaben auf Remote-Servern konzipiert. Durch die passwortlose SSH-Authentifizierung kann Ansible eine Verbindung zu diesen Servern herstellen, ohne dass eine manuelle Passworteingabe erforderlich ist.

Führen Sie diesen Befehl aus, um mithilfe des SSH-Schlüssels des Benutzers „ansible-admin“ eine sichere Verbindung von Ihrem Computer zu einem anderen Computer (z. B. dem mit der IP-Adresse 172.31.34.41) herzustellen.

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

In meinem Fall sieht es so aus.

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Jetzt sehen Sie „Anzahl der hinzugefügten Schlüssel: 1“ . Dies bedeutet, dass die Installation der passwortlosen SSH-Authentifizierung erfolgreich abgeschlossen wurde.

Schritt 17: Konfigurieren Sie Ansible-Hosts in der AnsibleServer EC2-Instanz

Wenn Sie ein Ansible-Playbook ausführen, geben Sie die Hosts an, auf denen es ausgeführt werden soll. In diesem Schritt müssen Sie den KubernetesServer EC2-Instanzhost angeben. Dazu müssen Sie die gleichen Schritte wiederholen, die Sie in „ [Modul 6]: Ansible“ durchgeführt haben.

Lassen Sie uns den Host der KubernetesServer EC2-Instanz ermitteln, indem wir den folgenden Befehl ausführen.

 sudo ifconfig 

Nachdem Sie den KubernetesServer EC2-Instanzhost gefunden haben, können Sie ihn der Ansible-Hosts-Datei hinzufügen, indem Sie den folgenden Befehl ausführen.

 sudo vi /etc/ansible/hosts 

Sie können auch „[kubernetes]“ als Referenz hinzufügen

Schritt 18: Erstellen Sie ein neues Ansible-Playbook für Kubernetes-Aufgaben

Nachdem Kubernetes nun vollständig eingerichtet und einsatzbereit ist, können Sie ein neues Ansible-Playbook mit Kubernetes-Aufgaben für Ihre Pipeline erstellen. Mit diesem Playbook kann Ansible Ihre App mit kubectl-Befehlen auf dem Kubernetes-Cluster ausführen.

So können Sie es machen:

1. Erstellen Sie zunächst eine neue Ansible-Playbook-Datei. Verwenden Sie einfach diesen Befehl.

 touch kubernetes-hello-app.yml

2. Bearbeiten Sie dann die neu erstellte Datei hello-app.yml . Öffnen Sie es mit diesem Befehl zur Bearbeitung.

 vi kubernetes-hello-app.yml

3. Geben Sie in die Datei Folgendes ein:

 --- - hosts: kubernetes tasks: - name: deploy regapp on kubernetes command: kubectl apply -f hello-app-deployment.yaml - name: create service for regapp command: kubectl apply -f hello-app-service.yaml - name: update deployment with new pods if image updated in docker hub command: kubectl rollout restart deployment.apps/zufarexplainedit-hello-app

Das Ansible-Playbook für Kubernetes-Aufgaben ist einsatzbereit.

Schritt 19: Integrieren Sie ein neues Ansible-Playbook für Kubernetes-Aufgaben mit Jenkins

Nachdem Kubernetes, Ansible und Ansible Playbook für Kubernetes-Aufgaben nun eingerichtet und einsatzbereit sind, können Sie es in Jenkins integrieren.

1. Gehen Sie zu JenkinsServer → Jenkins-Dashboard → Neues Element.

2. Erstellen Sie ein neues Jenkins Freestyle-Projekt mit dem Namen „CD-Job“.

   
   

   

   
   

3. Klicken Sie auf die Schaltfläche „OK“.

4. Gehen Sie zum Abschnitt „Post-Build-Aktionen“.

5. Klicken Sie auf die Schaltfläche „Post-Build-Aktion hinzufügen“.

6. Wählen Sie die Option „Build-Artefakte über SSH senden“.

7. Wählen Sie „AnsibleServer“ als SSH-Server.

8. Fügen Sie diesen Befehl zur Eingabe „exec command“ hinzu.

   
   

 sudo -u ansible-admin ansible-playbook /opt/docker/kubernetes-hello-app.yml

9. Klicken Sie auf die Schaltflächen „Übernehmen“ und „Speichern“.

10. Gehen Sie zum Jenkins-Dashboard → „CI_CD_Pipeline“ → Konfigurieren → Abschnitt „Post-Build-Aktionen“.

11. Klicken Sie auf die Schaltfläche „Post-Build-Aktion hinzufügen“.

12. Wählen Sie die Option „Andere Projekte erstellen“.

13. Gehen Sie zum Abschnitt „Andere Projekte erstellen“.

14. Wählen Sie die Option „Nur auslösen, wenn der Build stabil ist“.

15. Fügen Sie „CD-Job“ zur Eingabe „Projekt zum Erstellen“ hinzu.

    
    

    
    

    

    
    

16. Klicken Sie auf die Schaltflächen „Übernehmen“ und „Speichern“.

    
    

Jetzt können Sie davon ausgehen, dass die Pipeline vollständig fertiggestellt und einsatzbereit ist.

Schritt 20: Testen der endgültigen Pipeline-Version

Jetzt ist es an der Zeit, die endgültige Pipeline-Version auf die Probe zu stellen.

Navigieren Sie zu Jenkins → Jenkins-Dashboard → „CI_CD_Pipeline“.

Klicken Sie auf die Schaltfläche „Jetzt erstellen“.

Um die Ergebnisse anzuzeigen, überprüfen Sie die Protokolle der Build-Konsole.

Sie werden feststellen, dass der „CD-Job“ in den Build-Konsolenprotokollen ausgelöst wurde und der endgültige Status als ERFOLGREICH gekennzeichnet ist.

4

Darüber hinaus können Sie zu Dockerhub gehen, um das Hinzufügen des neuen Docker-Images zu bestätigen.

Und schließlich können Sie über einen Webbrowser auf Ihre Anwendung zugreifen. Geben Sie die zugewiesene externe IP-Adresse gefolgt von „:8080“ ein. Nach einem kurzen Moment wird die Seite geladen und zeigt die Meldung „HelloWorld“ an.

Abschluss

Herzlichen Glückwunsch zum Einrichten dieser modernen CI/CD-Pipeline!

Du hast großartige Arbeit geleistet und bist ein echter Held!

Vielen Dank für all Ihre Mühe!

Über den Autor

Zufar Sunagatov ist ein erfahrener leitender Softwareentwickler, der sich leidenschaftlich für die Entwicklung moderner Softwaresysteme interessiert.

• Entwickelte leistungsstarke verteilte Systeme mit Java, Kotlin, AWS, Docker und Kubernetes für Unternehmen wie Citi (London), MTS (Moskau) und andere ( für weitere Informationen können Sie Zufars LinkedIn-Profil folgen ).
• Gründer von Ice Latte, einem Open-Source-Online-Marktplatz von Grund auf (Sie können Zufars Team beitreten und zu seinem Projekt auf GitHub beitragen: https://github.com/Sunagatov/Online-Store ).
• Er gründete die ZufarExplainedIT-Community, um sein Wissen und seine Erfahrungen mit anderen zu teilen (Sie können der IT-Telegram-Community von Zufar folgen: https://t.me/zufarexplained ).
• Über 3000 Minuten lang Mentor und Durchführung von 60 Sitzungen auf ADPlist, um aufstrebende Talente zu fördern ( Sie können sich von Zufar auf ADPlist betreuen lassen ).
• Als Redner auf Konferenzen und auf IT-YouTube-Kanälen begeisterte er das Publikum und teilte unschätzbare Erkenntnisse (Beispiele seiner YouTube-Videos sind: „Тестовое собеседование Java разработчика #27 – Зуфар Сунагатов“ , „Aspiring Speakers Lunchtime Lightning Talks May 28th“ ).
• Autor sehr beliebter IT-Artikel mit jeweils mehr als 7.000 Aufrufen (Beispiele seiner Artikel sind: „Microservice Architecture Patterns Part 1: Decomposition Patterns“ , „Что значит «вариативный»? Объясняем простыми словами“ ).