Introduction
De nombreuses installations Jenkins exécutent des builds dans des environnements basés sur des conteneurs. Dans cette image LabEx, Jenkins lui-même s'exécute dans un conteneur Docker. Le contrôleur n'expose pas le socket Docker de l'hôte aux builds ; ce laboratoire se concentre donc sur les preuves concrètes qu'un pipeline peut collecter à partir d'un contexte d'exécution conteneurisé, sans avoir à extraire d'images externes.
Dans ce laboratoire, vous inspecterez l'image Jenkins locale, créerez un job de pipeline qui vérifie les preuves de conteneurisation, lancerez la build et vérifierez la sortie de la console.
Inspection des images de conteneurs disponibles
Dans cette étape, vous allez inspecter les images Docker locales sur l'hôte de la machine virtuelle. Le conteneur du contrôleur Jenkins a été démarré à partir de l'image locale jenkins/jenkins:latest, et la build du pipeline s'exécutera à l'intérieur de cet environnement Jenkins conteneurisé.
Listez les images disponibles :
docker images --format '{{.Repository}}:{{.Tag}}' | sort
Inspectez le conteneur Jenkins en cours d'exécution :
docker ps --filter name=jenkins --format 'container={{.Names}} image={{.Image}} status={{.Status}}'
Vous devriez voir jenkins/jenkins:latest et un conteneur en cours d'exécution nommé jenkins.
Rédaction d'un pipeline conscient du conteneur
Dans cette étape, vous allez écrire un script de pipeline qui vérifie son environnement d'exécution. Le fichier /.dockerenv est généralement présent à l'intérieur des conteneurs Docker. Le pipeline affiche également le nom d'hôte, l'espace de travail et les détails du système d'exploitation.
Créez le script du pipeline :
cat > /home/labex/project/container-agent-pipeline.groovy <<'GROOVY'
node {
stage('Container Context') {
echo 'Checking container-backed Jenkins execution context'
sh '''
set -e
echo "Container marker:"
test -f /.dockerenv && echo "INSIDE_CONTAINER=true"
echo "Container hostname: $(hostname)"
echo "Workspace: $WORKSPACE"
grep '^PRETTY_NAME=' /etc/os-release
'''
}
}
GROOVY
Affichez le script pour examiner l'étape et la commande shell :
nl -ba /home/labex/project/container-agent-pipeline.groovy
Création du job de pipeline
Dans cette étape, vous allez créer un job de pipeline Jenkins nommé container-agent-demo. Python se chargera d'échapper les caractères XML du script Groovy et d'écrire la configuration du job de pipeline.
Générez la configuration du job Jenkins :
python3 - <<'PY'
from html import escape
from pathlib import Path
script = Path("/home/labex/project/container-agent-pipeline.groovy").read_text()
config = f"""<?xml version='1.1' encoding='UTF-8'?>
<flow-definition plugin="workflow-job">
<actions/>
<description>Capture container execution evidence from a Pipeline build.</description>
<keepDependencies>false</keepDependencies>
<properties/>
<definition class="org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition" plugin="workflow-cps">
<script>{escape(script)}</script>
<sandbox>true</sandbox>
</definition>
<triggers/>
<disabled>false</disabled>
</flow-definition>
"""
Path("/home/labex/project/container-agent-demo-config.xml").write_text(config)
PY
Copiez le job dans Jenkins et rechargez la configuration :
docker exec jenkins mkdir -p /var/jenkins_home/jobs/container-agent-demo
docker cp /home/labex/project/container-agent-demo-config.xml jenkins:/var/jenkins_home/jobs/container-agent-demo/config.xml
CRUMB=$(curl -fsS -c /tmp/jenkins-container-reload.cookies 'http://localhost:8080/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
curl -fsS -b /tmp/jenkins-container-reload.cookies -H "$CRUMB" -X POST http://localhost:8080/reload >/dev/null || true
sleep 5
Confirmez que Jenkins peut charger le job :
curl -fsS http://localhost:8080/job/container-agent-demo/api/json | grep -o '"name":"container-agent-demo"'
Exécution du pipeline conscient du conteneur
Dans cette étape, vous allez exécuter le pipeline et attendre que Jenkins termine la build #1.
Déclenchez la build :
CRUMB=$(curl -fsS -c /tmp/jenkins-container-build.cookies 'http://localhost:8080/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
curl -fsS -b /tmp/jenkins-container-build.cookies -H "$CRUMB" -X POST http://localhost:8080/job/container-agent-demo/build
Attendez la fin de la build :
until curl -fsS http://localhost:8080/job/container-agent-demo/1/api/json >/tmp/container-agent-build-1.json 2>/dev/null && grep -q '"building":false' /tmp/container-agent-build-1.json; do
echo "Waiting for container-aware pipeline build #1..."
sleep 3
done
Confirmez le résultat :
curl -fsS http://localhost:8080/job/container-agent-demo/1/api/json | grep -o '"result":"SUCCESS"'
Inspection des preuves d'exécution dans le conteneur
Dans cette étape, vous allez inspecter la sortie de la console. Les preuves importantes sont INSIDE_CONTAINER=true, le nom d'hôte du conteneur et le chemin de l'espace de travail Jenkins.
Affichez les lignes clés de la console :
curl -fsS http://localhost:8080/job/container-agent-demo/1/consoleText | grep -E 'INSIDE_CONTAINER|Container hostname|Workspace|PRETTY_NAME|Finished: SUCCESS'
Ouvrez Firefox depuis l'interface de bureau et visitez http://localhost:8080/job/container-agent-demo/1/console. La page de la console devrait afficher le marqueur de conteneur et les informations sur l'espace de travail.
Résumé
Vous avez inspecté l'image du conteneur Jenkins local, créé un job de pipeline conscient du conteneur, l'avez exécuté et avez vérifié les preuves d'exécution dans le conteneur à partir de la sortie de la console Jenkins. Vous avez également appris pourquoi cet environnement LabEx valide l'exécution basée sur des conteneurs sans dépendre d'extractions d'images externes ou d'un socket Docker monté.