Kontinuierliche Bereitstellung mit Jenkins und Docker unter Docker

1. Was ist Continuous Delivery

Der Ausgabeprozess des Softwareprodukts sollte innerhalb kurzer Zeit abgeschlossen sein, um sicherzustellen, dass die Software stabil und kontinuierlich in einem Zustand gehalten werden kann, in dem sie jederzeit veröffentlicht werden kann. Ziel ist es, Software schneller und häufiger zu erstellen, zu testen und freizugeben. Dieser Ansatz kann die Kosten und den Zeitaufwand der Softwareentwicklung verringern sowie Risiken reduzieren.

2. Vergleich zwischen Continuous Delivery und traditioneller Lieferung

Der Release-Zyklus der herkömmlichen Bereitstellung kann wie folgt dargestellt werden:

Nachteile der herkömmlichen Zustellung:

Langsame Lieferung: Hier erhält der Kunde das Produkt erst lange nach der Angabe seiner Anforderungen. Dies führte zu einer unbefriedigenden Markteinführungszeit und verzögertem Kundenfeedback.

Langer Feedback-Zyklus: Im Feedback-Zyklus geht es nicht nur um Kunden, sondern auch um Entwickler. Angenommen, Sie verursachen versehentlich einen Fehler und erfahren während der UAT-Phase davon. Wie lange dauert es, etwas zu reparieren, was Sie vor zwei Monaten repariert haben? Selbst kleine Fehler können Wochen dauern.

Gefährliche Hotfixes: Hotfixes können normalerweise nicht auf eine vollständige UAT-Phase warten und werden daher häufig anders (mit einer verkürzten UAT-Phase) oder überhaupt nicht getestet.

Stress: Unvorhersehbare Veröffentlichungen bedeuten Stress für Betriebsteams. Darüber hinaus sind die Release-Zyklen oft eng getaktet, was zusätzlichen Druck auf Entwickler und Tester ausübt.

Um kontinuierlich Produkte liefern zu können, ohne Unmengen an Geld für ein rund um die Uhr arbeitendes Betriebsteam auszugeben, benötigen wir Automatisierung. Aus diesem Grund geht es bei Continuous Delivery darum, jede Phase des herkömmlichen Bereitstellungsprozesses in eine Reihe von Skripten umzuwandeln, die als automatisierte Bereitstellungspipeline oder Continuous Delivery-Pipeline bezeichnet wird.

Wir können den Prozess dann nach jeder Codeänderung ausführen und den Benutzern das Produkt kontinuierlich bereitstellen, ohne dass manuelle Schritte erforderlich sind.

Vorteile von Continuous Delivery:

Schnelle Lieferung: Kunden können das Produkt sofort nach Abschluss der Entwicklung nutzen, was die Markteinführungszeit erheblich verkürzt. Bedenken Sie, dass Software nur dann Umsatz generiert, wenn sie in den Händen der Benutzer ist.

Schnelle Feedback-Zyklen: Angenommen, Sie entdecken einen Fehler in Ihrem Code und dieser geht noch am selben Tag in die Produktion. Wie lange würde es dauern, etwas zu reparieren, an dem Sie an diesem Tag gearbeitet haben? Wahrscheinlich nicht so viel. Dies ist zusammen mit einer schnellen Rollback-Strategie der beste Weg, die Produktion stabil zu halten.

Veröffentlichungen mit geringem Risiko: Wenn Sie jeden Tag eine Veröffentlichung durchführen, wird der Prozess wiederholbar und damit sicherer.

Flexible Freigabeoptionen: Wenn die Freigabe sofort erfolgen muss, ist bereits alles vorbereitet, sodass mit einer Freigabeentscheidung kein zusätzlicher Zeit-/Kostenaufwand verbunden ist.

