LabEx
LoginBeitreten

Sichern und Wiederherstellen der Jenkins-Konfiguration

Beginner

Einführung

Jenkins speichert den Großteil der Controller- und Job-Konfigurationen als Dateien unter JENKINS_HOME. Ein praxistauglicher Backup-Plan muss die Dateien erfassen, die Jobs und Controller-Einstellungen definieren. Ein Wiederherstellungsplan muss zudem nachweisen, dass Jenkins die wiederhergestellten Dateien korrekt laden kann.

In diesem Lab erstellen Sie einen Beispiel-Job, sichern dessen config.xml, löschen den Job, stellen ihn aus einem tar-Archiv wieder her, laden Jenkins neu und verifizieren, dass der Job wieder ordnungsgemäß funktioniert.

Erstellen eines Jenkins-Status für das Backup

In diesem Schritt erstellen Sie einen Freestyle-Job namens backup-restore-demo. Dies liefert Ihnen eine echte Jenkins-Konfigurationsdatei, die Sie sichern und wiederherstellen können.

Schreiben Sie die Job-Konfiguration:

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

Kopieren Sie den Job in Jenkins und laden Sie die Konfiguration neu:

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

Bestätigen Sie, dass Jenkins den Job laden kann:

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

Sichern der Job-Konfiguration

In diesem Schritt kopieren Sie die Job-Konfiguration aus dem Jenkins-Container und archivieren sie. Das Backup behält den relativen Pfad jobs/backup-restore-demo/config.xml bei, was den Wiederherstellungspfad eindeutig macht.

Erstellen Sie ein Arbeitsverzeichnis für das Backup und kopieren Sie die Job-Konfiguration:

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

Erstellen Sie ein komprimiertes tar-Archiv:

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

Listen Sie den Inhalt des Archivs auf:

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

Die Ausgabe sollte Folgendes enthalten:

jobs/backup-restore-demo/config.xml

Löschen des Jobs zur Simulation eines Datenverlusts

In diesem Schritt löschen Sie den Job aus Jenkins. Dies simuliert ein versehentliches Löschen und bietet Ihnen ein klares Ziel für die Wiederherstellung.

Entfernen Sie das Job-Verzeichnis und laden Sie Jenkins neu:

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

Bestätigen Sie, dass der Job nicht mehr erreichbar ist. Der folgende Befehl behandelt eine 404-Antwort für diese Prüfung absichtlich als Erfolg:

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

Wiederherstellen des Jobs aus dem Backup

In diesem Schritt entpacken Sie das Backup-Archiv, kopieren das wiederhergestellte Job-Verzeichnis zurück in Jenkins und laden den Controller neu.

Entpacken Sie das Archiv in ein Wiederherstellungsverzeichnis:

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

Kopieren Sie das wiederhergestellte Job-Verzeichnis in Jenkins und laden Sie neu:

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

Bestätigen Sie, dass Jenkins den wiederhergestellten Job laden kann:

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

Ausführen des wiederhergestellten Jobs

In diesem Schritt führen Sie den wiederhergestellten Job aus. Eine Wiederherstellung ist nur dann nützlich, wenn Jenkins die wiederhergestellte Konfiguration laden und ausführen kann.

Starten Sie den Build. Jenkins gibt zunächst ein Warteschlangen-Element zurück, speichern Sie daher die Antwort-Header und lesen Sie den Location-Header aus:

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}"

Warten Sie, bis das Element in der Warteschlange zu einem tatsächlichen Build wird. Jenkins benötigt möglicherweise einige Sekunden in einer Ruhephase, bevor die endgültige Build-Nummer zugewiesen wird:

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}"

Warten Sie, bis der Build abgeschlossen ist:

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

Überprüfen Sie die Konsolenausgabe:

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

Öffnen Sie Firefox über die Desktop-Oberfläche und besuchen Sie die Konsolen-URL für die Build-Nummer, die in Ihrem Terminal angezeigt wird, z. B. http://localhost:8080/job/backup-restore-demo/2/console. Die Konsolenseite sollte zeigen, dass der wiederhergestellte Job erfolgreich ausgeführt wurde.

Jenkins wiederhergestellte Job-Konsolenausgabe

Zusammenfassung

Sie haben eine Jenkins-Konfiguration erstellt, die eine Sicherung wert ist, die config.xml eines Jobs archiviert, den Job gelöscht, ihn aus dem Backup-Archiv wiederhergestellt, Jenkins neu geladen und den wiederhergestellten Job durch einen erfolgreichen Build-Lauf verifiziert.