Schritt-für-Schritt-Anleitung zur Konfiguration von CI/CD-Pipelines in Jenkins

Jenkins ist ein Automatisierungsserver, der häufig für die Einrichtung von CI/CD-Pipelines verwendet wird. Er eignet sich sowohl für kleine Projekte als auch für groß angelegte Unternehmens-Workflows und bietet leistungsstarke Tools zur Optimierung und Automatisierung des Software-Bereitstellungsprozesses. Ganz gleich, ob Sie an einfachen Aufgaben arbeiten oder komplizierte Vorgänge verwalten, Jenkins passt sich den Anforderungen verschiedener Entwicklungsumgebungen an und ist damit eine ideale Lösung für die kontinuierliche Integration und Bereitstellung in verschiedenen Branchen.
Dieser Leitfaden führt Sie durch die Schritte zur Installation von Jenkins, zur Konfiguration und zur Einrichtung einer grundlegenden CI/CD-Pipeline zur Automatisierung Ihres Softwareentwicklungsprozesses.

Was Sie benötigen

Bevor wir beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Einen bereitgestellten Server mit dem Betriebssystem Ihrer Wahl.
• Installiertes Java (JDK 11 oder höher) auf dem Server.
• Git für Code-Repositories auf dem Server installiert.
• (Optional) Docker für containerisierte Anwendungen installiert.
• Zugriff auf den Server über SSH mit Administratorrechten.

Schritte zur Einrichtung von Jenkins

Sie können Jenkins auf zwei Arten einrichten.
Sie können die Jenkins Download-Seite aufrufen und die entsprechende Version für Ihren Computer auswählen und installieren.

Sobald Sie die Jenkins-Dateien heruntergeladen haben, wird ein Setup-Assistent angezeigt.

Als Nächstes müssen Sie den Zielordner für das Programm angeben.

Schließlich erhalten Sie die Anmeldedaten für den Dienst.

Hier sollten Sie sicherstellen, dass Sie Jenkins als lokalen oder Domänenbenutzer ausführen, denn wenn Jenkins als LocalSystem ausgeführt wird, erhält es vollen Zugriff auf Ihren Computer, was überhaupt nicht sicher ist.
Um Jenkins als lokalen oder Domänenbenutzer auszuführen, müssen Sie einen Domain Benutzernamen und ein Kennwort für das Konto eingeben, mit dem Sie Jenkins ausführen möchten. Klicken Sie dann auf „Test Credentials“, um sie zu testen, und klicken Sie dann auf „Next“. Danach werden Sie aufgefordert,

• einen Port auszuwählen, auf dem Jenkins ausgeführt werden soll, und diesen dann zu testen.
• ein Java-Home-Verzeichnis auswählen.
• andere Dienste auswählen, die Sie zusammen mit Jenkins installieren möchten.
• die Installation zu bestätigen.

Oder Sie können Jenkins auf Ihrem vorbereiteten Server installieren, indem Sie diese Schritte befolgen:

1. Fügen Sie den Jenkins-GPG-Schlüssel und das Repository hinzu: sudo wget -O /usr/share/keyrings/jenkins-keyring.asc https://pkg.jenkins.io/debian/jenkins.io-2023.keyecho „deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc]“ \https://pkg.jenkins.io/debian binary/ | sudo tee \ /etc/apt/sources.list.d/jenkins.list > /dev/null
2. Aktualisieren Sie Ihre Paketliste: sudo apt update
3. Installieren Sie Jenkins: sudo apt install jenkins
4. Starten und aktivieren Sie den Jenkins-Dienst: sudo systemctl start jenkins sudo systemctl enable jenkins

So greifen Sie auf das Jenkins-Dashboard zu

Wenn Jenkins ausgeführt wird, können Sie für die Ersteinrichtung auf die Jenkins-Benutzeroberfläche zugreifen:

