In der schnelllebigen Welt der Softwareentwicklung ist es entscheidend, hochwertige Anwendungen schnell und zuverlässig bereitzustellen. Hier kommt CI/CD (Continuous Integration und Continuous Delivery/Deployment) ins Spiel.

CI/CD ist eine Reihe von Praktiken und Tools, die darauf abzielen, den Prozess der Integration von Code-Änderungen, deren Testung und Bereitstellung in der Produktion zu automatisieren und zu optimieren. Durch die Einführung von CI/CD kann Ihr Team manuelle Fehler reduzieren, die Release-Zyklen beschleunigen und sicherstellen, dass Ihr Code immer in einem bereitstellbaren Zustand ist.

In diesem Tutorial konzentrieren wir uns auf einen benutzerfreundlichen Ansatz zur Einrichtung einer grundlegenden CI/CD-Pipeline unter Verwendung von Bitbucket, einem Linux-Server und Python mit Flask. Konkret werden wir einen automatisierten Prozess erstellen, der die neuesten Änderungen aus einem Bitbucket-Repository auf Ihren Linux-Server zieht, wenn ein Push oder Merge zu einem bestimmten Branch erfolgt.

Dieser Prozess wird von Bitbucket-Webhooks und einem einfachen Flask-basierten Python-Server unterstützt, der auf eingehende Webhook-Ereignisse hört und die Bereitstellung auslöst.

Es ist wichtig zu beachten, dass CI/CD ein umfangreiches und komplexes Feld ist und dieses Tutorial darauf abzielt, ein grundlegendes Verständnis zu vermitteln, anstatt ein umfassender Leitfaden zu sein.

Wir werden die Grundlagen der Einrichtung einer CI/CD-Pipeline mithilfe von Tools behandeln, die für Anfänger zugänglich sind. Beachten Sie jedoch, dass CI/CD-Systeme in der realen Welt oft fortgeschrittenere Tools und Konfigurationen wie Containerisierung, Orchestrierung und mehrstufige Testumgebungen umfassen.

Bis zum Ende dieses Tutorials haben Sie ein funktionierendes Beispiel dafür, wie Sie Bereitstellungen mithilfe von Bitbucket, Linux und Python automatisieren können, auf das Sie aufbauen können, wenn Sie sich mit CI/CD-Konzepten vertrauter machen.

Inhaltsverzeichnis:

  1. Warum ist CI/CD wichtig?

  2. Schritt 1: Richten Sie einen Webhook in Bitbucket ein

  3. Schritt 2: Richten Sie den Flask-Listener auf Ihrem Linux-Server ein

  4. Schritt 3: Veröffentlichen Sie die Flask-App (Optional)

  5. Schritt 4: Testen Sie die Einrichtung

  6. Schritt 5: Sicherheitsüberlegungen

  7. Abschließend

Warum ist CI/CD wichtig?

CI/CD ist aus mehreren Gründen zu einem Eckpfeiler der modernen Softwareentwicklung geworden. Vor allem beschleunigt es den Entwicklungsprozess. Durch die Automatisierung wiederkehrender Aufgaben wie Tests und Bereitstellung können Entwickler sich stärker auf das Schreiben von Code konzentrieren und weniger auf manuelle Prozesse. Dies führt zu einer schnelleren Bereitstellung neuer Funktionen und Fehlerkorrekturen, was besonders in wettbewerbsintensiven Märkten wichtig ist, in denen Geschwindigkeit ein Unterscheidungsmerkmal sein kann.

Ein weiterer wichtiger Vorteil von CI/CD ist die Reduzierung von Fehlern und die Verbesserung der Zuverlässigkeit. Die automatisierten Tests stellen sicher, dass jede Code-Änderung gründlich auf Probleme überprüft wird, bevor sie in den Hauptcode integriert wird. Dies minimiert das Risiko, Fehler einzuführen, die die Anwendung stören oder später teure Korrekturen erfordern könnten. Automatisierte Bereitstellungspipelines reduzieren auch die Wahrscheinlichkeit menschlicher Fehler während des Freigabeprozesses und gewährleisten so, dass Bereitstellungen konsistent und vorhersehbar sind.

