Introducción
Normalmente, Jenkins se inicia como un controlador sin inicializar. El primer administrador desbloquea el controlador con la contraseña inicial, crea una cuenta de administrador permanente y confirma que Jenkins está listo para trabajar.
En este laboratorio, practicará ese flujo de trabajo de primera ejecución de forma segura. El servicio principal de Jenkins en la máquina virtual ya está configurado para otros laboratorios, por lo que iniciará un segundo controlador Jenkins temporal en el puerto 18080. Inicializará solo ese controlador temporal, verificará el resultado y luego lo eliminará.
Iniciar un controlador Jenkins nuevo y aislado
En este paso, iniciará un nuevo controlador Jenkins sin modificar el servicio principal de Jenkins. Un controlador Jenkins almacena su configuración en /var/jenkins_home, por lo que este laboratorio utiliza un volumen de Docker independiente llamado jenkins-init-lab-home.
El comando docker run a continuación inicia el controlador temporal en segundo plano. La opción -d significa modo separado (detached), --name le da al contenedor un nombre estable, -p 18080:8080 publica Jenkins en el puerto 18080 del host, y -v adjunta el volumen de inicio aislado de Jenkins.
docker run -d \
--name jenkins-init-lab \
-p 18080:8080 \
-v jenkins-init-lab-home:/var/jenkins_home \
jenkins/jenkins:latest
Docker imprimirá el nuevo ID del contenedor. El ID exacto es diferente cada vez, por lo que cualquier valor hexadecimal largo es aceptable.
A continuación, espere hasta que Jenkins comience a responder a las solicitudes HTTP. El bucle siguiente consulta al controlador local en /login hasta que devuelve un código de estado HTTP. Una respuesta 200 significa que la página de inicio de sesión está disponible.
until [ "$(curl -s -o /dev/null -w '%{http_code}' http://localhost:18080/login)" = "200" ]; do
echo "Waiting for the temporary Jenkins controller..."
sleep 5
done
Debería ver el mensaje de espera un par de veces, luego volverá el prompt. Confirme el contenedor y el mapeo de puertos:
docker ps --filter name=jenkins-init-lab --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'
La salida debería incluir el nombre del contenedor y el puerto 18080:
NAMES STATUS PORTS
jenkins-init-lab Up ... 0.0.0.0:18080->8080/tcp, ...
Recuperar la contraseña de administrador inicial
En este paso, recuperará la contraseña de un solo uso que Jenkins crea para el primer administrador. Jenkins almacena esta contraseña dentro del directorio de inicio del controlador en /var/jenkins_home/secrets/initialAdminPassword.
Utilice docker exec para ejecutar cat dentro del contenedor temporal de Jenkins, luego guarde la contraseña en el directorio de su proyecto:
docker exec jenkins-init-lab cat /var/jenkins_home/secrets/initialAdminPassword > /home/labex/project/jenkins-init-password.txt
El comando utiliza la redirección > para escribir la salida del comando en un archivo. Esto mantiene la contraseña disponible para los siguientes pasos sin depender de una variable de shell.
Muestre solo los primeros caracteres para confirmar que el archivo no está vacío sin exponer el valor completo en el historial de su terminal:
cut -c1-8 /home/labex/project/jenkins-init-password.txt
Debería ver ocho caracteres de la contraseña, similares a estos:
1a2b3c4d
Crear una cuenta de administrador permanente
En este paso, utilizará la contraseña inicial para crear un administrador de Jenkins real llamado lab-admin. La contraseña inicial solo está destinada a la configuración. Una cuenta de administrador normal es lo que los equipos utilizan después de que el controlador se ha inicializado.
Jenkins protege los envíos de formularios con un token crumb. Un crumb está vinculado a la misma sesión de navegador o HTTP que lo solicitó, por lo que el comando a continuación también guarda las cookies de Jenkins en un archivo de almacenamiento de cookies.
INIT_PASSWORD=$(tr -d '\r\n' < /home/labex/project/jenkins-init-password.txt)
COOKIE_JAR=/home/labex/project/jenkins-init-cookies.txt
curl -fsS -c "${COOKIE_JAR}" -u "admin:${INIT_PASSWORD}" \
http://localhost:18080/crumbIssuer/api/json \
> /home/labex/project/jenkins-init-crumb.json
El siguiente comando envía un pequeño script de Groovy a Jenkins. El script crea un dominio de seguridad privado, añade el usuario lab-admin, otorga control total a los usuarios registrados y marca el asistente de configuración como completado.
CRUMB_FIELD=$(sed -n 's/.*"crumbRequestField":"\([^"]*\)".*/\1/p' /home/labex/project/jenkins-init-crumb.json)
CRUMB_VALUE=$(sed -n 's/.*"crumb":"\([^"]*\)".*/\1/p' /home/labex/project/jenkins-init-crumb.json)
cat > /home/labex/project/initialize-controller.groovy <<'GROOVY'
import jenkins.model.Jenkins
import jenkins.install.InstallState
import hudson.security.HudsonPrivateSecurityRealm
import hudson.security.FullControlOnceLoggedInAuthorizationStrategy
def jenkins = Jenkins.get()
def realm = new HudsonPrivateSecurityRealm(false)
realm.createAccount('lab-admin', 'LabEx-Admin-123')
jenkins.setSecurityRealm(realm)
def strategy = new FullControlOnceLoggedInAuthorizationStrategy()
strategy.setAllowAnonymousRead(false)
jenkins.setAuthorizationStrategy(strategy)
jenkins.setInstallState(InstallState.INITIAL_SETUP_COMPLETED)
jenkins.save()
println('created lab-admin and completed setup')
GROOVY
curl -fsS -b "${COOKIE_JAR}" -u "admin:${INIT_PASSWORD}" \
-H "${CRUMB_FIELD}: ${CRUMB_VALUE}" \
--data-urlencode "script@/home/labex/project/initialize-controller.groovy" \
http://localhost:18080/scriptText \
> /home/labex/project/jenkins-init-result.txt
Lea el archivo de resultados:
cat /home/labex/project/jenkins-init-result.txt
El mensaje esperado es:
created lab-admin and completed setup
Confirmar el panel de control del controlador inicializado
En este paso, confirmará que el controlador temporal ya no es solo una pantalla de desbloqueo. Un controlador inicializado correctamente debería autenticar al usuario lab-admin y devolver la página principal de Jenkins.
Utilice curl con -u para autenticarse. La opción -o escribe el HTML en un archivo, y -w '%{http_code}' imprime solo el código de estado HTTP.
curl -s -u 'lab-admin:LabEx-Admin-123' \
-o /home/labex/project/jenkins-init-dashboard.html \
-w '%{http_code}\n' \
http://localhost:18080/
El código de estado debería ser:
200
Ahora busque en la página del panel guardada el texto estable de Jenkins:
grep -o -E 'Dashboard|Welcome to Jenkins|Jenkins' /home/labex/project/jenkins-init-dashboard.html | head
Debería ver al menos una línea coincidente. El HTML exacto puede cambiar entre versiones de Jenkins, pero debería identificar la página como Jenkins.
Detener y eliminar el controlador desechable
En este paso, limpiará el controlador temporal. La limpieza es importante porque el servicio principal de Jenkins es el que utilizan el resto de los laboratorios de Jenkins, y el controlador temporal era solo para practicar la inicialización de la primera ejecución.
Primero, detenga y elimine el contenedor temporal:
docker rm -f jenkins-init-lab
Luego, elimine su volumen de inicio de Jenkins aislado:
docker volume rm jenkins-init-lab-home
Finalmente, demuestre que el controlador temporal ha desaparecido:
docker ps -a --filter name=jenkins-init-lab --format '{{.Names}}'
Este comando no debería imprimir nada. Un resultado vacío significa que no queda ningún contenedor con ese nombre.
Resumen
Ha iniciado un controlador Jenkins aislado, recuperado su contraseña de administrador inicial de un solo uso, creado una cuenta de administrador permanente, confirmado que el panel de control inicializado era accesible y limpiado el controlador temporal. Este es el flujo de trabajo central de inicialización de primera ejecución detrás de un controlador Jenkins utilizable.