1. Öffnen Sie einen Webbrowser und navigieren Sie zu http://<your-server-ip>:8080.
2. Um Jenkins zu entsperren, rufen Sie das Administratorkennwort ab, indem Sie Folgendes ausführen: sudo cat /var/lib/jenkins/secrets/initialAdminPassword
3. Geben Sie das Kennwort in die Jenkins-Benutzeroberfläche ein und folgen Sie dem Einrichtungsassistenten.
4. Installieren Sie die vorgeschlagenen Plugins.
5. Erstellen Sie Ihren Admin-Benutzer und schließen Sie die Einrichtung ab.

Nach Abschluss der Einrichtung werden Sie zum Jenkins-Dashboard weitergeleitet, um mit der Konfiguration Ihrer CI/CD-Pipeline zu beginnen.

Jenkins-Einstellungen konfigurieren

Nach der Installation von Jenkins müssen Sie es für die Besonderheiten Ihrer CI/CD-Pipeline konfigurieren. Die folgenden Schritte helfen Ihnen dabei, Anmeldedaten für den Zugriff auf externe Dienste einzurichten und die globalen Tools zu konfigurieren, die Jenkins während der Erstellung und Bereitstellung verwenden wird. Dazu gehören das Hinzufügen von Anmeldedaten für Versionskontrollsysteme wie GitHub und das Einrichten von Tools wie Java, Maven und Docker, die in verschiedenen Phasen Ihrer Pipeline benötigt werden.

Wichtige Plugins installieren

Die wahre Stärke von Jenkins liegt in seinem umfangreichen Plug-in-Ökosystem, das es Ihnen ermöglicht, das System anzupassen. Um mit einer CI/CD-Pipeline zu beginnen, müssen Sie mehrere wichtige Plugins installieren:

• Git-Plugin: Damit kann Jenkins mit Git-Repositorys interagieren, sodass Sie Code klonen, erstellen und übertragen können.

Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Manage Plugins -> Available. Suchen Sie nach einem Git Plugin und installieren Sie es.

• Pipeline-Plugin: Dieses Plugin ist für die Definition und Ausführung von Jenkins-Pipelines über eine Jenkins-Datei unerlässlich und automatisiert Ihre Build-, Test- und Bereitstellungsprozesse.

Suchen Sie nach „Pipeline“ und installieren Sie es.

• Docker-Pipeline-Plugin (optional): Wenn Sie Docker in Ihre Pipeline integrieren möchten, können Sie mit diesem Plugin Docker-Befehle in Ihre Jenkins-Datei integrieren, was die Erstellung und Verwaltung von Docker-Containern erleichtert.

Suchen Sie nach „Docker-Pipeline“ und installieren Sie es.

• Credentials Binding Plugin: Dieses Plugin hilft Ihnen, Anmeldedaten wie API-Token oder Passwörter sicher in Ihren Pipelines zu verwalten und zu verwenden.

Suchen Sie nach dem Credentials Binding Plugin und installieren Sie es.
Mit diesen Plugins wird die Funktionalität von Jenkins erheblich erweitert, sodass Sie fortschrittlichere und automatisierte Pipelines erstellen können.

Anmeldeinformationen einrichten

Damit Jenkins sicher mit GitHub, Docker Hub oder anderen Systemen von Drittanbietern interagieren kann, müssen Sie Anmeldeinformationen einrichten und verwalten. So geht's:

1. Navigieren Sie zu Anmeldeinformationen:

Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Manage Credentials.

2. Anmeldeinformationen hinzufügen

• Wählen Sie die entsprechende Domäne aus (normalerweise Global, es sei denn, Sie organisieren Anmeldeinformationen nach Projekten). 
• Klicken Sie unter „Stores scoped to Jenkins“ auf (global) und wählen Sie dann „Zugangsdaten hinzufügen“ aus.

3. Wählen Sie den Typ der Zugangsdaten aus

• Wählen Sie für GitHub oder GitLab „Benutzername mit Passwort“ oder „Geheimer Text“ (für API-Token) aus.
• Wählen Sie für Docker Hub „Benutzername mit Passwort“ aus. Geben Sie die erforderlichen Details wie Benutzername, Passwort oder API-Token ein und geben Sie eine aussagekräftige ID zur einfachen Bezugnahme an.

