Introduction
Jenkins démarre normalement en tant que contrôleur non initialisé. Le premier administrateur déverrouille le contrôleur à l'aide du mot de passe initial, crée un compte administrateur permanent et confirme que Jenkins est prêt à être utilisé.
Dans ce laboratoire, vous allez pratiquer ce flux de travail de premier lancement en toute sécurité. Le service Jenkins principal de la machine virtuelle étant déjà configuré pour d'autres laboratoires, vous allez démarrer un second contrôleur Jenkins temporaire sur le port 18080. Vous n'initialiserez que ce contrôleur temporaire, vérifierez le résultat, puis le supprimerez.
Démarrer un contrôleur Jenkins isolé et vierge
Dans cette étape, vous allez démarrer un nouveau contrôleur Jenkins sans modifier le service Jenkins principal. Un contrôleur Jenkins stocke sa configuration sous /var/jenkins_home, c'est pourquoi ce laboratoire utilise un volume Docker séparé nommé jenkins-init-lab-home.
La commande docker run ci-dessous démarre le contrôleur temporaire en arrière-plan. L'option -d active le mode détaché, --name donne au conteneur un nom stable, -p 18080:8080 publie Jenkins sur le port hôte 18080, et -v attache le volume isolé du répertoire Jenkins.
docker run -d \
--name jenkins-init-lab \
-p 18080:8080 \
-v jenkins-init-lab-home:/var/jenkins_home \
jenkins/jenkins:latest
Docker affiche l'ID du nouveau conteneur. L'ID exact étant différent à chaque fois, toute valeur hexadécimale longue est acceptable.
Ensuite, attendez que Jenkins commence à répondre aux requêtes HTTP. La boucle ci-dessous interroge le contrôleur local sur /login jusqu'à ce qu'il renvoie un code d'état HTTP. Une réponse 200 signifie que la page de connexion 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
Vous devriez voir le message d'attente quelques fois, puis l'invite de commande réapparaîtra. Confirmez le conteneur et le mappage des ports :
docker ps --filter name=jenkins-init-lab --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'
La sortie doit inclure le nom du conteneur et le port 18080 :
NAMES STATUS PORTS
jenkins-init-lab Up ... 0.0.0.0:18080->8080/tcp, ...
Récupérer le mot de passe administrateur initial
Dans cette étape, vous allez récupérer le mot de passe à usage unique que Jenkins crée pour le premier administrateur. Jenkins stocke ce mot de passe dans le répertoire racine du contrôleur, à l'emplacement /var/jenkins_home/secrets/initialAdminPassword.
Utilisez docker exec pour exécuter cat à l'intérieur du conteneur Jenkins temporaire, puis enregistrez le mot de passe dans votre répertoire de projet :
docker exec jenkins-init-lab cat /var/jenkins_home/secrets/initialAdminPassword > /home/labex/project/jenkins-init-password.txt
La commande utilise la redirection > pour écrire la sortie de la commande dans un fichier. Cela permet de garder le mot de passe disponible pour les étapes suivantes sans dépendre d'une variable shell.
Affichez uniquement les premiers caractères pour confirmer que le fichier n'est pas vide sans exposer la valeur complète dans l'historique de votre terminal :
cut -c1-8 /home/labex/project/jenkins-init-password.txt
Vous devriez voir huit caractères du mot de passe, similaires à ceci :
1a2b3c4d
Créer un compte administrateur permanent
Dans cette étape, vous utiliserez le mot de passe initial pour créer un véritable administrateur Jenkins nommé lab-admin. Le mot de passe initial n'est destiné qu'à la configuration. Un compte administrateur normal est ce que les équipes utilisent une fois le contrôleur initialisé.
Jenkins protège les soumissions de formulaires avec un jeton "crumb". Un crumb est lié à la même session de navigateur ou HTTP qui l'a demandé, donc la commande ci-dessous enregistre également les cookies Jenkins dans un fichier de stockage 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
La commande suivante envoie un petit script Groovy à Jenkins. Le script crée un domaine de sécurité privé, ajoute l'utilisateur lab-admin, accorde un contrôle total aux utilisateurs connectés et marque l'assistant de configuration comme terminé.
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
Lisez le fichier de résultat :
cat /home/labex/project/jenkins-init-result.txt
Le message attendu est :
created lab-admin and completed setup
Confirmer le tableau de bord du contrôleur initialisé
Dans cette étape, vous confirmerez que le contrôleur temporaire n'est plus seulement un écran de déverrouillage. Un contrôleur initialisé correctement doit authentifier l'utilisateur lab-admin et renvoyer la page principale de Jenkins.
Utilisez curl avec -u pour vous authentifier. L'option -o écrit le HTML dans un fichier, et -w '%{http_code}' affiche uniquement le code d'état HTTP.
curl -s -u 'lab-admin:LabEx-Admin-123' \
-o /home/labex/project/jenkins-init-dashboard.html \
-w '%{http_code}\n' \
http://localhost:18080/
Le code d'état doit être :
200
Recherchez maintenant dans la page du tableau de bord enregistrée le texte stable de Jenkins :
grep -o -E 'Dashboard|Welcome to Jenkins|Jenkins' /home/labex/project/jenkins-init-dashboard.html | head
Vous devriez voir au moins une ligne correspondante. Le HTML exact peut varier selon les versions de Jenkins, mais il doit identifier la page comme étant Jenkins.
Arrêter et supprimer le contrôleur jetable
Dans cette étape, vous allez nettoyer le contrôleur temporaire. Ce nettoyage est important car le service Jenkins principal est celui utilisé par le reste des laboratoires Jenkins, et le contrôleur temporaire n'était destiné qu'à pratiquer l'initialisation au premier lancement.
Arrêtez et supprimez d'abord le conteneur temporaire :
docker rm -f jenkins-init-lab
Ensuite, supprimez son volume racine Jenkins isolé :
docker volume rm jenkins-init-lab-home
Enfin, prouvez que le contrôleur temporaire a disparu :
docker ps -a --filter name=jenkins-init-lab --format '{{.Names}}'
Cette commande ne devrait rien afficher. Un résultat vide signifie qu'aucun conteneur portant ce nom ne subsiste.
Résumé
Vous avez démarré un contrôleur Jenkins isolé, récupéré son mot de passe administrateur initial à usage unique, créé un compte administrateur permanent, confirmé que le tableau de bord initialisé était accessible et nettoyé le contrôleur temporaire. Il s'agit du flux de travail d'initialisation de base pour tout contrôleur Jenkins utilisable.