Es versteht sich von selbst, dass wir durch die Eliminierung sämtlicher Lieferphasen und die Entwicklung direkt auf der Grundlage der Produktion sämtliche Vorteile realisieren können. Allerdings kommt es hierdurch zu Qualitätseinbußen. Tatsächlich liegt die ganze Schwierigkeit bei der Einführung von Continuous Delivery in der Angst, dass die Qualität durch den Wegfall manueller Schritte nachlässt. Wir zeigen Ihnen, wie Sie damit sicher umgehen und Produkte liefern, die kontinuierlich weniger Fehler aufweisen und besser an die Kundenbedürfnisse angepasst sind.

3. So erreichen Sie Continuous Delivery

Die automatisierte Bereitstellungspipeline besteht aus drei Phasen, wie im folgenden Diagramm dargestellt:

Jeder Schritt entspricht einer Phase im herkömmlichen Lieferprozess, und zwar wie folgt:

Kontinuierliche Integration: Überprüft, ob von verschiedenen Entwicklern geschriebener Code zusammen integriert wird

Automatisierte Abnahmetests: Diese ersetzen die manuelle QA-Phase und prüfen, ob die von den Entwicklern implementierten Funktionen den Anforderungen des Kunden entsprechen.

Konfigurationsmanagement: Dies ersetzt die manuelle Phase - Konfiguration der Umgebung und Bereitstellung von Software

1. Kontinuierliche Integration

In der Continuous-Integration-Phase erhalten die Entwickler erstes Feedback. Es checkt Code aus dem Repository (Git, SVN) aus, kompiliert den Code, führt Unit-Tests aus und überprüft die Codequalität. Wenn ein beliebiger Schritt fehlschlägt, wird die Ausführung der Pipeline gestoppt und der Entwickler sollte zunächst den Continuous-Integration-Build reparieren.

2. Automatisierte Abnahmetests

Die automatisierte Abnahmetestphase besteht aus einer Reihe von Tests, die in Verbindung mit Qualitätssicherungen geschrieben werden und die manuelle UAT-Phase ersetzen sollen. Es fungiert als Qualitätskontrolltor, um zu entscheiden, ob ein Produkt zur Veröffentlichung bereit ist. Wenn ein Abnahmetest fehlschlägt, wird die Pipeline-Ausführung gestoppt und es werden keine weiteren Schritte ausgeführt. Es verhindert den Übergang zur Konfigurationsmanagementphase und somit die Freigabe.

3. Konfigurationsmanagement

Die Konfigurationsmanagementphase ist für die Verfolgung und Kontrolle von Änderungen in der Software und ihrer Umgebung verantwortlich. Hierzu gehört die Vorbereitung und Installation der erforderlichen Tools, die Skalierung der Anzahl von Serviceinstanzen und deren Verteilung, die Bestandsaufnahme der Infrastruktur und alle Aufgaben im Zusammenhang mit der Anwendungsbereitstellung.

Das Konfigurationsmanagement ist eine Lösung für die Probleme, die mit der manuellen Bereitstellung und Konfiguration von Anwendungen in einer Produktionsumgebung einhergehen. Konfigurationsverwaltungstools wie Ansible, Chef oder Puppet unterstützen das Speichern von Konfigurationsdateien in einem Versionskontrollsystem und das Verfolgen aller auf Produktionsservern vorgenommenen Änderungen.

Ein weiterer Job, der manuelle Aufgaben des Betriebsteams ersetzt, ist die Verantwortung für die Anwendungsüberwachung. Dies geschieht normalerweise durch das Streamen von Protokollen und Metriken von laufenden Systemen an ein gemeinsames Dashboard, das von Entwicklern (oder DevOps-Teams, wie im nächsten Abschnitt beschrieben) überwacht wird.

4. Werkzeuge

1.Docker-Ökosystem

Docker hat als führender Anbieter im Bereich Containerisierung in den letzten Jahren die Softwarebranche dominiert. Es ermöglicht das Verpacken von Anwendungen in umgebungsunabhängigen Images und behandelt den Server somit als Ressourcenfarm und nicht als Maschine, die für jede Anwendung konfiguriert werden muss.

Die Wahl fiel klar auf Docker, da es perfekt in die Welt der (Mikro-)Dienste und des kontinuierlichen Bereitstellungsprozesses passt.