4. Speichern Sie die Zugangsdaten

• Nachdem Sie Ihre Anmeldedaten hinzugefügt haben, werden diese sicher in Jenkins gespeichert und können in Ihren Pipelines verwendet werden.

Durch das Einrichten von Anmeldedaten wird sichergestellt, dass Jenkins sicher mit anderen Diensten interagieren kann, z. B. durch das Aufrufen von Code aus einem Repository oder das Pushen von Docker-Images, ohne dass vertrauliche Informationen offengelegt werden.

Definieren Sie globale Tool-Einstellungen

Damit Jenkins Ihre Anwendungen erstellen, testen und bereitstellen kann, benötigt es Zugriff auf Entwicklungstools. Durch die Konfiguration dieser globalen Tools wird sichergestellt, dass Jenkins weiß, wo sie auf Ihrem System zu finden sind.

1. Navigieren Sie zur globalen Tool-Konfiguration

• Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Global Tool Configuration.

2. Git einrichten:

• Klicken Sie unter Git auf Add Git.
• Wenn Git an einem Standardort installiert ist, sollte Jenkins es automatisch erkennen. Wenn nicht, geben Sie den Pfad zur ausführbaren Git-Datei an.

3. Maven einrichten (falls zutreffend)

• Wenn Ihr Projekt Maven für die Erstellung verwendet, scrollen Sie zu Maven, klicken Sie auf Maven hinzufügen und lassen Sie Jenkins die Installation entweder automatisch durchführen oder geben Sie den Installationspfad an.

4. Gradle einrichten (falls zutreffend)

• Ähnlich wie bei Maven klicken Sie unter Gradle auf Add Gradle und wählen die automatische Installation oder geben Sie den Pfad an.

Sobald diese Tools konfiguriert sind, kann Jenkins sie während der Pipeline-Ausführung aufrufen und so sicherstellen, dass Ihre Builds unabhängig von den verwendeten Technologien reibungslos ablaufen.

Erstellen Sie Ihre erste Pipeline

Nachdem Jenkins eingerichtet und bereit ist, besteht der nächste Schritt darin, eine Pipeline zu erstellen, um Ihre Build-, Test- und Bereitstellungsprozesse zu automatisieren. Befolgen Sie diese Schritte, um eine grundlegende Pipeline einzurichten.

Starten Sie ein neues Jenkins-Projekt

Jenkins bietet verschiedene Jobtypen. Für eine CI/CD-Pipeline ist der Pipeline-Jobtyp aufgrund seiner Flexibilität und Kompatibilität mit Jenkinsfiles in der Regel die beste Wahl.

1. Navigieren Sie zu „Neues Element“

• Klicken Sie im Jenkins Dashboard auf Neues Element.

2. Wählen Sie den Auftragstyp

• Geben Sie einen Namen für Ihren Auftrag ein (z. B. MyFirstPipeline). Wählen Sie Pipeline aus der Liste der Auftragstypen aus und klicken Sie auf OK.

3. Konfigurieren Sie den Auftrag

• Sie werden zur Job-Konfigurationsseite weitergeleitet, auf der Sie das Verhalten Ihrer Pipeline einrichten können.

Der Jobtyp „Pipeline“ ist ideal für komplexe CI/CD-Workflows, da Sie damit die gesamte Pipeline in einer Jenkins-Datei definieren können, was die Verwaltung und Versionskontrolle erleichtert.

Jenkins-Datei schreiben

Die Jenkins-Datei ist eine Textdatei, die Ihre CI/CD-Pipeline als Code definiert. Diese Datei wird mit einer von Jenkins bereitgestellten domänenspezifischen Sprache (DSL) geschrieben und normalerweise im Stammverzeichnis des Quellcodeverwaltungs-Repositorys Ihres Projekts gespeichert. Sie beschreibt die Schritte, die Jenkins zum Erstellen, Testen und Bereitstellen Ihrer Anwendung ausführen sollte.

1. Verstehen der Struktur von Jenkinsfile:

• Eine grundlegende Jenkinsfile enthält in der Regel Phasen wie Build (Erstellen), Test (Testen) und Deploy(Bereitstellen). Jede Phase enthält Schritte, die die von Jenkins auszuführenden Aktionen angeben.

2. Erstellen einer einfachen Jenkinsfile:

pipeline { agent any
stages {
    stage('Clone Repository') {
        steps {
            git '<https://github.com/your-repo/your-project.git>'
        }
    }
    stage('Build') {
        steps {
            // Example build step
            sh 'make build'
        }
    }
    stage('Test') {
        steps {
            // Example test step
            sh 'make test'
        }
    }
}
}

• pipeline: Der Block der obersten Ebene, der die gesamte Pipeline definiert.
• agent: Gibt an, wo die Pipeline ausgeführt werden soll; any bedeutet, dass sie auf jedem verfügbaren Agenten ausgeführt werden kann.
• stages: Ein Block, der alle Pipeline-Phasen enthält.
• stage: Definiert eine einzelne Phase in der Pipeline, z. B. „Clone Repository“, „Build“ oder „Test“.
• steps: Befehle oder Aktionen, die Jenkins in jeder Phase ausführt.

3. Fügen Sie die Jenkins-Datei zu Ihrem Repository hinzu:

Speichern Sie die Jenkins-Datei im Stammverzeichnis des Repositorys Ihres Projekts.

Definieren von Build-Triggern

Build-Trigger in Jenkins bestimmen, wann und wie Ihre Pipeline ausgeführt wird. Jenkins bietet eine Reihe von Trigger-Optionen, von manuellen Starts bis hin zu automatischen Triggern.

1. Navigieren Sie zu Build-Triggern: Scrollen Sie auf der Konfigurationsseite Ihres Jobs nach unten zum Abschnitt Build-Trigger.

2. Wählen Sie eine Triggermethode: 

• Poll SCM: Jenkins überprüft Ihr Quellcode-Repository regelmäßig auf Änderungen. Legen Sie die Abruffrequenz fest (z. B. *H/5 * * * ** alle 5 Minuten).
• GitHub Hook Trigger: Konfigurieren Sie für GitHub-Benutzer einen Webhook, um die Pipeline automatisch auszulösen, wenn eine neue Push- oder Pull-Anfrage eingeht.
• Build Periodically: Planen Sie die Ausführung der Pipeline in bestimmten Intervallen mithilfe einer cron-ähnlichen Syntax.
• Manuelle Auslösung: Starten Sie Builds bei Bedarf manuell über das Jenkins-Dashboard.

Konfigurieren Sie den Auslöser: Stellen Sie bei Webhooks sicher, dass Ihr Repository so eingerichtet ist, dass es bei Änderungen POST-Anfragen an Jenkins sendet. Jenkins reagiert auf diese Anfragen und löst die Pipeline entsprechend aus.

Ausführen des Pipeline-Jobs

1. Ausführen der Pipeline: Klicken Sie auf der Seite Ihres Jobs auf „Build Now“, um die Pipeline manuell auszulösen. Wenn Sie automatische Auslöser eingerichtet haben, wird die Pipeline automatisch gestartet, sobald das angegebene Ereignis eintritt (z. B. ein Code-Push).
2. Überwachen Sie den Erstellungsprozess: Jenkins zeigt den Fortschritt für jede Phase in Echtzeit an. Sie können Protokolle anzeigen, den Status jeder Phase überprüfen und eventuell auftretende Probleme beheben. Wenn die Pipeline erfolgreich abgeschlossen wurde, wird für alle Phasen ein grünes Häkchen angezeigt.
3. Überprüfen Sie die Ergebnisse: Überprüfen Sie nach Abschluss der Pipeline die Erstellungsprotokolle und -ergebnisse. Jenkins stellt detaillierte Informationen zu den ausgeführten Schritten, eventuell aufgetretenen Fehlern und dem Gesamterfolg oder -misserfolg der Pipeline bereit.

Jenkins mit der Quellcodeverwaltung verbinden