CI/CD fördert auch eine bessere Zusammenarbeit unter den Teammitgliedern. In traditionellen Entwicklungsabläufen kann die Integration von Codeänderungen mehrerer Entwickler ein zeitaufwändiger und fehleranfälliger Prozess sein. Mit CI/CD wird der Code häufig und oft mehrmals täglich integriert und getestet. Das bedeutet, dass Konflikte frühzeitig erkannt und gelöst werden, und der Code bleibt in einem stabilen Zustand. Infolgedessen können Teams effizienter und mit größerem Vertrauen arbeiten, selbst wenn mehrere Mitwirkende gleichzeitig an verschiedenen Teilen des Projekts arbeiten.

Schließlich unterstützt CI/CD kontinuierliche Verbesserung und Innovation. Durch die Automatisierung des Bereitstellungsprozesses können Teams Updates häufiger und mit weniger Risiko in die Produktion bringen. Dies ermöglicht es ihnen, schneller Feedback von den Benutzern zu sammeln und effektiver an ihren Produkten zu iterieren.

Was wir in diesem Tutorial behandeln werden

In diesem Tutorial werden wir den Prozess der Einrichtung einer einfachen CI/CD-Pipeline durchlaufen, die die Bereitstellung von Codeänderungen aus einem Bitbucket-Repository auf einen Linux-Server automatisiert. Hier ist, was Sie lernen werden:

  1. Wie man ein Bitbucket-Repository konfiguriert, um Webhook-Benachrichtigungen zu senden, wann immer es einen Push oder Merge zu einem bestimmten Branch gibt.

  2. Wie man einen auf Flask basierenden Python-Server auf Ihrem Linux-Server einrichtet, um auf eingehende Webhook-Ereignisse zu hören.

  3. Wie man ein Skript schreibt, das die neuesten Änderungen aus dem Repository abruft und sie auf den Server deployt.

  4. Wie man seinen automatisierten Bereitstellungsprozess testet und Fehlersuche betreibt.

Am Ende dieses Tutorials werden Sie ein funktionierendes Beispiel einer grundlegenden CI/CD-Pipeline haben, die Sie nach Bedarf anpassen und erweitern können. Lassen Sie uns anfangen!

Schritt 1: Richten Sie einen Webhook in Bitbucket ein

Bevor wir mit dem Setup beginnen, lassen Sie uns kurz erklären, was ein Webhook ist und wie er in unseren CI/CD-Prozess passt.

Ein Webhook ist ein Mechanismus, der es einem System ermöglicht, ein anderes System in Echtzeit über ein Ereignis zu benachrichtigen. Im Kontext von Bitbucket kann ein Webhook so konfiguriert werden, dass er eine HTTP-Anfrage (oft eine POST-Anfrage mit Payload-Daten) an eine angegebene URL sendet, wann immer ein bestimmtes Ereignis in Ihrem Repository auftritt, wie z.B. ein Push zu einem Branch oder ein Zusammenführen eines Pull-Requests.

In unserem Fall wird der Webhook unseren auf Flask basierenden Python-Server (der auf Ihrem Linux-Server läuft) benachrichtigen, wann immer es einen Push oder Merge zu einem bestimmten Branch gibt. Diese Benachrichtigung löst ein Skript auf dem Server aus, das die neuesten Änderungen aus dem Repository abruft und sie automatisch bereitstellt. Im Wesentlichen fungiert der Webhook als Brücke zwischen Bitbucket und Ihrem Server und ermöglicht eine nahtlose Automatisierung des Bereitstellungsprozesses.

Jetzt, da Sie die Rolle eines Webhooks verstehen, lassen Sie uns einen in Bitbucket einrichten:

  1. Melden Sie sich bei Bitbucket an und navigieren Sie zu Ihrem Repository.

  2. Klicken Sie in der linken Seitenleiste auf Einstellungen.

  3. Im Abschnitt Workflow finden und klicken Sie auf Webhooks.

  4. Klicken Sie auf die Schaltfläche Webhook hinzufügen.

  5. Geben Sie einen Namen für Ihren Webhook ein (zum Beispiel „Automatischer Pull“).

  6. Geben Sie im Feld URL die URL zu Ihrem Server an, an den der Webhook die Anfrage senden wird. Wenn Sie eine Flask-App lokal ausführen, könnte dies etwa http://your-server-ip/pull-repo sein. (Für Produktionsumgebungen wird dringend empfohlen, HTTPS zu verwenden, um die Kommunikation zwischen Bitbucket und Ihrem Server abzusichern.)

  7. Im Triggers-Bereich wählen Sie die Ereignisse aus, die Sie überwachen möchten. In diesem Beispiel wählen wir Push (und optional Pull Request Merged, wenn Sie auch nach dem Zusammenführen bereitstellen möchten).

  8. Speichern Sie den Webhook mit einem selbsterklärenden Namen, damit er später leicht zu identifizieren ist.

