Serveur d’Intégration Continue Jenkins

Objectifs

installer un serveur d’intégration continue Jenkins ;
configurer l’accès au service par un mandataire proxy inverse ;
sécuriser les accès au service ;
créer une première tâche simple.

Jenkins est un outil Open Source d'intégration continue écrit en Java.

Interfacé avec des systèmes de gestion de version tel que Git, Subversion etc., il peut être utilisé pour compiler, tester et déployer des scripts shell ou des projets Ant, Maven, etc, selon des planifications ou des requêtes à des URLs.

Le principe de l’intégration continue est de vérifier, idéalement à chaque modification du code, la non-régression sur l’application des modifications apportées. Cette vérification systématique est primordiale pour une équipe de développeur : le projet est stable tout au long du développement et peut être livré à tout moment.

Le code source de l’application doit être :

partagé avec un système de gestion versions ;
testé automatiquement ;
les modifications doivent être poussées régulièrement.

Ainsi, les problèmes d’intégrations peuvent être corrigés au plus tôt et la dernière version stable de l’application est connue.

Installation

Jenkins peut fonctionner :

en mode standalone : avec le serveur web intégré ;
en tant que servlet : avec le serveur applicatif tomcat.

En mode standalone

Installation de Jenkins :

Sous debian :

Installation de la clé et ajout du dépot dans /etc/apt/sources.list :

# wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | # sudo apt-key add -

# deb http://pkg.jenkins-ci.org/debian binary/

Installation :

# apt-get update
# apt-get install jenkins

Sous RedHat :

Installation du dépôt et ajout de la clé GPG :

# wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo
# sudo rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key

Installation du paquet :

# yum update
# yum install java-1.8.0-openjdk jenkins

Jenkins peut maintenant être démarré :

# systemctl start jenkins
# systemctl enable jenkins

Jenkins est directement accessible à l’adressse :

http://IPSERVEUR:8080/jenkins

En tant que servlet tomcat

Installation de tomcat :

Sous debian :

apt-get install tomcat

Sous redhat :

yum install java-1.8.0-openjdk tomcat

Téléchargement de l’application :

cd /var/lib/tomcat6/webapps
wget http://mirrors.jenkins-ci.org/war/latest/jenkins.war

Si tomcat est en cours de fonctionnement, l’application sera automatiquement déployée, sinon lancer/relancer tomcat.

Jenkins est accessible à l’adressse :

http://IPSERVEUR:8080/jenkins

Installer Nginx

Un proxy inverse Nginx (mais Apache ou HAproxy sont de bonnes alternatives) va permettre d’accéder à l’application sur le port standard 80.

# yum -y install epel-release
# yum -y install nginx
# systemctl enable nginx

Créer un nouveau serveur dans la configuration de Nginx :

# vim /etc/nginx/conf.d/jenkins.conf
upstream jenkins{
    server 127.0.0.1:8080;
}

server{
    listen      80;
    server_name jenkins.formatux.fr;

    access_log  /var/log/nginx/jenkins.access.log;
    error_log   /var/log/nginx/jenkins.error.log;

    proxy_buffers 16 64k;
    proxy_buffer_size 128k;

    location / {
        proxy_pass  http://jenkins;
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
        proxy_redirect off;

        proxy_set_header    Host            $host;
        proxy_set_header    X-Real-IP       $remote_addr;
        proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header    X-Forwarded-Proto https;
    }

}

Lancer le serveur Nginx :

# systemctl start nginx
# systemctl enable nginx

Vous pouvez alternativement installer un proxy inversé Apache. Dans ce cas, le VHOST suivant pourra être utilisé :

<Virtualhost *:80>
    ServerName        jenkins.formatux.fr
    ProxyRequests     Off
    ProxyPreserveHost On
    AllowEncodedSlashes NoDecode

    <Proxy http://localhost:8080/*>
      Order deny,allow
      Allow from all
    </Proxy>

    ProxyPass         /  http://localhost:8080/ nocanon
    ProxyPassReverse  /  http://localhost:8080/
    ProxyPassReverse  /  http://jenkins.formatux.fr/
</Virtualhost>

Ouvrir les ports du parefeu :

Sur un serveur en standalone sans proxy-inverse ou sous tomcat :

# firewall-cmd --zone=public --add-port=8080/tcp --permanent

Sur un serveur avec proxy inverse :

# firewall-cmd --zone=public --add-service=http --permanent
# firewall-cmd --reload

Autoriser Nginx à se connecter au serveur Jenkins d’un point de vue SELinux :

# setsebool httpd_can_network_connect 1 -P

Configuration de Jenkins

L’interface de gestion web du serveur d’intégration continue Jenkins est accessible à l’adresse http://jenkins.formatux.fr si le proxy inverse a été configuré ou à l’adresse http://jenkins.formatux.fr:8080 dans les autres cas.

La page par défaut suivante s’affiche :

Cette page demande un mot de passe admin initial, qui a été généré lors de l’installation et qui est stocké dans le fichier /var/lib/jenkins/secrets/initialAdminPassword.

cat /var/lib/jenkins/secrets/initialAdminPassword

Utiliser le mot de passe pour ce connecter à l’interface de gestion.

L’assistant va ensuite demander quels plugins doivent être installés et proposer l’installation des plugins suggérés.

En choisissant Installer les plugins suggérés, tous les plugins nécessaire pour bien commencer seront installés :

L’étape suivante consiste à créer un utilisateur avec les droits d’administration pour l’accès à la console de gestion :

La configuration terminée, la console de gestion s’affiche :

La sécurité et la gestion des utilisateurs

Depuis l’interface de gestion, configurer les options de sécurité de Jenkins : cliquer sur Manage Jenkins, puis Configure Global Security.

Plusieurs méthodes d’autorisations peuvent être utilisées. En sélectionnant Matrix-based Security, les droits des utilisateurs peuvent être gérés plus finement. Activer l’utilisateur admin et cliquer sur Add. Lui donner tous les droits en sélectionnant toutes les options. Donner à l’utilisateur anonymous uniquement les droits de lecture (read). Ne pas oublier de cliquer sur Save.

Ajouter une tâche d’automatisation simple

Dans l’interface de gestion, cliquer sur Create new jobs.

Saisir un nom pour la tâche, par exemple test. Choisir Freestyle Project et cliquer sur OK.

Aller dans l’onglet Build. Dans Add build step, selectionner l’option Execute shell.

Saisir la commande suivante dans le champ texte :

top -b -n 1 | head -n 5

Cliquer sur Save.

Dans la page dédiée à la tâche test, cliquer sur Build Now pour executer la tâche test.

Une fois que la tâche a été executée, vous verrez l’historique du Build. Cliquer sur la première tâche pour visualiser les résultats.

Sources

Source principale : howtoforge.