Démarrer avec Jenkins

Configuration du proxy Nginx

Nativement, Jenkins s’exécute sur le port 8080. Nous pouvons établir un proxy à partir du port 80 -> 8080 afin que Jenkins soit accessible via :

http://<url>.com

au lieu de la valeur par défaut

http://<url>.com:8080

Commencez par installer Nginx.

sudo aptitude -y install nginx

Supprimer les paramètres par défaut pour Nginx

cd /etc/nginx/sites-available

sudo rm par défaut ../sites-enabled/default

Créer le nouveau fichier de configuration

sudo touche jenkins

Copiez le code suivant dans le fichier jenkins nouvellement créé.

upstream app_server {
  server 127.0.0.1:8080 fail_timeout=0;
}

server {
  listen 80;
  listen [::]:80 default ipv6only=on;
  server_name ;

  location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;

    if (!-f $request_filename) {
        proxy_pass http://app_server;
        break;
    }
  }
}

Créez un lien symbolique entre les sites disponibles et les sites activés :

sudo ln -s /etc/nginx/sites-available/jenkins /etc/nginx/sites-enabled/

Redémarrez le service proxy Nginx

redémarrage du service sudo nginx

Jenkins sera désormais accessible depuis le port 80.

Présentation complète de Jenkins en un seul endroit

1. Jenkins :

Jenkins est un outil d’intégration continue open source écrit en Java. Le projet a été dérivé d’Hudson après un différend avec Oracle.

En un mot, Jenkins est le premier serveur d’automatisation open source. Construit avec Java, il fournit des centaines de plug-ins pour prendre en charge la création, les tests, le déploiement et l’automatisation de pratiquement tous les projets.

Fonctionnalités : Jenkins offre les principales fonctionnalités suivantes prêtes à l’emploi, et bien d’autres peuvent être ajoutées via des plugins :

Installation facile : exécutez simplement java -jar jenkins.war, déployez-le dans un conteneur de servlet. Aucune installation supplémentaire, aucune base de données. Vous préférez un programme d’installation ou un package natif ? Nous en avons aussi. Configuration facile : Jenkins peut être entièrement configuré à partir de son interface graphique Web conviviale avec des contrôles d’erreurs à la volée et une aide en ligne. Écosystème de plug-ins riche : Jenkins s’intègre à pratiquement tous les outils SCM ou build existants. Voir les plugins. Extensibilité : la plupart des parties de Jenkins peuvent être étendues et modifiées, et il est facile de créer de nouveaux plugins Jenkins. Cela vous permet de personnaliser Jenkins selon vos besoins. Builds distribués : Jenkins peut distribuer des charges de build/test à plusieurs ordinateurs avec différents systèmes d’exploitation. Créer un logiciel pour OS X, Linux et Windows ? Aucun problème.

Montage :

$ wget -q -O - https://jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add -

$ sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian binary/ > /etc/apt/sources.list.d/jenkins.list'
$ sudo apt-get update
$ sudo apt-get install jenkins
to do more refer link :

Réf : https://wiki.jenkins-ci.org/display/JENKINS/Installing+Jenkins+on+Ubuntu

Réf : http://www.vogella.com/tutorials/Jenkins/article.html

Réf : https://wiki.jenkins-ci.org/display/JENKINS/Meet+Jenkins

Répertoire JENKINS_HOME Jenkins a besoin d’espace disque pour effectuer des builds et conserver des archives. Vous pouvez vérifier cet emplacement à partir de l’écran de configuration de Jenkins. Par défaut, ce paramètre est défini sur ~/.jenkins, mais vous pouvez le modifier de l’une des manières suivantes : Définissez la variable d’environnement “JENKINS_HOME” sur le nouveau répertoire personnel avant de lancer le conteneur de servlet. Définissez la propriété système “JENKINS_HOME” sur le conteneur de servlet. Définissez l’entrée d’environnement JNDI “JENKINS_HOME” sur le nouveau répertoire. Consultez la collection de documentation spécifique au conteneur pour en savoir plus sur la façon de procéder pour votre conteneur. Vous pouvez également modifier cet emplacement après avoir utilisé Jenkins pendant un certain temps. Pour ce faire, arrêtez complètement Jenkins, déplacez le contenu de l’ancien JENKINS_HOME vers le nouveau home, définissez le nouveau JENKINS_HOME et redémarrez Jenkins. JENKINS_HOME a une structure de répertoires assez évidente qui ressemble à ceci :