2.jenkins

Jenkins ist der beliebteste Automatisierungsserver auf dem Markt. Es unterstützt Sie bei der Erstellung kontinuierlicher Integrations- und Bereitstellungspipelines und hilft generell bei der Erstellung von Skripts für jede andere Automatisierung. Es ist stark Plugin-orientiert und verfügt über eine großartige Community, die es ständig um neue Funktionen erweitert.

Noch wichtiger ist, dass es das Schreiben von Pipelines als Code ermöglicht und verteilte Build-Umgebungen unterstützt.

3. Ansible

Ansible ist ein Automatisierungstool, das bei der Softwarebereitstellung, dem Konfigurationsmanagement und der Anwendungsbereitstellung hilft. Es verwendet eine agentenlose Architektur und ist gut in Docker integriert.

4.gitHub

GitHub ist definitiv das gehostete Versionskontrollsystem Nummer eins. Es bietet ein sehr stabiles System, eine webbasierte Benutzeroberfläche und einen kostenlosen Dienst mit einem öffentlichen Repository.

Dennoch kann jeder Dienst oder jedes Tool zur Quellcodeverwaltung die kontinuierliche Bereitstellung nutzen, unabhängig davon, ob es sich in der Cloud oder selbst gehostet befindet und ob es auf Git, SVN, Mercurial oder einem anderen Tool basiert.

5. Docker-Praxis

1. Docker-Übersicht

Docker ist ein Open-Source-Projekt, das die Anwendungsbereitstellung mithilfe von Softwarecontainern erleichtern soll. Das folgende Zitat stammt von der offiziellen Docker-Seite:

Ein Docker-Container verpackt eine Software in ein vollständiges Dateisystem, das alles enthält, was zur Ausführung benötigt wird: Code, Laufzeit, Systemtools, Systembibliotheken – alles, was auf einem Server installiert werden kann. Dadurch wird sichergestellt, dass die Software unabhängig von ihrer Umgebung immer gleich ausgeführt wird.

Ähnlich wie bei der Virtualisierung ermöglicht Docker das Verpacken von Anwendungen in Images, die überall ausgeführt werden können.

2. Virtualisierung und Containerisierung

Ohne Docker können Isolation und andere Vorteile durch Hardwarevirtualisierung (allgemein als virtuelle Maschinen bekannt) erreicht werden. Die beliebtesten Lösungen sind VirtualBox, VMware und Parallels.

Eine virtuelle Maschine emuliert eine Computerarchitektur und bietet die Funktionalität eines physischen Computers. Wenn jede Anwendung als separates virtuelles Maschinenimage bereitgestellt und ausgeführt wird, können wir eine vollständige Isolierung der Anwendungen erreichen. Die folgende Abbildung zeigt das Konzept der Virtualisierung:

Jede Anwendung wird als eigenständiges Image gestartet, das alle Abhängigkeiten und das Gastbetriebssystem enthält. Das Image wird von einem Hypervisor ausgeführt, der die physische Computerarchitektur emuliert.

Diese Bereitstellungsmethode wird von vielen Tools wie Vagrant unterstützt und ist für Entwicklungs- und Testumgebungen vorgesehen. Allerdings hat die Virtualisierung drei wesentliche Nachteile:

Geringe Leistung: Eine virtuelle Maschine emuliert die gesamte Computerarchitektur, um das Gastbetriebssystem auszuführen, sodass jeder Vorgang einen großen Overhead verursacht.

Hoher Ressourcenverbrauch: Simulationen benötigen viele Ressourcen und müssen für jeden Anwendungsfall separat durchgeführt werden. Aus diesem Grund können auf einem Standard-Desktop nur wenige Anwendungen gleichzeitig ausgeführt werden.

Große Bilder: Jede Anwendung wird mit einem vollständigen Betriebssystem geliefert, daher ist mit der Bereitstellung auf einem Server das Senden und Speichern großer Datenmengen verbunden.

Die folgende Abbildung zeigt den Unterschied, den Docker mit sich bringt:

3. Installation von Docker

Der Docker-Installationsprozess ist schnell und einfach. Die meisten Linux-Betriebssysteme unterstützen es heutzutage und viele von ihnen stellen dedizierte Binärdateien bereit. Auch Mac und Windows werden mit nativen Apps gut unterstützt.

Es ist jedoch wichtig zu verstehen, dass Docker intern auf dem Linux-Kernel und seinen Besonderheiten basiert, weshalb es unter Mac und Windows eine virtuelle Maschine (xhyve für Mac und hyv für Windows) verwendet, um die Docker-Engine-Umgebung auszuführen.

Hier sprechen wir nur über den Betrieb unter Ubuntu 16.04 unter Linux (offizielle Befehle):

$ sudo apt-get update
$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 9DC858229FC7DD38854AE2D88D81803C0EBFCD88
$ sudo apt-add-repository 'deb [arch=amd64] https://download.docker.com/linux/ubuntu xenial main stable'
$ sudo apt-get update
$ sudo apt-get install -y docker-ce

Wenn eine Fehlermeldung angezeigt wird:

,

Sie können den folgenden Befehl erneut ausführen:

$ cd /etc/apt/sources.list.d
$ sudo vi docker.list
  deb https://download.docker.com/linux/ubuntu würziger Rand
$ sudo apt-Update
$ sudo apt installiere docker-ce

Diesmal ist kein Fehler aufgetreten, aber es war zu langsam, da der Download von Docker-ce relativ groß ist und von einer ausländischen Website stammt. Hier können Sie es in eine inländische Quelle ändern. Die Anweisungen lauten wie folgt:

sudo apt-get update 
sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ software-properties-common
curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key hinzufügen
sudo add-apt-repository "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stabil"
sudo apt-get update 
sudo apt-get installiere docker-ce

Testen Sie, ob die Installation abgeschlossen ist: docker -v oder docker info können einige grundlegende Informationen zu Docker anzeigen und darauf hinweisen, dass die Installation erfolgreich war:

4. Docker ausführen

Die Docker-Umgebung wurde installiert. Wir können zunächst ein sehr klassisches Beispiel ausführen: Hallo Welt:

$ docker run hello-world

Wenn Sie die folgende Meldung sehen, bedeutet das, dass alles richtig läuft:

Sehen wir uns Schritt für Schritt an, was unter der Haube passiert:

1. Führen Sie den Docker-Client mit dem Befehl „Run“ aus.

2. Der Docker-Client kontaktiert den Docker-Daemon und fordert die Erstellung eines Containers aus dem Image mit dem Namen „Hello-World“ an.

3. Der Docker-Daemon überprüft, ob das „Hello World“-Image lokal vorhanden ist. Da dies nicht der Fall ist, fordert er das „Hello World“-Image aus dem Remote-Docker-Hub-Register an.

4. Das Docker Hub-Register enthält das „Hello-World“-Image. Legen Sie es also auf dem Docker-Daemon ab.

5. Der Docker-Daemon erstellte einen neuen Container aus dem „Hello-World“-Image und startete die ausführbare Datei, die die Ausgabe generierte.

6. Der Docker-Daemon streamt diese Ausgabe an den Docker-Client.

7.Der Docker-Client sendet es an Ihr Terminal.

5. Erstellen Sie das Image

Es gibt zwei Möglichkeiten, ein Image zu erstellen:

Docker-Commit-Befehl und automatischer Build der Docker-Datei. Lassen Sie uns besprechen, wie Docker Images erstellt.

Ich werde nur über die Dockerfile-Methode sprechen:

Das manuelle Erstellen jedes Docker-Images mit dem Commit-Befehl kann mühsam sein, insbesondere bei Build-Automatisierung und kontinuierlichen Bereitstellungsprozessen. Glücklicherweise gibt es eine integrierte Sprache zum Angeben aller Anweisungen, die zum Erstellen eines Docker-Image ausgeführt werden müssen.

1. Erstellen Sie eine DockerFile-Datei und geben Sie den folgenden Inhalt ein:

VON Ubuntu:16.04
Führen Sie apt-get update && \ aus.
 apt-get install -y python

2. Führen Sie den Befehl zum Erstellen des Images aus:

Docker-Build -t Ubuntu_mit_Python.

3. Wir können den Befehl verwenden:

Docker-Images: Sehen Sie sich das Image an, das wir erstellt haben:

6.Docker-Container

Wir können den Befehl „docker ps“ verwenden, um die laufenden Container anzuzeigen, und „docker ps -a“, um alle Container anzuzeigen. Container sind zustandsbehaftet.

Starten Sie den Container über das Image und zeigen Sie den Status des Containers an:

Um den Docker-Container zu stoppen, verwenden Sie den Befehl: docker stop container id

7. Führen Sie Tomcat aus und verwenden Sie den externen Zugriff

1. Führen Sie das Tomcat-Image aus:

docker run -d tomcat

Unser externer Browser kann jedoch nicht auf den Tomcat-Port 8080 zugreifen, da eine virtuelle Maschine die Netzwerkverbindung blockiert.

Wenn wir also den Container starten, müssen wir den Befehl -p verwenden, um den virtuellen Host und die Netzwerkportzuordnung des Docker-Containers zu verbinden

2.-p beginnen

docker run -d -p 8080:8080 tomcat

Geben Sie die IP-Adresse und den Port der virtuellen Maschine auf der Webseite ein, um wie folgt darauf zuzugreifen:

6. Jenkins-Praxis

1. Einführung in Jenkins

Jenkins ist ein Open-Source-Automatisierungsserver, der in Java geschrieben ist. Aufgrund des sehr aktiven Community-Supports und einer großen Anzahl Plugins ist es das beliebteste Tool zur Implementierung von Continuous Integration- und Continuous Delivery-Prozessen.

Jenkins übertrifft andere Continuous-Integration-Tools und ist die am weitesten verbreitete Software ihrer Art. Dies alles ist aufgrund seiner Merkmale und Funktionalität möglich.

2. Jenkins installieren

Der Jenkins-Installationsprozess ist schnell und einfach. Hierfür gibt es viele verschiedene Möglichkeiten. Da wir jedoch bereits mit dem Docker-Tool und seinen Vorteilen vertraut sind, beginnen wir mit einer Docker-basierten Lösung. Darüber hinaus ist es der einfachste, vorhersehbarste und intelligenteste Ansatz.

Für die Installation von Jenkins gelten einige Umgebungsanforderungen:

Java 8 256 MB freier Speicher 1 GB+ freier Festplattenspeicher

Es ist jedoch wichtig zu verstehen, dass die Anforderungen streng davon abhängen, was Sie mit Jenkins vorhaben. Wenn Jenkins als Continuous-Integration-Server für ein ganzes Team verwendet wird, werden selbst für ein kleines Team 1 GB+ freier Speicher und 50 GB+ freier Festplattenspeicher empfohlen. Natürlich führt Jenkins auch einige Berechnungen durch und überträgt viele Daten über das Netzwerk, sodass CPU und Bandbreite von entscheidender Bedeutung sind.

Es gibt zwei Möglichkeiten, Jenkins zu installieren:

1. Docker-Image verwenden

2. Keine Docker-Images verwenden

1. Installieren Sie Jenkins mit einem Docker-Image

Verwenden Sie den Befehl:

docker run -p <Host-Port>:8080 -v <Host-Volume>:/var/jenkins_home jenkins:2.60.1

Geben Sie die URL auf der Webseite ein. Das folgende Bild zeigt, dass die Installation erfolgreich war:

Geben Sie das Passwort ein. Im Protokoll wird Ihnen dann ein erstes Passwort angezeigt:

2. Installieren Sie Jenkins ohne Verwendung eines Docker-Images

Die Installation ist auch sehr einfach, führen Sie einfach den folgenden Befehl aus:

$ 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 installiere jenkins

3. Einfache Jenkins-Anwendung (Hallo Welt)

