LabEx
EntrerRejoindre

Sauvegarde et restauration de la configuration Jenkins

Beginner

Introduction

Jenkins stocke la majeure partie de la configuration du contrôleur et des jobs sous forme de fichiers dans JENKINS_HOME. Un plan de sauvegarde efficace doit capturer les fichiers qui définissent les jobs et les paramètres du contrôleur, et un plan de restauration doit prouver que Jenkins est capable de charger les fichiers restaurés.

Dans ce laboratoire, vous allez créer un job exemple, sauvegarder son fichier config.xml, supprimer le job, le restaurer à partir d'une archive tar, recharger Jenkins et vérifier que le job fonctionne à nouveau.

Créer un état Jenkins à sauvegarder

Dans cette étape, vous allez créer un job de type Freestyle nommé backup-restore-demo. Cela vous fournira un fichier de configuration Jenkins réel à sauvegarder et à restaurer.

Écrivez la configuration du job :

cat > /home/labex/project/backup-restore-demo-config.xml <<'XML'
<?xml version='1.1' encoding='UTF-8'?>
<project>
  <actions/>
  <description>Job used to practice Jenkins backup and restore.</description>
  <keepDependencies>false</keepDependencies>
  <properties/>
  <scm class="hudson.scm.NullSCM"/>
  <canRoam>true</canRoam>
  <disabled>false</disabled>
  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
  <triggers/>
  <concurrentBuild>false</concurrentBuild>
  <builders>
    <hudson.tasks.Shell>
      <command>echo "Restored Jenkins job is running"</command>
      <configuredLocalRules/>
    </hudson.tasks.Shell>
  </builders>
  <publishers/>
  <buildWrappers/>
</project>
XML

Copiez le job dans Jenkins et rechargez la configuration :

docker exec -u root jenkins mkdir -p /var/jenkins_home/jobs/backup-restore-demo
docker cp /home/labex/project/backup-restore-demo-config.xml jenkins:/var/jenkins_home/jobs/backup-restore-demo/config.xml
docker exec -u root jenkins chown -R jenkins:jenkins /var/jenkins_home/jobs/backup-restore-demo
/home/labex/project/reload-jenkins.sh

Confirmez que Jenkins peut charger le job :

curl -fsS http://localhost:8080/job/backup-restore-demo/api/json | grep -o '"name":"backup-restore-demo"'

Sauvegarder la configuration du job

Dans cette étape, vous allez copier la configuration du job hors du conteneur Jenkins et l'archiver. La sauvegarde conserve le chemin relatif jobs/backup-restore-demo/config.xml, ce qui rend le chemin de restauration clair.

Créez un répertoire de travail pour la sauvegarde et copiez la configuration du job :

mkdir -p /home/labex/project/jenkins-backup-work/jobs/backup-restore-demo
docker cp jenkins:/var/jenkins_home/jobs/backup-restore-demo/config.xml /home/labex/project/jenkins-backup-work/jobs/backup-restore-demo/config.xml

Créez une archive tar compressée :

cd /home/labex/project/jenkins-backup-work
tar -czf /home/labex/project/backup-restore-demo.tar.gz jobs/backup-restore-demo/config.xml

Listez le contenu de l'archive :

tar -tzf /home/labex/project/backup-restore-demo.tar.gz

La sortie devrait inclure :

jobs/backup-restore-demo/config.xml

Supprimer le job pour simuler une perte de données

Dans cette étape, vous allez supprimer le job de Jenkins. Cela simule une suppression accidentelle et vous donne une cible de restauration claire.

Supprimez le répertoire du job et rechargez Jenkins :

docker exec -u root jenkins rm -rf /var/jenkins_home/jobs/backup-restore-demo
/home/labex/project/reload-jenkins.sh

Confirmez que le job n'est plus accessible. La commande ci-dessous traite intentionnellement une réponse 404 comme un succès pour cette vérification :

