Einführung
Eine Jenkins Multibranch-Pipeline durchsucht ein Versionskontroll-Repository nach Branches, die eine Jenkinsfile enthalten, und erstellt für jeden dieser Branches einen eigenen Pipeline-Job. Dies ermöglicht es, dass main- und Feature-Branches ihre eigenen Pipeline-Definitionen verwenden können, während sie unter einem gemeinsamen übergeordneten Projekt verwaltet werden.
In diesem Lab bereiten Sie ein kleines lokales Git-Repository mit zwei Branches vor, erstellen eine Multibranch-Pipeline über das Jenkins-Dashboard, scannen das Repository und vergleichen die Konsolenausgaben der einzelnen erkannten Branches.
Vorbereiten eines Git-Repositorys mit zwei Branches
In diesem Schritt bereiten Sie ein kleines Git-Repository vor, das von Jenkins gescannt werden kann. Das Repository befindet sich innerhalb des Jenkins-Containers, sodass der Jenkins-Controller darauf zugreifen kann, ohne von GitHub oder einem anderen externen Dienst abhängig zu sein.
Führen Sie diesen Befehl im Terminal aus, um den main-Branch mit einer Jenkinsfile zu erstellen:
docker exec jenkins bash -lc '
set -e
rm -rf /var/jenkins_home/multibranch-src /var/jenkins_home/multibranch-demo.git
mkdir -p /var/jenkins_home/multibranch-src
cd /var/jenkins_home/multibranch-src
git init -b main
git config user.email "jenkins@example.com"
git config user.name "Jenkins Multibranch"
cat > Jenkinsfile <<'"'"'EOF'"'"'
pipeline {
agent any
stages {
stage("Branch Info") {
steps {
echo "Running main branch pipeline"
sh "echo BRANCH_NAME=${BRANCH_NAME}"
}
}
}
}
EOF
git add Jenkinsfile
git commit -m "Add main branch Jenkinsfile"
'
Erstellen Sie nun einen feature/demo-Branch mit einer anderen Pipeline-Nachricht und veröffentlichen Sie beide Branches in einem Bare-Repository:
docker exec jenkins bash -lc '
set -e
cd /var/jenkins_home/multibranch-src
git checkout -b feature/demo
sed -i "s/Running main branch pipeline/Running feature demo pipeline/" Jenkinsfile
git add Jenkinsfile
git commit -m "Customize feature branch Jenkinsfile"
git init --bare --initial-branch=main /var/jenkins_home/multibranch-demo.git
git remote add origin /var/jenkins_home/multibranch-demo.git
git push origin main
git push origin feature/demo
touch /var/jenkins_home/multibranch-demo.git/git-daemon-export-ok
if [ -f /tmp/multibranch-git-daemon.pid ]; then
kill "$(cat /tmp/multibranch-git-daemon.pid)" 2>/dev/null || true
rm -f /tmp/multibranch-git-daemon.pid
fi
git daemon --reuseaddr --base-path=/var/jenkins_home --export-all --detach --pid-file=/tmp/multibranch-git-daemon.pid /var/jenkins_home
'
Notieren Sie die Branches, die Jenkins scannen wird:
docker exec jenkins git --git-dir=/var/jenkins_home/multibranch-demo.git branch -a | tee /home/labex/project/multibranch-branches.txt
Sie sollten beide Branches sehen:
feature/demo
* main
Erstellen eines Multibranch-Pipeline-Projekts
In diesem Schritt erstellen Sie ein Multibranch-Pipeline-Projekt über das Jenkins-Dashboard. Das Projekt scannt git://localhost/multibranch-demo.git und sucht in jedem Branch nach einer Datei namens Jenkinsfile.
Öffnen Sie die Desktop-Oberfläche. Firefox öffnet Jenkins automatisch. Falls nicht, rufen Sie http://localhost:8080 auf.
Vom Jenkins-Dashboard aus:
Klicken Sie auf New Item, geben Sie multibranch-demo ein, wählen Sie Multibranch Pipeline und klicken Sie auf OK.
Auf der Konfigurationsseite:
Klicken Sie unter Branch Sources auf Add source und wählen Sie Git.
Füllen Sie die Git-Quelle mit folgenden Werten aus:
Project Repository:git://localhost/multibranch-demo.gitCredentials:- none -
Lassen Sie Behaviors bei der Standardeinstellung für die Branch-Erkennung. Behalten Sie unter Build Configuration den Mode als by Jenkinsfile und den Script Path als Jenkinsfile bei.
Klicken Sie auf Save.
Führen Sie diesen Befehl aus, um die wichtige gespeicherte Konfiguration zu protokollieren:
docker exec jenkins sh -lc "grep -n -E 'WorkflowMultiBranchProject|git://localhost/multibranch-demo.git|<scriptPath>Jenkinsfile</scriptPath>' /var/jenkins_home/jobs/multibranch-demo/config.xml" | tee /home/labex/project/multibranch-config-lines.txt
Scannen der Repository-Branches
In diesem Schritt führen Sie die Branch-Indizierung über das Jenkins-Dashboard aus. Die Branch-Indizierung durchsucht das Git-Repository, findet Branches mit einer Jenkinsfile und erstellt untergeordnete Jobs für diese Branches.
Klicken Sie auf der Projektseite von multibranch-demo auf Scan Multibranch Pipeline Now.
Warten Sie, bis die Seite die untergeordneten Jobs für main und feature/demo anzeigt. Jenkins startet möglicherweise automatisch den ersten Build für jeden erkannten Branch.
Führen Sie diesen Befehl aus, um die erkannten untergeordneten Jobs zu protokollieren:
curl -fsS http://localhost:8080/job/multibranch-demo/api/json | grep -o '"name":"[^"]*"' | tee /home/labex/project/multibranch-discovered-jobs.txt
Die Ausgabe sollte beide Branch-Jobs enthalten:
"name":"main"
"name":"feature%2Fdemo"
Überprüfen der Branch-Builds
In diesem Schritt bestätigen Sie, dass Jenkins jeden erkannten Branch bauen kann. Eine Multibranch-Pipeline verwaltet jeden Branch als eigenen untergeordneten Pipeline-Job.
Öffnen Sie den Job des main-Branches von der multibranch-demo-Seite aus. Wenn bereits ein Build läuft, warten Sie, bis er abgeschlossen ist. Wenn noch kein Build existiert, klicken Sie auf Build Now.
Kehren Sie zu multibranch-demo zurück, öffnen Sie den Job des feature/demo-Branches und verfahren Sie ebenso.
Beide Branch-Jobs sollten einen erfolgreichen letzten Build aufweisen.
Führen Sie diesen Befehl aus, um den letzten erfolgreichen Build für jeden Branch zu protokollieren:
python3 - <<'PY' | tee /home/labex/project/multibranch-build-results.txt
import json
import urllib.request
for url_name, display in [('main', 'main'), ('feature%252Fdemo', 'feature/demo')]:
with urllib.request.urlopen(f'http://localhost:8080/job/multibranch-demo/job/{url_name}/lastBuild/api/json') as response:
data = json.load(response)
print(f'{display}: {data["result"]}')
PY
Sie sollten Folgendes sehen:
main: SUCCESS
feature/demo: SUCCESS
Vergleichen der Branch-Pipeline-Ausgabe
In diesem Schritt vergleichen Sie die Konsolenausgabe der beiden Branch-Builds. Da der main-Branch und der feature/demo-Branch unterschiedliche Nachrichten in ihren Jenkinsfiles verwenden, belegen die Protokolle, dass Jenkins die korrekte, branch-spezifische Pipeline ausgeführt hat.
Öffnen Sie den letzten Build des main-Branches und klicken Sie auf Console Output. Dort sollte Running main branch pipeline stehen.
Öffnen Sie dann den letzten Build des feature/demo-Branches und klicken Sie auf Console Output. Dort sollte Running feature demo pipeline stehen.
Führen Sie diesen Befehl aus, um denselben Konsolen-Nachweis zu speichern:
curl -fsS http://localhost:8080/job/multibranch-demo/job/main/lastBuild/consoleText | grep 'Running main branch pipeline' | tee /home/labex/project/multibranch-console-lines.txt
curl -fsS http://localhost:8080/job/multibranch-demo/job/feature%252Fdemo/lastBuild/consoleText | grep 'Running feature demo pipeline' | tee -a /home/labex/project/multibranch-console-lines.txt
Zusammenfassung
Sie haben ein lokales Git-Repository mit zwei Branches vorbereitet, eine Jenkins Multibranch-Pipeline über das Dashboard erstellt, das Repository gescannt, bestätigt, dass beide Branch-Jobs erfolgreich gebaut wurden, und die branch-spezifischen Pipeline-Ausgaben verglichen.