JENKINS_HOME

+- config.xml     (jenkins root configuration)
 +- *.xml          (other site-wide configuration files)
 +- userContent    (files in this directory will be served under your http://server/userContent/)
 +- fingerprints   (stores fingerprint records)
 +- plugins        (stores plugins)
 +- workspace (working directory for the version control system)
     +- [JOBNAME] (sub directory for each job)
 +- jobs
     +- [JOBNAME]      (sub directory for each job)
         +- config.xml     (job configuration file)
         +- latest         (symbolic link to the last successful build)
         +- builds
             +- [BUILD_ID]     (for each build)
                 +- build.xml      (build result summary)
                 +- log            (log file)
                 +- changelog.xml  (change log)

Tâches de construction Jenkins :

La création d’une nouvelle tâche de build dans Jenkins est simple : cliquez simplement sur l’élément de menu « Nouvelle tâche » sur le tableau de bord Jenkins. Jenkins prend en charge plusieurs types de tâches de build différents, qui vous sont présentés lorsque vous choisissez de créer une nouvelle tâche.

Projet logiciel Freestyle

Les travaux de construction Freestyle sont des travaux de construction à usage général, qui offrent un maximum de flexibilité.

Projet Maven Le « projet maven2/3 » est un travail de build spécialement adapté aux projets Maven. Jenkins comprend les fichiers Maven pom et les structures de projet, et peut utiliser les informations glanées à partir du fichier pom pour réduire le travail que vous devez faire pour configurer votre projet.

Flux de travail

Orchestre les activités de longue durée qui peuvent s’étendre sur plusieurs esclaves de build. Convient à la construction de pipelines et/ou à l’organisation d’activités complexes qui ne s’intègrent pas facilement dans le type de travail de style libre.

Surveiller une tâche externe La tâche de build « Surveiller une tâche externe » vous permet de garder un œil sur les processus non interactifs, tels que les tâches cron.

Emploi multiconfiguration Le « projet multiconfiguration » (également appelé « projet matriciel ») vous permet d’exécuter la même tâche de build dans de nombreuses configurations différentes. Cette fonctionnalité puissante peut être utile pour tester une application dans de nombreux environnements différents, avec différentes bases de données, ou même sur différentes machines de construction.

1. Construire un projet logiciel (style libre)

Jenkins peut être utilisé pour effectuer le travail typique du serveur de build, comme effectuer des builds continus/officiels/nocturnes, exécuter des tests ou effectuer des tâches répétitives par lots. C’est ce qu’on appelle “projet de logiciel de style libre” dans Jenkins. Mise en place du projet Accédez à la page d’accueil de Jenkins, sélectionnez “Nouveau travail”, puis choisissez “Créer un projet de logiciel de style libre”. Ce type de travail comprend les éléments suivants : SCM facultatif, tel que CVS ou Subversion où réside votre code source. des déclencheurs facultatifs pour contrôler quand Jenkins effectuera des builds. une sorte de script de construction qui exécute la construction (ant, maven, script shell, fichier batch, etc.) où le vrai travail se produit étapes facultatives pour collecter des informations à partir de la construction, telles que l’archivage des artefacts et/ou l’enregistrement de javadoc et des résultats de test. étapes facultatives pour informer d’autres personnes/systèmes du résultat de la construction, telles que l’envoi d’e-mails, de messages instantanés, la mise à jour du suivi des problèmes, etc.

Constructions pour les projets sans contrôle de code source Il est parfois nécessaire de créer un projet simplement à des fins de démonstration ou l’accès à un référentiel SVN/CVS n’est pas disponible. En choisissant de configurer le projet sur “Aucun” sous “Gestion du code source”, vous devrez :

Construisez le projet au moins une fois (il échouera), mais Jenkins créera la structure jenkins/workspace/PROJECTNAME/
Copiez les fichiers du projet dans jenkins/workspace/PROJECTNAME/
Compilez à nouveau et configurez de manière appropriée

** Jenkins définit les variables d’environnement **

Lorsqu’un travail Jenkins s’exécute, il définit certaines variables d’environnement que vous pouvez utiliser dans votre script shell, votre commande batch, votre script Ant ou Maven POM . Voir la liste des variables en cliquant sur ENVIRONMENT_VARIABLE

Configuration des compilations automatiques

Les builds dans Jenkins peuvent être déclenchés périodiquement (selon un calendrier, spécifié dans la configuration), ou lorsque des changements de source dans le projet ont été détectés, ou ils peuvent être déclenchés automatiquement en demandant l’URL :

http://VOTREHÔTE/jenkins/job/NOMPROJET/build

Cela vous permet d’intégrer les builds Jenkins dans une variété de configurations. Pour plus d’informations (en particulier pour effectuer cette opération avec la sécurité activée), consultez API d’accès à distance.

Compilation par changement de source

Vous pouvez demander à Jenkins d’interroger votre système de contrôle de révision pour les modifications. Vous pouvez spécifier la fréquence à laquelle Jenkins interroge votre système de contrôle de révision en utilisant la même syntaxe que crontab sous Unix/Linux. Cependant, si votre période d’interrogation est plus courte qu’il n’en faut pour interroger votre système de contrôle de révision, vous pouvez vous retrouver avec plusieurs builds pour chaque modification. Vous devez soit ajuster votre période d’interrogation pour qu’elle soit plus longue que le temps nécessaire pour interroger votre système de contrôle de révision, soit utiliser un déclencheur post-commit. Vous pouvez examiner le journal d’interrogation de chaque version pour voir combien de temps il a fallu pour interroger votre système.

Alternativement, au lieu d’interroger à intervalle fixe, vous pouvez utiliser un déclencheur d’URL (décrit ci-dessus), mais avec /polling au lieu de /build à la fin de l’URL. Cela oblige Jenkins à interroger le SCM pour les modifications plutôt que de créer immédiatement. Cela empêche Jenkins d’exécuter une construction sans modifications pertinentes pour les validations affectant les modules ou les branches qui ne sont pas liés au travail. Lors de l’utilisation de /polling, la tâche doit être configurée pour l’interrogation, mais la planification peut être vide.

** Construit par e-mail (sendmail) **

Si vous avez le compte root de votre système et que vous utilisez sendmail, j’ai trouvé qu’il était plus simple de modifier /etc/aliases et d’ajouter l’entrée suivante : jenkins-foo : “|/bin/wget -o /dev/null

http://VOTREHÔTE/jenkins/job/NOMPROJET/build”

puis exécutez la commande “newaliases” pour informer sendmail du changement. Chaque fois que quelqu’un envoie un e-mail à “jenkins-foo@yoursystem”, cela déclenchera une nouvelle construction. Consultez ceci pour plus de détails sur la configuration de sendmail. Construit par e-mail (qmail) Avec qmail, vous pouvez écrire /var/qmail/alias/.qmail-jenkins comme suit : |/bin/wget -o /dev/null http://VOTREHÔTE/jenkins/job/NOMPROJET/build"

2. Construire un projet Maven

Jenkins fournit un type de travail dédié à Maven 2/3. Ce type de travail intègre profondément Jenkins à Maven 2/3 et offre les avantages suivants par rapport au projet de logiciel de style libre plus générique.

Jenkins analyse les POM Maven pour obtenir la plupart des informations nécessaires à son travail. En conséquence, la quantité de configuration est considérablement réduite.

Jenkins écoute l’exécution de Maven et détermine ce qui doit être fait lorsqu’il est seul. Par exemple, il enregistrera automatiquement le rapport JUnit lorsque Maven exécutera la phase de test. Ou si vous exécutez le goal javadoc, Jenkins enregistrera automatiquement javadoc.

Jenkins crée automatiquement des dépendances de projet entre les projets qui déclarent des dépendances SNAPSHOT entre eux. Voir ci-dessous. Ainsi, la plupart du temps, il vous suffit de configurer les informations SCM et les objectifs que vous souhaitez exécuter, et Jenkins s’occupera de tout le reste.

Ce type de projet peut fournir automatiquement les fonctionnalités suivantes :

Archiver les artefacts produits par une compilation

Publier les résultats des tests

Déclencher des tâches pour des projets qui sont des dépendances en aval

Déployez vos artefacts dans un dépôt Maven

Résultats des tests de répartition par module

Facultativement, reconstruisez uniquement les modules modifiés, ce qui accélère vos compilations

Chaînage automatique des builds à partir des dépendances de modules

Jenkins lit les dépendances de votre projet à partir de votre POM, et si elles sont également construites sur Jenkins, les déclencheurs sont configurés de manière à ce qu’une nouvelle construction dans l’une de ces dépendances démarre automatiquement une nouvelle construction de votre projet. Jenkins comprend toutes sortes de dépendances dans POM. À savoir, parent POM

<dependencies> section of your project
<plugins> section of your project
<extensions> section of your project
<reporting> section of your project

Ce processus prend en compte les versions, vous pouvez donc avoir plusieurs versions/branches de votre projet sur le même Jenkins et il déterminera correctement les dépendances. Notez que les plages de versions de dépendance ne sont pas prises en charge, voir [https://issues.jenkins-ci.org/browse/JENKINS-2787][1] pour la raison.

Cette fonctionnalité peut être désactivée à la demande - voir l’option de configuration Construire chaque fois qu’une dépendance SNAPSHOT est créée

Montage :

1 . allez dans Gérer Jenkins» configurer le système 2. dans l’onglet maven “Cliquez sur l’installation de maven ……

Vous pouvez soit demander à Jenkins d’installer automatiquement une version spécifique de Maven, soit fournir un chemin vers une installation locale de Maven (vous pouvez configurer autant de versions de Maven que vous le souhaitez pour vos projets de construction et utiliser différentes versions de Maven pour différents projets. Si vous cochez la case Installer automatiquement, Jenkins téléchargera et installera pour vous la version demandée de Maven et l’installera dans le répertoire tools du répertoire d’accueil de Jenkins.

Comment l’utiliser

Tout d’abord, vous devez configurer une installation Maven (cette étape peut être ignorée si vous utilisez DEV@cloud). Cela peut être fait en accédant à l’écran de configuration du système (Gérer Jenkins-> Configurer le système). Dans la section “Installations Maven”, 1) cliquez sur le bouton Ajouter, 2) donnez-lui un nom tel que “Maven 3.0.3” puis 3) choisissez la version dans le menu déroulant.

