Backup e Restauração da Configuração do Jenkins

Introdução

O Jenkins armazena a maior parte da configuração do controlador e dos jobs como arquivos dentro do diretório JENKINS_HOME. Um plano de backup prático deve capturar os arquivos que definem os jobs e as configurações do controlador, e um plano de restauração deve comprovar que o Jenkins consegue carregar os arquivos restaurados.

Neste laboratório, você criará um job de exemplo, fará backup do seu config.xml, excluirá o job, restaurará a partir de um arquivo tar, recarregará o Jenkins e verificará se o job funciona novamente.

Criar um Estado do Jenkins para Backup

Nesta etapa, você criará um job do tipo Freestyle chamado backup-restore-demo. Isso fornecerá um arquivo de configuração real do Jenkins para realizar o backup e a restauração.

Escreva a configuração do 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

Copie o job para o Jenkins e recarregue:

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

Confirme se o Jenkins consegue carregar o job:

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

Fazer Backup da Configuração do Job

Nesta etapa, você copiará a configuração do job para fora do contêiner do Jenkins e a arquivará. O backup mantém o caminho relativo jobs/backup-restore-demo/config.xml, o que torna o caminho de restauração claro.

Crie um diretório de trabalho para o backup e copie a configuração do 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

Crie um arquivo tar compactado:

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

Liste o conteúdo do arquivo:

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

A saída deve incluir:

jobs/backup-restore-demo/config.xml

Excluir o Job para Simular Perda de Dados

Nesta etapa, você excluirá o job do Jenkins. Isso simula uma exclusão acidental e fornece um alvo claro para a restauração.

Remova o diretório do job e recarregue o Jenkins:

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

Confirme que o job não está mais acessível. O comando abaixo trata intencionalmente uma resposta 404 como sucesso para esta verificação:

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

Restaurar o Job a partir do Backup

Nesta etapa, você extrairá o arquivo de backup, copiará o diretório do job restaurado de volta para o Jenkins e recarregará o controlador.

Extraia o arquivo para um diretório de restauração:

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

Copie o diretório do job restaurado para o Jenkins e recarregue:

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

Confirme se o Jenkins consegue carregar o job restaurado:

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

Executar o Job Restaurado

Nesta etapa, você executará o job restaurado. Uma restauração só é útil se o Jenkins conseguir carregar e executar a configuração restaurada.

Acione o build. O Jenkins retorna primeiro um item na fila, portanto, armazene os cabeçalhos da resposta e leia o cabeçalho 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}"

Aguarde até que o item na fila se torne um build real. O Jenkins pode levar alguns segundos em um período de silêncio antes de atribuir o número final do build:

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

Aguarde a conclusão do 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

Inspecione a saída do console:

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

Abra o Firefox na interface da área de trabalho e visite a URL do console para o número do build mostrado no seu terminal, como http://localhost:8080/job/backup-restore-demo/2/console. A página do console deve mostrar o job restaurado sendo executado com sucesso.

Saída do console do job restaurado no Jenkins

Resumo

Você criou uma configuração do Jenkins digna de backup, arquivou o config.xml de um job, excluiu o job, restaurou-o a partir do arquivo de backup, recarregou o Jenkins e verificou o job restaurado executando um build com sucesso.