Befolgen wir diese Regel und sehen uns die Schritte zum Erstellen unserer ersten Jenkins-Pipeline an:

Klicken Sie auf Neues Element.

Geben Sie „Hallo Welt“ als Projektnamen ein, wählen Sie „Pipeline“ aus und klicken Sie auf „OK“.

Es gibt viele Möglichkeiten. Wir überspringen sie jetzt und gehen direkt zum Pipeline-Teil.

In das Textfeld „Skript“ können wir das Pipeline-Skript eingeben:

Pipeline
   Agent beliebig
   Stufen {
    stage("Hallo") {
      Schritte {
       echo 'Hallo Welt'
      }
    }
   }
  }

Klicken Sie auf „Jetzt speichern und erstellen“. Im Ausgabeprotokoll sehen wir die folgende Abbildung:

7. Kontinuierliche Integrationspipeline

1. Einführung in die Pipeline

Eine Pipeline kann als eine Reihe automatisierter Vorgänge verstanden werden, die als einfache Skriptkette betrachtet werden können:

Gruppierung von Aktionen: Gruppierung von Aktionen in Phasen (auch Gates oder Qualitätsgates genannt), die dem Prozess mit klar definierten Regeln Struktur verleihen: Wenn eine Phase fehlschlägt, werden keine weiteren Phasen ausgeführt.

Sichtbarkeit: Alle Aspekte des Prozesses werden visualisiert, was eine schnelle Fehleranalyse ermöglicht und die Zusammenarbeit im Team fördert.

Feedback: Teammitglieder werden über auftretende Probleme informiert, sodass sie schnell reagieren können

2. Pipeline-Struktur

Eine Jenkins-Pipeline besteht aus zwei Elementen: Phasen und Schritte. Das folgende Diagramm zeigt ihre Verwendung:

3. Hallo Welt der Pipeline

Pipeline
  Agent beliebig
  Stufen {
   stage('Erste Stufe') {
    Schritte {
     echo 'Schritt 1. Hallo Welt'
    }
   }
   stage('Zweite Stufe') {
    Schritte {
     echo 'Schritt 2. Zweites Mal Hallo'
     echo 'Schritt 3. Hallo zum dritten Mal'
    }
   }
  }
}

Nachdem der Build erfolgreich war, können Sie das folgende Bild sehen:

4. Pipeline-Regeln

Agent: Gibt an, wo die Ausführung stattfindet, und kann Bezeichnungen definieren, um Agenten mit derselben Bezeichnung abzugleichen, oder Docker, um dynamisch vorbereitete Container anzugeben, die die Umgebung für die Pipeline-Ausführung bereitstellen.

Trigger: Dies definiert, wie die Pipeline automatisch ausgelöst wird und kann verwendet werden, um einen zeitbasierten Zeitplan mit cron oder pollScm einzurichten, um nach Änderungen im Repository zu suchen (wir werden dies im Abschnitt Trigger und Benachrichtigungen ausführlich behandeln).

Optionen: Hiermit werden Optionen für eine bestimmte Pipeline angegeben, z. B. Timeout (die maximale Laufzeit der Pipeline) oder Wiederholungsversuche (die Häufigkeit, mit der die Pipeline nach einem Fehler erneut ausgeführt werden soll).

Umgebung: Dies definiert eine Reihe von Schlüsselwerten, die während des Build-Prozesses als Umgebungsvariablen verwendet werden

Parameter: Dies definiert eine Liste von Benutzereingabeparametern

Phase: Dies ermöglicht eine logische Gruppierung von Schritten

Wann: Dies bestimmt, ob die Phase basierend auf der gegebenen Bedingung ausgeführt werden soll.

Dies sind die grundlegendsten Kenntnisse. Einige erweiterte Funktionen werden später veröffentlicht.

Zusammenfassen

Oben habe ich Ihnen die Verwendung von Jenkins und Docker vorgestellt, um eine kontinuierliche Bereitstellung unter Docker zu erreichen. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und ich werde Ihnen rechtzeitig antworten!