par Docker est sorti vainqueur de la bataille des packages d’applications universels. Tous les principaux systèmes d’exploitation prennent en charge les images Docker, tous les fournisseurs de cloud prennent en charge le déploiement d’images Docker et chaque outil ou plate-forme majeur propose une image Docker officielle. Jenkins ne fait pas exception, fournissant l’image jenkins/jenkins.
Dans cet article, vous apprendrez à exécuter Jenkins à partir d’une image Docker, à la configurer, à la personnaliser et à utiliser l’image en remplacement d’une installation traditionnelle basée sur un package.
Conditions préalables
Pour exécuter une image Docker, vous devez avoir installé Docker. Docker fournit des instructions détaillées pour l’installation sur Linux, macOS et Windows.
Notez que même si les versions récentes de Windows ont acquis une prise en charge native pour l’exécution d’images Docker, Jenkins ne fournit que des images Docker basées sur Linux. Windows et macOS peuvent exécuter des images Docker Linux via la virtualisation, donc la plupart des commandes présentées ici s’appliquent de la même manière à tous les systèmes d’exploitation, mais cet article se concentrera sur Linux.
Premiers pas avec l’image Jenkins Docker
Une fois Docker installé, Jenkins peut être exécuté avec la commande :
docker run -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts-jdk11
Décomposons cette commande pour comprendre ce qu’elle fait.
docker runest utilisé pour exécuter une image Docker en tant que conteneur.
Vous pouvez considérer une image Docker comme un artefact en lecture seule contenant les fichiers dont vous avez besoin pour exécuter une application particulière. Contrairement à la plupart des artefacts d’application, une image Docker contient un système d’exploitation complet et tous les outils système associés requis pour prendre en charge l’application principale en cours d’exécution. Dans le cas de Jenkins, cela signifie que l’image Docker contient les fichiers dont vous avez besoin pour prendre en charge un système d’exploitation Linux minimal, ainsi que la version de Java requise pour exécuter Jenkins.
Un conteneur est un environnement isolé dans le système d’exploitation où l’image Docker est exécutée. Bien que Docker ne fournisse généralement pas le même type de garanties d’isolation que les machines virtuelles, les conteneurs offrent un moyen d’exécuter facilement du code fiable côte à côte.
Les -parguments mappent un port local à un port exposé par le conteneur Docker. Le premier argument est le port local, suivi de deux points, puis du port du conteneur.
Ainsi, l’argument -p 8080:8080mappe le port local 8080 au port 8080 du conteneur (qui est le port Web) et -p 50000:50000mappe le port local 50000 au port 50000 du conteneur (qui est le port de l’agent). Cela signifie que vous pouvez ouvrir http://localhost:8080 sur votre machine locale et que Docker dirige le trafic vers le serveur Web hébergé par le conteneur.
L’argument -v jenkins_home:/var/jenkins_homecrée un volume appelé jenkins_homes’il n’existe pas déjà et le monte sous le chemin /var/jenkins_homeà l’intérieur du conteneur.
Alors que les images Docker sont en lecture seule, les conteneurs Docker exposent un système de fichiers en lecture/écriture permettant à toute application en cours d’exécution de conserver les modifications. Les modifications sont toutefois locales au conteneur et si le conteneur est détruit, les modifications sont perdues. Ou, si vous souhaitez utiliser un conteneur différent, si vous souhaitez effectuer une mise à niveau vers une version plus récente de Jenkins, par exemple, les modifications apportées à votre ancien conteneur sont également perdues.
Les volumes Docker permettent aux conteneurs de conserver les données en dehors du cycle de vie du conteneur et de les partager avec différents conteneurs. Vous pouvez considérer les volumes comme des lecteurs réseau que vous verriez généralement montés dans votre session lorsque vous vous connectez à un réseau d’entreprise. En enregistrant des données mutables sur un volume, vous pouvez détruire et recréer votre conteneur Jenkins, ou créer un nouveau conteneur basé sur une image Docker plus récente, tout en conservant toutes les modifications que vous avez apportées à la configuration Jenkins.
L’argument final jenkins/jenkins:lts-jdk11est le nom de l’image Docker. Cette image particulière peut être trouvée sur Dockerhub, qui est l’un des nombreux registres Docker disponibles pour héberger des images Docker.
Notez que l’image associée à une balise Docker peut changer au fil du temps. De nombreux registres utilisent une balise « flottante » pour représenter la dernière version d’une image. Dans le cas de l’image Jenkins, l’image avec la balise lts-jdk11est mise à jour à chaque version LTS.
Pour vous assurer que votre machine locale dispose de la dernière image, vous devez exécuter manuellement docker pull jenkins/jenkins:lts-jdk11. Sachez cependant que tous les conteneurs existants continueront à utiliser l’ancienne image et que vous devez créer un nouveau conteneur pour référencer toutes les images mises à jour.
Les balises plus spécifiques, comme 2.303.2-lts-jdk11, ne sont généralement pas écrasées, il n’y a donc aucune raison de les exécuter docker pullsur ces images.
Pour afficher le conteneur créé par cette commande, exécutez :
docker container ls
Vous verrez les détails de base du conteneur, ainsi qu’un nom (souvent humoristique) comme nostalgic_tharp:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
801f4e834173 jenkins/jenkins:lts-jdk11 "/sbin/tini -- /usr/…" About a minute ago Up About a minute 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp, 0.0.0.0:50000->50000/tcp, :::50000->50000/tcp nostalgic_tharp
Pour définir le nom du conteneur, passez l’ --nameargument :
docker run -d --name jenkins -p 8080:8080 -p 50000:50000 jenkins/jenkins:lts-jdk11
La première fois que vous démarrez Jenkins, les journaux Docker contiendront un message comme celui-ci :
Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:
1883c809f01b4ed585fb5c3e0156543a
This may also be found at: /var/jenkins_home/secrets/initialAdminPassword
Cette chaîne aléatoire de chiffres et de lettres est le mot de passe administrateur initial, requis pour terminer la configuration de Jenkins.
Ouvrez http://localhost:8080 lorsque vous voyez le message suivant dans les journaux :
Jenkins is fully up and running
Vous avez maintenant la possibilité de terminer la configuration initiale de l’instance Jenkins. Consultez l’article précédent sur l’installation traditionnelle de Jenkins pour plus de détails sur la réalisation de cette configuration initiale.
Vous avez peut-être remarqué que l’exécution de Docker avec la commande ci-dessus attache votre terminal au flux de sortie du conteneur. Pour exécuter l’image Docker en arrière-plan, utilisez l’ argument -dou--detach :
docker run -d -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts-jdk11
Ajout de logiciels supplémentaires au serveur Jenkins
Étant donné que Jenkins est écrit en Java, le serveur par défaut créé en exécutant l’image Jenkins Docker dispose de la plupart des logiciels requis pour compiler et tester les applications Java.
Pour créer des applications écrites dans d’autres langages, vous connectez des agents Jenkins externes aux logiciels requis et exécutez des tâches sur ceux-ci. L’utilisation d’agents est une solution évolutive, que vous devriez envisager si vous utilisez Jenkins dans un environnement de production.
Pour les tests locaux, une solution plus pratique consiste à créer une image Docker personnalisée avec les outils requis intégrés. Pour ce faire, vous devez créer un fichier appelé Dockerfileavec un contenu similaire à ce qui suit :
FROM jenkins/jenkins:lts-jdk11
USER root
RUN apt update &&
apt install -y --no-install-recommends gnupg curl ca-certificates apt-transport-https &&
curl -sSfL https://apt.octopus.com/public.key | apt-key add - &&
sh -c "echo deb https://apt.octopus.com/ stable main > /etc/apt/sources.list.d/octopus.com.list" &&
apt update && apt install -y octopuscli
USER jenkins
DockerfileLes fichiers sont utilisés pour créer de nouvelles images Docker. Vous pouvez trouver une référence complète des commandes disponibles dans Dockerfilela documentation Docker. L’exemple ci-dessus utilise un petit sous-ensemble des commandes, mais illustre une image personnalisée typique basée sur l’image fournie par Jenkins.
Le fichier commence par la FROMcommande qui demande à Docker de créer la nouvelle image à partir de l’image fournie. Cela signifie que Jenkins et tous les outils de support seront déjà installés et configurés sur votre nouvelle image :
FROM jenkins/jenkins:lts-jdk11
Pour installer un nouveau logiciel, vous devez passer à l’ rootutilisateur. Tout comme avec un système d’exploitation Linux classique, seuls les utilisateurs privilégiés peuvent installer un nouveau logiciel à partir d’un gestionnaire de paquets :
USER root
La commande suivante effectue l’installation du logiciel. Cet exemple installe l’interface de ligne de commande Octopus en suivant les instructions du site Web d’Octopus :
RUN apt update &&
apt install -y --no-install-recommends gnupg curl ca-certificates apt-transport-https &&
curl -sSfL https://apt.octopus.com/public.key | apt-key add - &&
sh -c "echo deb https://apt.octopus.com/ stable main > /etc/apt/sources.list.d/octopus.com.list" &&
apt update && apt install -y octopuscli
Il est considéré comme une bonne pratique de disposer d’un compte utilisateur standard pour exécuter l’application dans le conteneur Docker. L’ jenkinsutilisateur a été créé dans l’image de base, vous revenez donc à cet utilisateur avec la commande finale :
USER jenkins
Pour créer une nouvelle image Docker avec le Dockerfile, exécutez :
docker build . -t myjenkins
Cette commande crée une nouvelle image appelée myjenkins. Pour exécuter la nouvelle image, arrêtez d’abord tout conteneur existant utilisant le jenkins_homevolume :
docker container stop nostalgic_tharp
Exécutez ensuite votre nouvelle image en montant le jenkins_homevolume existant pour conserver toute votre configuration Jenkins existante :
docker run -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home myjenkins
Installation de plugins Jenkins supplémentaires
Le moyen le plus simple d’installer de nouveaux plugins consiste à utiliser l’interface utilisateur Web de Jenkins. Tous les nouveaux plugins sont enregistrés sur le volume externe, ils sont donc disponibles même lorsque vous créez, détruisez et mettez à jour des conteneurs.
Vous pouvez également automatiser le processus d’installation des plugins en appelant le jenkins-plugin-cliscript, inclus dans l’image Jenkins de base, dans le cadre de votre image Docker personnalisée.
Voici un exemple Dockerfilequi installe le plugin Octopus Jenkins :
FROM jenkins/jenkins:lts-jdk11
USER root
RUN apt update &&
apt install -y --no-install-recommends gnupg curl ca-certificates apt-transport-https &&
curl -sSfL https://apt.octopus.com/public.key | apt-key add - &&
sh -c "echo deb https://apt.octopus.com/ stable main > /etc/apt/sources.list.d/octopus.com.list" &&
apt update && apt install -y octopuscli
RUN jenkins-plugin-cli --plugins octopusdeploy:3.1.6
USER jenkins
Ceci Dockerfileest similaire à l’exemple précédent, mais inclut une nouvelle RUNinstruction pour installer le plugin Octopus :
RUN jenkins-plugin-cli --plugins octopusdeploy:3.1.6
L’ID du plugin ( octopusdeploy) et la version ( 3.1.6) se trouvent sur le site Web du plugin Jenkins :
Publication de l’image Docker personnalisée
Pour publier votre image Docker personnalisée, vous avez besoin d’un compte avec un registre Docker. DockerHub est un choix populaire et propose un hébergement gratuit d’images publiques.
Créez un compte gratuit, puis connectez-vous avec la commande :
docker login
Pour créer une image pouvant être publiée sur DockerHub, exécutez la commande suivante en la remplaçant usernamepar votre nom d’utilisateur DockerHub :
docker build . -t username/myjenkins
Publiez l’image avec cette commande :
docker push username/myjenkins
Mon nom d’utilisateur DockerHub est mcasperson, j’exécute donc ces commandes pour créer et publier une image :
docker build . -t mcasperson/myjenkins
docker push mcasperson/myjenkins
Mon image Docker personnalisée est ensuite disponible sur DockerHub.
Passer des arguments Java
La configuration avancée de Jenkins est souvent effectuée en transmettant des arguments Java, généralement sous la forme de propriétés système.
L’image Docker de Jenkins permet de définir des arguments Java dans la JAVA_OPTSvariable d’environnement. Cette variable d’environnement est lue par le script d’image Docker qui lance Jenkins et transmise en tant qu’arguments Java.
Pour définir la JAVA_OPTSvariable d’environnement, transmettez l’ --envargument à la docker runcommande :
docker run -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home --env JAVA_OPTS=-Dhudson.footerURL=http://mycompany.com jenkins/jenkins:lts-jdk11
Une liste des propriétés du système Jenkins peut être trouvée dans la documentation Jenkins.
Passer des arguments Jenkins
En plus des propriétés système, Jenkins accepte également un certain nombre d’arguments d’application.
Les arguments de l’application sont définis en les ajoutant à la fin de la commande d’exécution de Docker. L’exemple ci-dessous transmet l’ --httpPortargument configurant Jenkins pour écouter sur le port 8081 :
docker run -p 8080:8081 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts-jdk11 --httpPort=8081
Les arguments de l’application peuvent également être définis dans la JENKINS_OPTSvariable d’environnement :
docker run -p 8080:8081 -p 50000:50000 -v jenkins_home:/var/jenkins_home --env JENKINS_OPTS=--httpPort=8081 jenkins/jenkins:lts-jdk11
Une liste des arguments d’application est disponible dans le référentiel GitHub de Winstone. Winstone est le conteneur de servlet intégré par défaut dans Jenkins.
Sauvegarder le volume Docker
Vous pouvez exécuter la commande suivante pour sauvegarder les données enregistrées dans le volume Docker hébergeant le /var/jenkins_homerépertoire. Elle monte le volume dans un nouveau conteneur, monte le répertoire de travail actuel dans le /backuprépertoire du conteneur et crée une archive appelée backup.tarcontenant le contenu du /var/jenkinsrépertoire :
docker run --rm -v jenkins_home:/var/jenkins_home -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /var/jenkins_home
Cette commande peut être exécutée pendant que le conteneur Jenkins est en cours d’exécution, car les volumes Docker peuvent être partagés entre les conteneurs en cours d’exécution. Cependant, il est recommandé d’arrêter Jenkins avant d’effectuer une sauvegarde :
Même si Jenkins tire parti de COW, il est recommandé d’arrêter Jenkins si possible avant d’effectuer une sauvegarde car les fichiers XML du workflow du pipeline peuvent être capturés dans un état incohérent (par exemple si la sauvegarde ne prend pas un « instantané instantané » de chaque fichier à ce moment précis).
Exécution d’images Docker en tant que services
Une instance de production de Jenkins doit être redémarrée automatiquement lorsque le système d’exploitation sous-jacent est redémarré. Cependant, ce n’est pas le comportement par défaut des conteneurs que vous avez lancés à l’aide des commandes Docker présentées ci-dessus, donc tous les conteneurs Jenkins resteront arrêtés après un redémarrage du système d’exploitation.
Pour résoudre ce problème, vous pouvez exécuter un conteneur Docker en tant que service systemd. Cela vous permet de gérer un conteneur Jenkins de la même manière que vous géreriez une instance Jenkins installée avec un gestionnaire de packages.
Pour créer un nouveau service systemd, enregistrez le contenu suivant dans le fichier/etc/systemd/system/docker-jenkins.service :
[Unit]
Description=Jenkins
[Service]
SyslogIdentifier=docker-jenkins
ExecStartPre=-/usr/bin/docker create -m 0b -p 8080:8080 -p 50000:50000 --restart=always --name jenkins jenkins/jenkins:lts-jdk11
ExecStart=/usr/bin/docker start -a jenkins
ExecStop=-/usr/bin/docker stop --time=0 jenkins
[Install]
WantedBy=multi-user.target
Pour charger le nouveau fichier de service, exécutez la commande :
sudo systemctl daemon-reload
Pour démarrer le service, exécutez la commande :
sudo systemctl start docker-jenkins
Pour permettre au service de s’exécuter au redémarrage, exécutez la commande :
sudo systemctl enable docker-jenkins
Pour afficher les journaux de service, exécutez la commande :
sudo journalctl -u docker-jenkins -f
Conclusion
L’exécution de Jenkins à partir d’une image Docker fournit une méthode pratique pour lancer Jenkins dans un environnement autonome et préconfiguré.
Dans cet article, vous avez appris comment :
- Lancer Jenkins dans un conteneur Docker
- Installer des outils et des plugins supplémentaires
- Transmettre les propriétés du système Java et les arguments de l’application Jenkins
- Sauvegarder le volume Docker
- Configurer un conteneur Docker en tant que service systemd
L’exécution d’images Docker sur un poste de travail ou un serveur n’est toutefois qu’un début. Dans le prochain article, vous apprendrez à déployer Jenkins sur un cluster Kubernetes.
Essayez notre outil gratuit Jenkins Pipeline Generator pour créer un fichier Pipeline en syntaxe Groovy. C’est tout ce dont vous avez besoin pour démarrer votre projet Pipeline.