Maintenant, Jenkins installera automatiquement cette version à tout moment (sur toutes les nouvelles machines de construction, par exemple) en la téléchargeant depuis Apache et en la décompressant.

Créer un nouveau Job Maven :

Cliquez sur “New Job / New Item” sur la main gauche
Donnez-lui un nom
Choisissez le “Construire un projet Maven 2/3”
Enregistrez votre travail

Vous devez maintenant configurer votre travail

Choisissez le SCM que vous souhaitez utiliser (ex. Utiliser git)
choisissez la cible maven à appeler
ajoutez l’URL du référentiel et les informations d’identification.
vérifiez le référentiel maven privé de l’utilisateur :

Vous pouvez également définir le chemin personnalisé pour le même.

5 . Projet de construction

Construisez votre projet en cliquant sur construire maintenant et cliquez sur la barre de progression dans la partie gauche “Build Executor Status” pour regarder Jenkins installer Maven, vérifier votre projet et le construire à l’aide de Maven.

Enregistrement:

https://wiki.jenkins-ci.org/display/JENKINS/Logging

Console de script :

Utile pour le dépannage, les diagnostics ou les mises à jour par lots des travaux Jenkins fournit une console de script qui vous donne accès à tous les composants internes de Jenkins. Ces scripts sont écrits en Groovy et vous en trouverez quelques exemples dans cette [page][1].