Die Integration von Jenkins in Versionsverwaltungssysteme wie GitHub oder GitLab ist für die Automatisierung Ihrer CI/CD-Pipeline von entscheidender Bedeutung. Sie müssen Jenkins so konfigurieren, dass automatisch Builds ausgelöst werden, wenn Änderungen in das Repository übertragen werden.

Link zu GitHub-Repositories

Um zu beginnen, müssen Sie Jenkins mit Ihrem GitHub- oder GitLab-Repository verbinden. Durch diese Verbindung kann Jenkins Benachrichtigungen (Webhooks) erhalten, wenn Änderungen in Ihrem Repository auftreten, und sich beim Zugriff auf Ihre Codebasis sicher authentifizieren.

1. Authentifizierung konfigurieren: 

• Generieren Sie einen persönlichen Zugriffstoken: Navigieren Sie zu GitHub > Einstellungen > Entwicklereinstellungen > Persönliche Zugriffstoken > Neues Token generieren. Wählen Sie die erforderlichen Bereiche aus, z. B. repo und admin:repo_hook.
• Fügen Sie den Token zu Jenkins hinzu: Gehen Sie in Jenkins zu Jenkins verwalten -> Anmeldeinformationen verwalten -> (global) -> Anmeldeinformationen hinzufügen.
• Wählen Sie Geheimer Text für das Token, geben Sie das Token ein und weisen Sie eine beschreibende ID zu (z. B. Github-Token).

2. Webhooks einrichten: Gehen Sie zu Ihrem Repository auf GitHub und navigieren Sie zu Einstellungen -> Webhooks -> Webhook hinzufügen. Legen Sie die Payload-URL auf http://your-jenkins-url/github-webhook/ fest und wählen Sie application/json als Inhaltstyp. Wählen Sie die Ereignisse aus, die den Webhook auslösen, in der Regel nur das Push-Ereignis und Pull-Anfragen.

3. Konfigurieren Sie den Jenkins-Job:

• Link zu Ihrem Repository: Geben Sie in Ihrer Jenkins-Job-Konfiguration im Abschnitt „Pipeline“ die URL Ihres Repositorys im Format https://github.com/your-repo/your-project.git an.
• Verwenden Sie Anmeldedaten: Stellen Sie sicher, dass Jenkins die zuvor hinzugefügten Anmeldedaten (persönliche Zugriffstoken) verwendet. Wählen Sie diese Anmeldedaten aus der Dropdown-Liste „Anmeldedaten“ im SCM-Abschnitt Ihrer Job-Konfiguration aus.

Wenn die Authentifizierung und Webhooks konfiguriert sind, wird Jenkins mit Ihrem GitHub- oder GitLab-Repository verbunden, sodass es Ihren Code abrufen und automatisch Builds auslösen kann.

Verwaltung von Branch- und PR-Builds

Um Jenkins vollumfänglich nutzen zu können, muss es unbedingt für die Erstellung von Feature-Branches und Pull-Anfragen konfiguriert werden. Diese Einrichtung hilft, Integrationsprobleme frühzeitig zu erkennen und die Gesamtqualität Ihres Codes zu verbessern.

1. Einrichten einer Multibranch-Pipeline: Ein Multibranch-Pipeline-Job in Jenkins erstellt automatisch Pipelines für alle Branchen in einem Repository und erstellt jede Branche auf der Grundlage ihrer eigenen Jenkins-Datei.

• Erstellen Sie einen Multibranch-Pipeline-Job: Klicken Sie im Jenkins Dashboard auf Neues Element und wählen Sie die Multibranch-Pipeline aus. Benennen Sie Ihren Job (z. B. MyProject-Multibranch).
• Konfigurieren Sie Branch-Quellen: Fügen Sie in der Job Konfiguration unter Branch-Quellen Ihr GitHub-Repository hinzu und verwenden Sie die zuvor eingerichteten Anmeldedaten.
• Legen Sie die Scan Multibranch-Pipeline-Trigger so fest, dass regelmäßig nach neuen Branchen oder Updates gesucht wird oder auf Webhook-Ereignisse reagiert wird.