if curl -fsS http://localhost:8080/job/backup-restore-demo/api/json >/dev/null 2>&1; then
  echo "Job still exists"
  exit 1
else
  echo "Job is absent and ready to restore"
fi

Restaurer le job à partir de la sauvegarde

Dans cette étape, vous allez extraire l'archive de sauvegarde, copier le répertoire du job restauré dans Jenkins et recharger le contrôleur.

Extrayez l'archive dans un répertoire de restauration :

rm -rf /home/labex/project/restore-work
mkdir -p /home/labex/project/restore-work
tar -xzf /home/labex/project/backup-restore-demo.tar.gz -C /home/labex/project/restore-work

Copiez le répertoire du job restauré dans Jenkins et rechargez :

docker cp /home/labex/project/restore-work/jobs/backup-restore-demo jenkins:/var/jenkins_home/jobs/backup-restore-demo
docker exec -u root jenkins chown -R jenkins:jenkins /var/jenkins_home/jobs/backup-restore-demo
/home/labex/project/reload-jenkins.sh

Confirmez que Jenkins peut charger le job restauré :

curl -fsS http://localhost:8080/job/backup-restore-demo/api/json | grep -o '"name":"backup-restore-demo"'

Exécuter le job restauré

Dans cette étape, vous allez exécuter le job restauré. Une restauration n'est utile que si Jenkins peut charger et exécuter la configuration restaurée.

Déclenchez le build. Jenkins renvoie d'abord un élément de file d'attente, donc stockez les en-têtes de réponse et lisez l'en-tête Location :

CRUMB=$(curl -fsS -c /tmp/jenkins-backup-build.cookies 'http://localhost:8080/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
curl -fsS -D /tmp/backup-restore-build.headers -o /dev/null -b /tmp/jenkins-backup-build.cookies -H "$CRUMB" -X POST http://localhost:8080/job/backup-restore-demo/build
QUEUE_URL=$(awk 'tolower($1)=="location:" {print $2}' /tmp/backup-restore-build.headers | tr -d '\r')
echo "Jenkins queued the restored job at ${QUEUE_URL}"

Attendez que l'élément en file d'attente devienne un build réel. Jenkins peut passer quelques secondes dans une période de calme avant d'attribuer le numéro de build final :

until BUILD_NUMBER=$(python3 - "$QUEUE_URL" <<'PY'
import json
import sys
import urllib.request

with urllib.request.urlopen(sys.argv[1] + 'api/json') as response:
    data = json.load(response)

executable = data.get('executable')
if not executable:
    raise SystemExit(1)
print(executable['number'])
PY
); do
  echo "Waiting for Jenkins to assign a build number..."
  sleep 3
done

echo "The restored job is running as build #${BUILD_NUMBER}"

Attendez la fin de ce build :

until curl -fsS "http://localhost:8080/job/backup-restore-demo/${BUILD_NUMBER}/api/json" >/tmp/backup-restore-build.json 2>/dev/null && grep -q '"building":false' /tmp/backup-restore-build.json; do
  echo "Waiting for restored job build #${BUILD_NUMBER}..."
  sleep 3
done

Inspectez la sortie de la console :

curl -fsS "http://localhost:8080/job/backup-restore-demo/${BUILD_NUMBER}/consoleText" | grep -E 'Restored Jenkins job is running|Finished: SUCCESS'

Ouvrez Firefox depuis l'interface de bureau et visitez l'URL de la console pour le numéro de build affiché dans votre terminal, par exemple http://localhost:8080/job/backup-restore-demo/2/console. La page de la console devrait montrer que le job restauré s'est exécuté avec succès.

Sortie de la console du job Jenkins restauré

Résumé

Vous avez créé une configuration Jenkins à sauvegarder, archivé le config.xml d'un job, supprimé le job, l'avez restauré à partir de l'archive de sauvegarde, rechargé Jenkins et vérifié le job restauré en effectuant un build réussi.