[1] : https://wiki.jenkins-ci.org/display/JENKINS/Logging

Déplacer Jenkins d’un PC à un autre

Cela a fonctionné pour moi pour passer d’Ubuntu 12.04 (Jenkins ver. 1.628) à Ubuntu 16.04 (Jenkins ver. 1.651.2). J’ai d’abord [installé Jenkins à partir des dépôts][1].

[Arrêter les deux serveurs Jenkins][2]
Copiez JENKINS_HOME (par exemple /var/lib/jenkins) de l’ancien serveur vers le nouveau. Depuis une console du nouveau serveur :

rsync -av username@old-server-IP:/var/lib/jenkins/ /var/lib/jenkins/
[Démarrez votre nouveau serveur Jenkins][2]

Tu n’en as peut-être pas besoin, mais je devais

Gérer Jenkins et Recharger la configuration à partir du disque.
Déconnectez et reconnectez tous les esclaves.
Vérifiez que dans Configure System > Jenkins Location, l’URL Jenkins est correctement attribuée au nouveau serveur Jenkins.

[1] : https://wiki.jenkins-ci.org/display/JENKINS/Installing+Jenkins+on+Ubuntu [2] : https://cloudbees.zendesk.com/hc/en-us/articles/216118748-How-to-Start-Stop-or-Restart-your-Instance