2. Branch-Build-Konfiguration: Jenkins erkennt und erstellt automatisch alle Branchen mit einer Jenkins-Datei. Sie können die Handhabung verschiedener Branchen anpassen.

• Ausschlüsse und Filter: Schließen Sie bestimmte Branches vom Erstellen aus, indem Sie die Property Strategy innerhalb der Branch-Quellen konfigurieren. Sie können beispielsweise einen regulären Ausdruck verwenden, um Branchen mit bestimmten Benennung Mustern herauszufiltern.
• Spezifische Branch-Konfiguration: Definieren Sie spezifische Verhaltensweisen für Branches mithilfe der when-Anweisung in Ihrer Jenkins-Datei. Sie können beispielsweise angeben, dass bestimmte Phasen nur für den Hauptbranch ausgeführt werden:

stage('Deploy') { 
when { 
branch 'main' 
} 
steps { 
// Deployment steps here } 
}

3. Pull-Request-Builds: Jenkins kann Pull-Requests automatisch erstellen, um vorgeschlagene Änderungen zu testen, bevor sie in den Hauptzweig integriert werden.

• Aktivieren Sie Pull-Request-Builds: In der Multibranch-Pipeline-Job Konfiguration erkennt Jenkins Pull-Requests, wenn eine unterstützte Quelle wie GitHub oder GitLab verwendet wird. Diese Pull-Requests werden als separate Zweige angezeigt und können ähnlich wie andere Zweige erstellt werden.
• Einrichten der Statusberichterstattung: Jenkins kann den Build-Status von Pull-Anfragen an GitHub oder GitLab zurückmelden, sodass Sie die Build-Ergebnisse direkt in der Pull-Anfrage sehen können.
• Stellen Sie sicher, dass Ihr persönlicher Zugriffstoken über die erforderlichen Berechtigungen verfügt (repo:status für GitHub oder api für GitLab).

Einrichten von Build-Benachrichtigungen

Um Ihr Team über den Status von Build und Bereitstellung auf dem Laufenden zu halten, ist es unerlässlich, Benachrichtigungen in Jenkins einzurichten. Benachrichtigungen können per E-Mail versendet oder in Kollaborations-Tools wie Slack oder Microsoft Teams integriert werden, um sicherzustellen, dass alle über den Erfolg oder Misserfolg jeder Pipeline auf dem Laufenden bleiben.

Konfiguration von E-Mail-Benachrichtigungen

E-Mail-Benachrichtigungen sind eine einfache, aber effektive Möglichkeit, Ihr Team über die Ergebnisse der Erstellung auf dem Laufenden zu halten. Jenkins kann diese Benachrichtigungen automatisch in verschiedenen Phasen der Pipeline versenden.

1. Installieren Sie das E-Mail-Erweiterungs-Plugin:

• Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Manage Plugins -> Available, suchen Sie nach Email Extension Plugin und installieren Sie es, falls es noch nicht installiert ist.

2. Konfigurieren Sie den SMTP-Server:

• Navigieren Sie zu Manage Jenkins -> Configure System.
• Scrollen Sie zum Abschnitt Erweiterte E-Mail-Benachrichtigung und geben Sie Ihre SMTP-Serverdaten ein:
• SMTP-Server: Die Adresse Ihres Mailservers (z. B. smtp.yourdomain.com).
• SMTP-Port: Verwenden Sie 587 für TLS oder 465 für SSL.
• SMTP-Authentifizierung: Aktivieren Sie dieses Kontrollkästchen, wenn Ihr Server einen Benutzernamen und ein Passwort erfordert.
• SSL/TLS verwenden: Aktivieren Sie dieses Kontrollkästchen, wenn Ihr SMTP-Server SSL oder TLS erfordert.

3. E-Mail-Benachrichtigungen in der Pipeline einrichten: Sie können E-Mail-Benachrichtigungen direkt in Ihrer Jenkins-Datei definieren, um Warnmeldungen basierend auf dem Build-Status zu senden:

groovy
Copy code
pipeline {
    agent any


    stages {
        stage('Build') {
            steps {
                sh 'make build'
            }
        }
    }


    post {
        success {
            emailext subject: "Build Success: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                     body: "Good news! The build succeeded.",
                     to: 'team@example.com'
        }
        failure {
            emailext subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                     body: "Oops! The build failed. Please check the logs.",
                     to: 'team@example.com'
        }
    }
}

• Post: In diesem Block werden Aktionen definiert, die nach Abschluss der Pipeline ausgeführt werden, z. B. das Senden von E-Mails.
• success und failure: Geben Sie an, was bei erfolgreichen oder fehlgeschlagenen Build geschehen soll. Der Schritt „emailext“ sendet die E-Mail mit dem entsprechenden Betreff und Text.

Einrichtung der Integration von Slack oder Teams

Für Teams, die Kollaborations-Tools wie Slack oder Microsoft Teams verwenden, stellt die Integration von Jenkins in diese Plattformen sicher, dass Build-Benachrichtigungen direkt an die Team-Kanäle gesendet werden und so Echtzeit-Updates bereitstellen.

Slack-Integration

1. Installieren Sie das Slack-Benachrichtigungs-Plugin: 

• Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Manage Plugins -> Available.
• Suchen Sie nach dem Slack Notification Plugin, installieren Sie es und starten Sie Jenkins bei Bedarf neu.

2. Konfigurieren Sie die Slack-Integration:

• Gehen Sie zu „Jenkins verwalten“ > „System konfigurieren“.
• Scrollen Sie nach unten zum Abschnitt „Slack“ und geben Sie die folgenden Details ein:
• Arbeitsbereich: Geben Sie den Namen Ihres Slack-Arbeitsbereichs ein.
• Anmeldedaten: Fügen Sie Ihr Slack-Integrationstoken hinzu (erhalten Sie durch Erstellen eines eingehenden Webhooks oder über die Jenkins CI-App von Slack).
• Standardkanal: Geben Sie den Slack-Kanal an, an den Benachrichtigungen standardmäßig gesendet werden sollen.

3. Slack-Benachrichtigungen zu Jenkinsfile hinzufügen:

groovy
Copy code
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'make build'
            }
        }
    }
    post {
        success {
            slackSend channel: '#build-notifications', color: 'good',
                      message: "Build Success: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
        failure {
            slackSend channel: '#build-notifications', color: 'danger',
                      message: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
    }
}

Microsoft Teams-Integration

1. Erstellen Sie einen eingehenden Webhook in Microsoft Teams:

• Gehen Sie in Microsoft Teams zu dem Kanal, in dem Sie Benachrichtigungen erhalten möchten.
• Navigieren Sie zu Weitere Optionen (⋯) > Connectors > Incoming Webhook. Benennen Sie den Webhook und kopieren Sie die bereitgestellte URL.

2. Installieren Sie das Microsoft Teams-Benachrichtigungs-Plugin:

• Gehen Sie zu Jenkins Dashboard -> Manage Jenkins -> Manage Plugins -> Available.
• Suchen Sie nach dem Office 365 Connector Plugin, installieren Sie es und starten Sie Jenkins bei Bedarf neu.

3. Konfigurieren Sie die Teams-Integration:

• Gehen Sie zur Konfigurationsseite Ihres Jenkins-Jobs.
• Scrollen Sie zum Abschnitt Office 365 Connector und fügen Sie die Webhook-URL von Teams ein.

4. Fügen Sie Teams-Benachrichtigungen zu Jenkinsfile hinzu:

groovy
Copy code
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'make build'
            }
        }
    }
    post {
        success {
            office365ConnectorSend message: "Build Success: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                                   webhookUrl: 'YOUR_WEBHOOK_URL'
        }
        failure {
            office365ConnectorSend message: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                                   webhookUrl: 'YOUR_WEBHOOK_URL'
        }
    }
}

Diese Konfiguration stellt sicher, dass Ihr Team Echtzeit-Benachrichtigungen in Slack oder Microsoft Teams erhält, sodass alle über den Stand des Erstellungsprozesses informiert sind.