Introdução
Muitas instalações do Jenkins executam builds em ambientes baseados em contêineres. Nesta imagem do LabEx, o próprio Jenkins é executado em um contêiner Docker. O controlador não expõe o socket do Docker do host para os builds, portanto, este laboratório foca nas evidências práticas que um Pipeline pode coletar de um contexto de execução baseado em contêiner sem precisar baixar imagens externas.
Neste laboratório, você inspecionará a imagem local do Jenkins, criará um job de Pipeline que verifica evidências do contêiner, executará o build e verificará a saída do console.
Inspecionar Imagens de Contêiner Disponíveis
Nesta etapa, você inspecionará as imagens Docker locais no host da VM. O contêiner do controlador Jenkins foi iniciado a partir da imagem local jenkins/jenkins:latest, e o build do Pipeline será executado dentro desse ambiente Jenkins baseado em contêiner.
Liste as imagens disponíveis:
docker images --format '{{.Repository}}:{{.Tag}}' | sort
Inspecione o contêiner do Jenkins em execução:
docker ps --filter name=jenkins --format 'container={{.Names}} image={{.Image}} status={{.Status}}'
Você deverá ver jenkins/jenkins:latest e um contêiner em execução chamado jenkins.
Escrever um Pipeline com Consciência de Contêiner
Nesta etapa, você escreverá um script de Pipeline que verifica seu ambiente de execução. O arquivo /.dockerenv geralmente está presente dentro de contêineres Docker. O Pipeline também imprime o hostname, o workspace e os detalhes do sistema operacional.
Crie o script do 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
Imprima o script para revisar o stage e o passo shell:
nl -ba /home/labex/project/container-agent-pipeline.groovy
Criar o Job de Pipeline
Nesta etapa, você criará um job de Pipeline do Jenkins chamado container-agent-demo. O Python fará o escape XML do script Groovy e escreverá a configuração do job de Pipeline.
Gere a configuração do job do 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
Copie o job para o Jenkins e recarregue:
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
Confirme se o Jenkins consegue carregar o job:
curl -fsS http://localhost:8080/job/container-agent-demo/api/json | grep -o '"name":"container-agent-demo"'
Executar o Pipeline com Consciência de Contêiner
Nesta etapa, você executará o Pipeline e aguardará o Jenkins finalizar o build #1.
Dispare o 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
Aguarde a conclusão do 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
Confirme o resultado:
curl -fsS http://localhost:8080/job/container-agent-demo/1/api/json | grep -o '"result":"SUCCESS"'
Inspecionar Evidências de Execução no Contêiner
Nesta etapa, você inspecionará a saída do console. As evidências importantes são INSIDE_CONTAINER=true, o hostname do contêiner e o caminho do workspace do Jenkins.
Imprima as linhas principais do console:
curl -fsS http://localhost:8080/job/container-agent-demo/1/consoleText | grep -E 'INSIDE_CONTAINER|Container hostname|Workspace|PRETTY_NAME|Finished: SUCCESS'
Abra o Firefox a partir da interface da Área de Trabalho e visite http://localhost:8080/job/container-agent-demo/1/console. A página do console deve mostrar o marcador do contêiner e as informações do workspace.
Resumo
Você inspecionou a imagem local do contêiner Jenkins, criou um job de Pipeline com consciência de contêiner, executou-o e verificou as evidências de execução do contêiner a partir da saída do console do Jenkins. Você também aprendeu por que este ambiente LabEx valida a execução baseada em contêiner sem depender de downloads de imagens externas ou de um socket Docker montado.