Introducción
Un Pipeline Multirrama (Multibranch Pipeline) de Jenkins analiza un repositorio de control de versiones, detecta las ramas que contienen un Jenkinsfile y crea un trabajo de Pipeline independiente para cada una de ellas. Esto permite que la rama main y las ramas de características (feature branches) utilicen sus propias definiciones de Pipeline mientras permanecen bajo un mismo proyecto principal.
En este laboratorio, preparará un pequeño repositorio Git local con dos ramas, creará un Pipeline Multirrama desde el panel de control de Jenkins, analizará el repositorio y comparará la salida de la consola de cada rama detectada.
Preparar un repositorio Git con dos ramas
En este paso, preparará un pequeño repositorio Git que Jenkins pueda analizar. El repositorio reside dentro del contenedor de Jenkins, por lo que el controlador de Jenkins puede acceder a él sin depender de GitHub u otro servicio externo.
Ejecute este comando en la terminal para crear la rama main con 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"
'
Ahora cree una rama feature/demo con un mensaje de Pipeline diferente y luego publique ambas ramas en un repositorio vacío (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
'
Registre las ramas que Jenkins analizará:
docker exec jenkins git --git-dir=/var/jenkins_home/multibranch-demo.git branch -a | tee /home/labex/project/multibranch-branches.txt
Debería ver ambas ramas:
feature/demo
* main
Crear un proyecto de Pipeline Multirrama
En este paso, creará un proyecto de Pipeline Multirrama desde el panel de control de Jenkins. El proyecto analizará git://localhost/multibranch-demo.git y buscará un archivo llamado Jenkinsfile en cada rama.
Abra la interfaz de escritorio. Firefox abrirá Jenkins automáticamente. Si no es así, acceda a http://localhost:8080.
Desde el panel de control de Jenkins:
Haga clic en New Item, ingrese multibranch-demo, seleccione Multibranch Pipeline y luego haga clic en OK.
En la página de configuración:
En Branch Sources, haga clic en Add source y seleccione Git.
Complete la fuente Git con estos valores:
Project Repository:git://localhost/multibranch-demo.gitCredentials:- none -
Deje Behaviors con el comportamiento predeterminado de descubrimiento de ramas. En Build Configuration, mantenga Mode como by Jenkinsfile y Script Path como Jenkinsfile.
Haga clic en Save.
Ejecute este comando para registrar la configuración guardada importante:
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
Analizar las ramas del repositorio
En este paso, ejecutará la indexación de ramas desde el panel de control de Jenkins. La indexación de ramas analiza el repositorio Git, encuentra las ramas con un Jenkinsfile y crea trabajos secundarios para esas ramas.
En la página del proyecto multibranch-demo, haga clic en Scan Multibranch Pipeline Now.
Espere hasta que la página muestre los trabajos secundarios para main y feature/demo. Es posible que Jenkins también inicie automáticamente la primera compilación para cada rama descubierta.
Ejecute este comando para registrar los trabajos secundarios descubiertos:
curl -fsS http://localhost:8080/job/multibranch-demo/api/json | grep -o '"name":"[^"]*"' | tee /home/labex/project/multibranch-discovered-jobs.txt
La salida debería incluir ambos trabajos de rama:
"name":"main"
"name":"feature%2Fdemo"
Comprobar las compilaciones de las ramas
En este paso, confirmará que Jenkins puede compilar cada rama descubierta. Un Pipeline Multirrama mantiene cada rama como su propio trabajo de Pipeline secundario.
Abra el trabajo de la rama main desde la página multibranch-demo. Si ya se está ejecutando una compilación, espere a que termine. Si aún no hay ninguna compilación, haga clic en Build Now.
Regrese a multibranch-demo, abra el trabajo de la rama feature/demo y haga lo mismo.
Ambos trabajos de rama deberían tener una compilación reciente exitosa.
Ejecute este comando para registrar la última compilación exitosa de cada rama:
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
Debería ver:
main: SUCCESS
feature/demo: SUCCESS
Comparar la salida del Pipeline de las ramas
En este paso, comparará la salida de la consola de las compilaciones de ambas ramas. La rama main y la rama feature/demo utilizan mensajes diferentes en sus respectivos Jenkinsfiles, por lo que los registros demuestran que Jenkins ejecutó el Pipeline correcto específico para cada rama.
Abra la última compilación de la rama main y haga clic en Console Output. Debería mostrar Running main branch pipeline.
Luego, abra la última compilación de la rama feature/demo y haga clic en Console Output. Debería mostrar Running feature demo pipeline.
Ejecute este comando para guardar la misma evidencia de la consola:
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
Resumen
Ha preparado un repositorio Git local con dos ramas, creado un Pipeline Multirrama de Jenkins desde el panel de control, analizado el repositorio, confirmado que ambos trabajos de rama se compilaron correctamente y comparado la salida del Pipeline específica de cada rama.