Introduction
Un pipeline multibranche Jenkins analyse un dépôt de contrôle de version, détecte les branches contenant un Jenkinsfile et crée un job de pipeline distinct pour chaque branche. Cela permet aux branches main et aux branches de fonctionnalités (feature branches) d'utiliser leurs propres définitions de pipeline tout en restant regroupées sous un même projet parent.
Dans ce laboratoire, vous allez préparer un petit dépôt Git local avec deux branches, créer un pipeline multibranche depuis le tableau de bord Jenkins, analyser le dépôt et comparer la sortie console de chaque branche détectée.
Préparation d'un dépôt Git à deux branches
Dans cette étape, vous allez préparer un petit dépôt Git que Jenkins pourra analyser. Le dépôt réside à l'intérieur du conteneur Jenkins afin que le contrôleur Jenkins puisse y accéder sans dépendre de GitHub ou d'un autre service externe.
Exécutez cette commande dans le terminal pour créer la branche main avec un Jenkinsfile :
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"
'
Créez maintenant une branche feature/demo avec un message de pipeline différent, puis publiez les deux branches dans un dépôt nu (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
'
Enregistrez les branches que Jenkins va analyser :
docker exec jenkins git --git-dir=/var/jenkins_home/multibranch-demo.git branch -a | tee /home/labex/project/multibranch-branches.txt
Vous devriez voir les deux branches :
feature/demo
* main
Création d'un projet de pipeline multibranche
Dans cette étape, vous allez créer un projet de pipeline multibranche depuis le tableau de bord Jenkins. Le projet analysera git://localhost/multibranch-demo.git et recherchera un fichier nommé Jenkinsfile dans chaque branche.
Ouvrez l'interface de bureau. Firefox ouvre Jenkins automatiquement. Si ce n'est pas le cas, accédez à http://localhost:8080.
Depuis le tableau de bord Jenkins :
Cliquez sur New Item, saisissez multibranch-demo, sélectionnez Multibranch Pipeline, puis cliquez sur OK.
Sur la page de configuration :
Dans Branch Sources, cliquez sur Add source et sélectionnez Git.
Remplissez les informations de la source Git avec ces valeurs :
Project Repository:git://localhost/multibranch-demo.gitCredentials:- none -
Laissez Behaviors avec le comportement de découverte de branche par défaut. Dans Build Configuration, conservez Mode sur by Jenkinsfile et Script Path sur Jenkinsfile.
Cliquez sur Save.
Exécutez cette commande pour enregistrer la configuration sauvegardée :
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
Analyse des branches du dépôt
Dans cette étape, vous allez lancer l'indexation des branches depuis le tableau de bord Jenkins. L'indexation analyse le dépôt Git, trouve les branches contenant un Jenkinsfile et crée des jobs enfants pour ces branches.
Sur la page du projet multibranch-demo, cliquez sur Scan Multibranch Pipeline Now.
Attendez que la page affiche les jobs enfants pour main et feature/demo. Jenkins peut également démarrer automatiquement le premier build pour chaque branche découverte.
Exécutez cette commande pour enregistrer les jobs enfants découverts :
curl -fsS http://localhost:8080/job/multibranch-demo/api/json | grep -o '"name":"[^"]*"' | tee /home/labex/project/multibranch-discovered-jobs.txt
La sortie doit inclure les deux jobs de branche :
"name":"main"
"name":"feature%2Fdemo"
Vérification des builds de branche
Dans cette étape, vous allez confirmer que Jenkins peut construire chaque branche découverte. Un pipeline multibranche conserve chaque branche comme son propre job de pipeline enfant.
Ouvrez le job de la branche main depuis la page multibranch-demo. Si un build est déjà en cours, attendez qu'il se termine. S'il n'y a pas encore de build, cliquez sur Build Now.
Retournez sur multibranch-demo, ouvrez le job de la branche feature/demo et faites de même.
Les deux jobs de branche devraient avoir un dernier build réussi.
Exécutez cette commande pour enregistrer le dernier build réussi pour chaque branche :
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
Vous devriez voir :
main: SUCCESS
feature/demo: SUCCESS
Comparaison de la sortie du pipeline par branche
Dans cette étape, vous allez comparer la sortie console des deux builds de branche. La branche main et la branche feature/demo utilisent des messages différents dans leurs Jenkinsfiles, les journaux prouvent donc que Jenkins a bien exécuté le pipeline spécifique à chaque branche.
Ouvrez le dernier build de la branche main et cliquez sur Console Output. Il devrait afficher Running main branch pipeline.
Ouvrez ensuite le dernier build de la branche feature/demo et cliquez sur Console Output. Il devrait afficher Running feature demo pipeline.
Exécutez cette commande pour enregistrer les preuves dans la console :
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
Résumé
Vous avez préparé un dépôt Git local avec deux branches, créé un pipeline multibranche Jenkins depuis le tableau de bord, analysé le dépôt, confirmé que les deux jobs de branche ont été construits avec succès et comparé la sortie du pipeline spécifique à chaque branche.