Installation

Pour les systèmes basés sur apt-get tels que Ubuntu

Ajoutez le dépôt Jenkins :

wget -q -O - https://jenkins-ci.org/debian/ Jenkins-ci.org.key | clé sudo apt

sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

Mettez à jour les sources et installez Jenkins :

sudo apt-obtenir la mise à jour

sudo apt-get install jenkins

Un utilisateur Jenkins est maintenant créé et, par défaut, Jenkins s’exécutera sur le port 8080.

Pour les distributions basées sur RPM telles que Red Hat Enterprise Linux (RHEL), CentOS, Fedora ou Scientific Linux

Pour télécharger le fichier de référentiel pour la version stable :

sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat-stable/jenkins.repo

Ou si vous voulez les dernières publications hebdomadaires :

sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo

Importez la clé publique :

sudo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key

Installez Jenkins en utilisant yum :

sudo miam installer jenkins

Jenkins a besoin de Java pour fonctionner, pour l’installer :

sudo miam installer java

Pour démarrer/arrêter/redémarrer jenkins, utilisez :

sudo service jenkins démarrer/arrêter/redémarrer

Mise à niveau de jenkins (installations RPM)

Sauvegardez le répertoire personnel de Jenkins
Remplacez jenkins.war à l’emplacement suivant par le nouveau fichier WAR. /usr/lib/jenkins/jenkins.war`
Redémarrez Jenkins
Vérifiez les plugins épinglés et détachez-les si nécessaire
Recharger la configuration à partir du disque

Remarque : pour les mises à niveau de Jenkins 2 pour le serveur d’applications Jetty fourni, désactivez le port AJP (définissez JENKINS_AJP_PORT="-1") dans /etc/sysconfig/jenkins.

Configurer un projet dans Jenkins

Ici, nous allons vérifier la dernière copie du code de notre projet, exécuter les tests et mettre l’application en ligne. Pour y parvenir, suivez les étapes ci-dessous :

Ouvrez Jenkins dans le navigateur.
Cliquez sur le lien Nouvelle tâche.
Entrez le nom du projet et sélectionnez le lien Créer un projet de logiciel de style libre.
Cliquez sur le bouton OK.
Dans la section Gestion du code source, sélectionnez la case d’option à côté de votre outil de gestion du code source. Dans mon cas, j’ai sélectionné Git.

Fournissez l’URL du dépôt git comme git://github.com/example/example.git 6. Sous Build triggers, sélectionnez la case d’option à côté de Poll SCM. 7. Indiquez ***** dans la case Calendrier. Cette case est chargée de déclencher le build à intervalles réguliers. ***** spécifie que la tâche sera déclenchée toutes les minutes pour les modifications apportées au référentiel git. 8. Dans la section Construire, cliquez sur le bouton Ajouter une étape de génération, puis sélectionnez l’option par laquelle vous souhaitez générer le projet. J’ai sélectionné Exécuter Shell. Dans la zone de commande, écrivez la commande pour compiler, exécutez les tests et déployez-la sur prod. 10. Faites défiler vers le bas et Enregistrer.

Donc, ci-dessus, nous avons configuré un projet de base dans Jenkins qui déclenchera la construction à chaque minute pour un changement dans votre référentiel git. Remarque : Pour configurer le projet complexe, vous devrez peut-être installer certains plugins dans Jenkins.

Configurer un projet de construction simple avec le script de pipeline Jenkins 2

Ici, nous allons créer un pipeline Groovy dans Jenkins 2 pour effectuer les étapes suivantes :

Vérifiez toutes les 5 minutes si un nouveau code a été validé pour notre projet
Code de paiement du référentiel SCM
Compilation Maven de notre code Java
Exécuter nos tests d’intégration et publier les résultats

Voici les étapes que nous allons :

Assurez-vous que nous avons au moins une version 2.0 de Jenkins (vous pouvez vérifier cela dans le coin inférieur droit de votre page) telle que :

[![Jenkins version capture example][1]][1]
Sur la page d’accueil de Jenkins, cliquez sur Nouvel élément
Entrez le nom du projet et sélectionnez Pipeline
Dans la section Build Triggers, sélectionnez l’option Poll SCM et ajoutez le programme CRON de 5 minutes suivant : */5 * * * *
Dans la section Pipeline, choisissez Script de pipeline ou Script de pipeline de SCM
Si vous avez sélectionné Script de pipeline de SCM à l’étape précédente, vous devez maintenant spécifier l’URL de votre référentiel SCM (Git, Mercurial, Subversion) dans URL de référentiel, par exemple http://github.com /exemple/exemple.git. Vous devez également spécifier le chemin du script de votre fichier de script Groovy dans votre référentiel example.git, par ex. pipelines/exemple.groovy
Copiez le code Groovy suivant, soit directement dans la fenêtre de script Groovy si vous avez précédemment cliqué sur Script Pipeline, soit dans votre example.groovy si vous avez choisi Script Pipeline de SCM

node(‘remote’) { // Note : this step is only needed if you’re using direct Groovy scripting stage ‘Checkout Git project’ git url: ‘https://github.com/jglick/simple-maven-project-with-tests.git’ def appVersion = version() if (appVersion) { echo “Building version ${appVersion}” }
```
 stage 'Build Maven project'
 def mvnHome = tool 'M3'
 sh "${mvnHome}/bin/mvn -B -Dmaven.test.failure.ignore verify"
 step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-*.xml'])
```
} def version() { def matcher = readFile(‘pom.xml’) =~ ‘(.+)’ matcher ? matcher[0][1] : null }

Et voilà, vous devriez maintenant pouvoir compiler et tester votre premier projet Jenkins en utilisant le pipeline Jenkins 2 Groovy.

[1] : http://i.stack.imgur.com/NCqh1.png

Installation du plugin à partir d’une source externe

java -jar [Path to client JAR] -s [Server address] install-plugin [Plugin ID]

Le client JAR doit être le fichier CLI JAR, pas le même JAR/WAR qui exécute Jenkins lui-même. Les identifiants uniques peuvent être trouvés sur une page respective des plugins sur le wiki Jenkins CLI (https://wiki.jenkins-ci.org/display/JENKINS/Plugins)

Démarrer avec Jenkins

Configuration du proxy Nginx #

Présentation complète de Jenkins en un seul endroit #

Déplacer Jenkins d’un PC à un autre #

Installation #

Mise à niveau de jenkins (installations RPM) #

Configurer un projet dans Jenkins #

Configurer un projet de construction simple avec le script de pipeline Jenkins 2 #

Installation du plugin à partir d’une source externe #