Sobald der Webhook eingerichtet ist, sendet Bitbucket jedes Mal eine POST-Anfrage an die angegebene URL, wenn das ausgewählte Ereignis eintritt. In den nächsten Schritten richten wir einen Flask-Server ein, um diese eingehenden Anfragen zu verarbeiten und den Bereitstellungsprozess auszulösen.

Hier ist, was Sie sehen sollten, wenn Sie den Bitbucket-WebHook einrichten

Schritt 2: Richten Sie den Flask-Listener auf Ihrem Linux-Server ein

Im nächsten Schritt richten Sie einen einfachen Webserver auf Ihrem Linux-Rechner ein, der auf das Webhook von Bitbucket hört. Wenn er die Benachrichtigung erhält, führt er einen git pull oder einen Force-Pull (im Falle von lokalen Änderungen) aus, um das Repository zu aktualisieren.

Installieren Sie Flask:

Um die Flask-Anwendung zu erstellen, installieren Sie zunächst Flask, indem Sie Folgendes ausführen:

pip install flask

Erstellen Sie die Flask-App:

Erstellen Sie ein neues Python-Skript (zum Beispiel app_repo_pull.py) auf Ihrem Server und fügen Sie den folgenden Code hinzu:

from flask import Flask
import subprocess

app = Flask(__name__)

@app.route('/pull-repo', methods=['POST'])
def pull_repo():
    try:
        # Holen Sie sich die neuesten Änderungen aus dem Remote-Repository
        subprocess.run(["git", "-C", "/path/to/your/repository", "fetch"], check=True)
        # Setzen Sie den lokalen Branch zurück, um mit dem Remote-Branch 'test' übereinzustimmen
        subprocess.run(["git", "-C", "/path/to/your/repository", "reset", "--hard", "origin/test"], check=True)  # Ersetzen Sie 'test' durch den Namen Ihres Branches
        return "Force pull successful", 200
    except subprocess.CalledProcessError:
        return "Failed to force pull the repository", 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Hier ist, was dieser Code tut:

  • subprocess.run(["git", "-C", "/path/to/your/repository", "fetch"]): Dieser Befehl holt die neuesten Änderungen aus dem Remote-Repository, ohne das lokale Arbeitsverzeichnis zu beeinträchtigen.

  • subprocess.run(["git", "-C", "/pfad/zum/ihrem/repository", "reset", "--hard", "origin/test"]): Dieser Befehl führt ein Hard-Reset durch, der das lokale Repository zwingt, mit dem Remote-test-Zweig übereinzustimmen. Ersetzen Sie test durch den Namen Ihres Zweigs.

Stellen Sie sicher, dass Sie /pfad/zum/ihrem/repository durch den tatsächlichen Pfad zu Ihrem lokalen Git-Repository ersetzen.

Schritt 3: Die Flask-App freigeben (Optional)

Wenn Sie möchten, dass die Flask-App von außerhalb Ihres Servers erreichbar ist, müssen Sie sie öffentlich freigeben. Dafür können Sie einen Reverse-Proxy mit NGINX einrichten. So geht’s:

Zuerst installieren Sie NGINX, falls Sie es noch nicht haben, indem Sie diesen Befehl ausführen:

sudo apt-get install nginx

Anschließend müssen Sie NGINX konfigurieren, um Anfragen an Ihre Flask-App weiterzuleiten. Öffnen Sie die NGINX-Konfigurationsdatei:

sudo nano /etc/nginx/sites-available/default

Passen Sie die Konfiguration an, um diesen Block einzuschließen:

server {
    listen 80;
    server_name your-server-ip;

    location /pull-repo {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Jetzt müssen Sie nur noch NGINX neu laden, um die Änderungen anzuwenden:

sudo systemctl reload nginx

Schritt 4: Die Einrichtung testen

Jetzt, da alles eingerichtet ist, starten Sie die Flask-App, indem Sie dieses Python-Skript ausführen:

python3 app_repo_pull.py

Jetzt, um zu testen, ob alles funktioniert:

  1. Mache einen Commit: Push einen Commit in den test Branch deines Bitbucket-Repositories. Diese Aktion wird das Webhook auslösen.

  1. Webhook-Auslösung: Das Webhook sendet eine POST-Anfrage an deinen Server. Die Flask-App empfängt diese Anfrage, führt einen Force-Pull vom test Branch durch und aktualisiert das lokale Repository.

  2. Überprüfe den Pull: Überprüfe die Protokollausgabe deiner Flask-App oder inspiziere das lokale Repository, um zu bestätigen, dass die Änderungen erfolgreich abgerufen und angewendet wurden.

Schritt 5: Sicherheitsüberlegungen

Wenn du eine Flask-App dem Internet aussetzt, ist es entscheidend, deinen Server und deine Anwendung abzusichern, um sie vor unbefugtem Zugriff, Datenverletzungen und Angriffen zu schützen. Hier sind die wichtigsten Bereiche, auf die du achten solltest:

1. Verwende einen sicheren Server mit geeigneten Firewall-Regeln

Ein sicherer Server ist so konfiguriert, dass er die Exposition gegenüber externen Bedrohungen minimiert. Dazu gehört die Verwendung von Firewall-Regeln, die Minimierung unnötiger Dienste und die Sicherstellung, dass nur erforderliche Ports für die Kommunikation geöffnet sind.

Beispiel für eine sichere Serverkonfiguration:

  • Minimale Software: Installieren Sie nur die Software, die Sie benötigen (zum Beispiel Python, Flask, NGINX) und entfernen Sie unnötige Dienste.

  • Betriebssystem-Updates: Stellen Sie sicher, dass das Betriebssystem Ihres Servers mit den neuesten Sicherheitsupdates auf dem neuesten Stand ist.

  • Firewall-Konfiguration: Verwenden Sie eine Firewall, um den eingehenden und ausgehenden Datenverkehr zu steuern und den Zugriff auf Ihren Server zu beschränken.

Zum Beispiel könnte eine grundlegende UFW (Uncomplicated Firewall)-Konfiguration auf Ubuntu so aussehen:

# Erlaube SSH (Port 22) für den Remote-Zugriff
sudo ufw allow ssh

# Erlaube HTTP (Port 80) und HTTPS (Port 443) für den Webverkehr
sudo ufw allow http
sudo ufw allow https

# Aktiviere die Firewall
sudo ufw enable

# Überprüfe den Status der Firewall
sudo ufw status

In diesem Fall:

  • Die Firewall erlaubt eingehende SSH-Verbindungen auf Port 22, HTTP auf Port 80 und HTTPS auf Port 443.

  • Alle unnötigen Ports oder Dienste sollten standardmäßig blockiert werden, um die Angriffsfläche zu verringern.

Zusätzliche Firewall-Regeln:

  • Zugriff auf den Webhook-Endpunkt einschränken: Idealerweise sollte der Datenverkehr zum Webhook-Endpunkt nur von den IP-Adressen von Bitbucket erlaubt werden, um externen Zugriff zu verhindern. Sie können dies in Ihrer Firewall oder mit Ihrem Webserver (zum Beispiel NGINX) einrichten, indem Sie nur Anfragen aus dem IP-Bereich von Bitbucket akzeptieren.

  • Alle anderen eingehenden Datenverkehr ablehnen: Für jeden Dienst, der nicht im Internet exponiert werden muss (zum Beispiel Datenbank-Ports), stellen Sie sicher, dass diese Ports blockiert sind.

2. Fügen Sie der Flask-App eine Authentifizierung hinzu

Da Ihre Flask-App über die Webhook-URL öffentlich zugänglich sein wird, sollten Sie in Erwägung ziehen, eine Authentifizierung hinzuzufügen, um sicherzustellen, dass nur autorisierte Benutzer (wie die Server von Bitbucket) den Pull auslösen können.

Beispiel für grundlegende Authentifizierung:

Sie können eine einfache tokenbasierte Authentifizierung verwenden, um Ihren Webhook-Endpunkt zu sichern. Hier ist ein Beispiel, wie Sie Ihre Flask-App so modifizieren können, dass ein Authentifizierungstoken erforderlich ist:

from flask import Flask, request, abort
import subprocess

app = Flask(__name__)

# Definieren Sie ein geheimes Token zur Webhook-Verifizierung
SECRET_TOKEN = 'your-secret-token'

@app.route('/pull-repo', methods=['POST'])
def pull_repo():
    # Überprüfen Sie, ob die Anfrage das richtige Token enthält
    token = request.headers.get('X-Hub-Signature')
    if token != SECRET_TOKEN:
        abort(403)  # Verboten, wenn das Token falsch ist

    try:
        subprocess.run(["git", "-C", "/path/to/your/repository", "fetch"], check=True)
        subprocess.run(["git", "-C", "/path/to/your/repository", "reset", "--hard", "origin/test"], check=True)
        return "Force pull successful", 200
    except subprocess.CalledProcessError:
        return "Failed to force pull the repository", 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
So funktioniert es:

  • Die X-Hub-Signature ist ein benutzerdefinierter Header, den Sie der Anfrage hinzufügen, wenn Sie den Webhook in Bitbucket einrichten.

  • Nur Anfragen mit dem richtigen Token werden erlaubt, um den Pull auszulösen. Wenn das Token fehlt oder falsch ist, wird die Anfrage mit einer 403 Forbidden-Antwort abgelehnt.

Sie können auch komplexere Formen der Authentifizierung verwenden, wie OAuth oder HMAC (Hash-basierte Nachrichten-Authentifizierung), aber dieser einfache Tokenansatz funktioniert in vielen Fällen.

3. Verwenden Sie HTTPS für sichere Kommunikation

Es ist entscheidend, die zwischen Ihrer Flask-App und dem Bitbucket-Webhook übertragenen Daten sowie alle sensiblen Daten (wie Tokens oder Passwörter), die über das Netzwerk übertragen werden, zu verschlüsseln. Dies stellt sicher, dass Angreifer die Daten nicht abfangen oder ändern können.

Warum HTTPS?

  • Datenverschlüsselung: HTTPS verschlüsselt die Kommunikation und stellt sicher, dass sensible Daten wie Ihr Authentifizierungstoken nicht für Man-in-the-Middle-Angriffe exponiert werden.

  • Vertrauen und Integrität: HTTPS hilft sicherzustellen, dass die vom Server empfangenen Daten nicht manipuliert wurden.

Verwendung von Let’s Encrypt zur Sicherung Ihrer Flask-App mit SSL:
  1. Installieren Sie Certbot (das Tool zum Erhalten von Let’s Encrypt-Zertifikaten):
sudo apt-get update
sudo apt-get install certbot python3-certbot-nginx

Erhalten Sie ein kostenloses SSL-Zertifikat für Ihre Domain:

sudo certbot --nginx -d your-domain.com

  • Dieser Befehl konfiguriert Nginx automatisch so, dass es HTTPS mit einem kostenlosen SSL-Zertifikat von Let’s Encrypt verwendet.

  • Stellen Sie sicher, dass HTTPS verwendet wird: Stellen Sie sicher, dass Ihre Flask-App oder die Nginx-Konfiguration den gesamten Datenverkehr zwingt, HTTPS zu verwenden. Sie können dies tun, indem Sie eine Weiterleitungsregel in Nginx einrichten:

server {
    listen 80;
    server_name your-domain.com;

    # Weiterleitung von HTTP zu HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your-domain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;

    # Andere Nginx-Konfiguration...
}

Automatische Verlängerung: Let’s Encrypt-Zertifikate sind 90 Tage gültig, daher ist es wichtig, die automatische Verlängerung einzurichten:

sudo certbot renew --dry-run

Dieser Befehl testet den Verlängerungsprozess, um sicherzustellen, dass alles funktioniert.

4. Protokollierung und Überwachung

Richten Sie die Protokollierung und Überwachung für Ihre Flask-App ein, um unbefugte Zugriffsversuche, Fehler oder ungewöhnliche Aktivitäten zu verfolgen:

  • Protokollierung von Anfragen: Protokollieren Sie alle eingehenden Anfragen, einschließlich der IP-Adresse, der Anforderungsheader und des Antwortstatus, damit Sie auf verdächtige Aktivitäten überwachen können.

  • Verwendung von Überwachungstools: Richten Sie Tools wie Prometheus, Grafana oder New Relic ein, um die Leistung des Servers und die Gesundheit der App zu überwachen.

Zusammenfassung

In diesem Tutorial haben wir erkundet, wie Sie eine einfache, benutzerfreundliche CI/CD-Pipeline einrichten, die Bereitstellungen mithilfe von Bitbucket, einem Linux-Server und Python mit Flask automatisiert. Hier ist eine Zusammenfassung dessen, was Sie gelernt haben:

  1. CI/CD-Grundlagen: Wir haben die Grundlagen der kontinuierlichen Integration (CI) und kontinuierlichen Bereitstellung/Implementierung (CD) besprochen, die wesentliche Praktiken zur Automatisierung der Integration, des Testens und der Bereitstellung von Code sind. Sie haben gelernt, wie CI/CD dazu beiträgt, die Entwicklung zu beschleunigen, Fehler zu reduzieren und die Zusammenarbeit zwischen Entwicklern zu verbessern.

  2. Einrichten von Bitbucket-Webhooks: Sie haben gelernt, wie Sie einen Bitbucket-Webhook konfigurieren, um Ihren Server bei jedem Push oder Merge in einen bestimmten Branch zu benachrichtigen. Dieser Webhook dient als Auslöser, um den Bereitstellungsprozess automatisch zu starten.

  3. Erstellung eines Flask-basierten Webhook-Listeners: Wir haben Ihnen gezeigt, wie Sie eine Flask-App auf Ihrem Linux-Server einrichten, um eingehende Webhook-Anfragen von Bitbucket zu empfangen. Diese Flask-App empfängt die Benachrichtigungen und führt die erforderlichen Git-Befehle aus, um die neuesten Änderungen abzurufen und bereitzustellen.

  4. Automatisierung des Bereitstellungsprozesses: Mit Python und Flask haben wir den Prozess automatisiert, Änderungen aus dem Bitbucket-Repository abzurufen und einen Force-Pull durchzuführen, um sicherzustellen, dass der neueste Code bereitgestellt wird. Sie haben auch gelernt, wie man den Server konfiguriert, um die Flask-App bereitzustellen und Anfragen sicher zu akzeptieren.

  5. Sicherheitsüberlegungen: Wir haben kritische Sicherheitsmaßnahmen besprochen, um Ihren Bereitstellungsprozess zu schützen:

    • Firewall-Regeln: Wir haben die Konfiguration von Firewall-Regeln besprochen, um die Exposition zu begrenzen und sicherzustellen, dass nur autorisierter Verkehr (von Bitbucket) auf Ihren Server zugreifen kann.

    • Authentifizierung: Wir haben eine tokenbasierte Authentifizierung hinzugefügt, um sicherzustellen, dass nur autorisierte Anfragen Bereitstellungen auslösen können.

    • HTTPS: Wir haben erklärt, wie Sie die Kommunikation zwischen Ihrem Server und Bitbucket mithilfe von SSL-Zertifikaten von Let’s Encrypt sichern können.

    • Protokollierung und Überwachung: Schließlich haben wir empfohlen, Protokollierung und Überwachung einzurichten, um ungewöhnliche Aktivitäten oder Fehler im Auge zu behalten.

Nächste Schritte

Am Ende dieses Tutorials haben Sie nun ein funktionierendes Beispiel für eine automatisierte Bereitstellungspipeline. Während dies eine grundlegende Implementierung ist, dient sie als Grundlage, auf der Sie aufbauen können. Wenn Sie sich mit CI/CD wohler fühlen, können Sie fortgeschrittene Themen wie:

  • Mehrstufige Bereitstellungspipelines

  • Integration mit Containerisierungswerkzeugen wie Docker

  • Komplexere Test- und Bereitstellungsstrategien

  • Einsatz von Orchestrierungswerkzeugen wie Kubernetes zur Skalierung

CI/CD-Praktiken entwickeln sich ständig weiter, und indem Sie die Grundlagen meistern, haben Sie sich für den Erfolg gerüstet, während Sie Ihre Fähigkeiten in diesem Bereich erweitern. Viel Spaß beim Automatisieren und danke fürs Lesen!

Sie können den Code von hier forken.