jenkins Tutoriel
Commencer avec jenkins

Remarques

Versions

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 | sudo apt-key

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

Mettre à jour les sources et installer Jenkins:

sudo apt-get update

sudo apt-get install jenkins

Un utilisateur jenkins est maintenant créé et par défaut Jenkins sera exécuté 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 versions hebdomadaires:

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

Importer la clé publique:

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

Installez Jenkins en utilisant yum:

sudo yum install jenkins

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

sudo yum install java

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

sudo service jenkins start/stop/restart

Mise à niveau de jenkins (installations RPM)

1. Répertoire de sauvegarde jenkins
2. Remplacez jenkins.war à l'emplacement suivant par un nouveau fichier WAR. / usr / lib / jenkins / jenkins.war`
3. Redémarrer Jenkins
4. Vérifiez les plugins épinglés et désépinglez-les si nécessaire
5. Recharger la configuration à partir du disque

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

Configuration du proxy Nginx

Nativement, Jenkins fonctionne sur le port 8080. Nous pouvons établir un proxy à partir du port 80 -> 8080 pour pouvoir accéder à Jenkins via:

http://<url>.com

au lieu du 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 default ../sites-enabled/default

Créez le nouveau fichier de configuration

sudo touch 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éer 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

sudo service nginx restart

Jenkins sera désormais accessible depuis le port 80.

Installation du plug-in à partir d'une source externe

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

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

Déplacer Jenkins d'un PC vers un autre

Cela a fonctionné pour que je passe d'Ubuntu 12.04 (Jenkins ver. 1.628) à Ubuntu 16.04 (Jenkins ver. 1.651.2). J'ai d'abord installé Jenkins à partir des référentiels .

1. Arrêtez 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/

3. Démarrer votre nouveau serveur Jenkins

Vous pourriez ne pas avoir besoin de cela, mais je devais

• Manage Jenkins et Reload Configuration from Disk .
• Déconnectez et connectez tous les esclaves à nouveau.
• Vérifiez que, dans Configure System > Jenkins Location , l' Jenkins URL est correctement affectée au nouveau serveur 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 rendre l'application en direct. Pour ce faire, suivez les étapes ci-dessous:

1. Ouvrez Jenkins dans le navigateur.
2. Cliquez sur le lien New Job .
3. Entrez le nom du projet et sélectionnez le lien Créer un projet logiciel de style libre .
4. Cliquez sur le bouton Ok .
5. Sous la section Gestion du code source , sélectionnez la case d'option en regard de votre outil de gestion du code source. Dans mon cas, j'ai choisi Git .

Fournit l'URL de repo git://github.com/example/example.git comme git://github.com/example/example.git

6. Sous les déclencheurs de génération , sélectionnez la case d' option en regard de Poll SCM .
7. Fournir ***** dans la case Schedule . Cette case est responsable de déclencher la construction à intervalles réguliers. ***** spécifie que, le travail sera déclenché toutes les minutes pour les changements de repo git.
8. Dans la section Générer , cliquez sur le bouton Ajouter une étape de création , puis sélectionnez l'option par laquelle vous souhaitez générer le projet. J'ai sélectionné Execute Shell . Dans la boîte de commande, écrivez la commande à générer, exécutez les tests et déployez-la pour générer.
9. Faites défiler et enregistrer .

Donc, ci-dessus, nous avons configuré un projet de base dans Jenkins qui déclenchera la génération à chaque minute pour le modifier dans votre dépôt git. Note: Pour configurer le projet complexe, vous devrez peut-être installer des plugins dans Jenkins.

Jenkins Full Introduction en un seul endroit

1. Jenkins:

Jenkins est un outil d'intégration continue open source écrit en Java. Le projet a été conçu à partir de Hudson après un conflit avec Oracle.

En résumé, Jenkins est le principal 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, et de nombreux autres peuvent être ajoutés via des plugins:

Installation facile: lancez simplement java -jar jenkins.war, déployez-le dans un conteneur de servlets. Pas d'installation supplémentaire, pas de base de données. Préférez un installateur ou un package natif? Nous les avons aussi. Configuration facile: Jenkins peut être entièrement configuré à partir de son interface graphique Web conviviale avec des vérifications d’erreur à la volée et une aide en ligne. Écosystème de plug-in enrichi: Jenkins s'intègre à pratiquement tous les outils SCM ou de génération 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. Constructions distribuées: Jenkins peut distribuer des charges de build / test à plusieurs ordinateurs dotés de systèmes d'exploitation différents. Création de logiciels pour OS X, Linux et Windows? Aucun problème.

Installation:

$ 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 depuis l'écran de configuration de Jenkins. Par défaut, il 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 de base 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" dans le nouveau répertoire. Consultez la collection de documentation spécifique au conteneur pour en savoir plus sur la procédure à suivre 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 dossier d'accueil, définissez le nouveau fichier JENKINS_HOME et redémarrez Jenkins. JENKINS_HOME a une structure de répertoire 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)

Jenkins crée des emplois:

Créer un nouveau travail de construction dans Jenkins est simple: il suffit de cliquer sur l’élément de menu «Nouvelle tâche» du tableau de bord Jenkins. Jenkins prend en charge plusieurs types de travaux de construction, qui vous sont présentés lorsque vous choisissez de créer un nouveau travail

Projet logiciel Freestyle

Les travaux de construction en style libre sont des travaux de construction polyvalents, qui offrent un maximum de flexibilité.

Projet Maven Le projet «maven2 / 3» est un travail de construction spécialement adapté aux projets Maven. Jenkins comprend les fichiers Maven et les structures de projet, et peut utiliser les informations collectées dans le fichier pom pour réduire le travail nécessaire à la configuration de votre projet.

Workflow

Orchestre les activités de longue durée qui peuvent couvrir plusieurs esclaves de construction. Convient pour la construction de pipelines et / ou l'organisation d'activités complexes qui ne correspondent pas facilement à un type de travail de style libre.

Surveiller une tâche externe La tâche de génération «Surveiller une tâche externe» vous permet de surveiller les processus non interactifs, tels que les tâches cron.

Travail de multiconfiguration Le «projet de multiconfiguration» (également appelé «projet de matrice») vous permet d'exécuter le même travail de construction dans de nombreuses configurations différentes. Cette fonctionnalité puissante peut être utile pour tester une application dans de nombreux environnements, avec différentes bases de données ou même sur des machines de construction différentes.

1. Construire un projet logiciel (style libre)

Jenkins peut être utilisé pour effectuer le travail typique du serveur de génération, par exemple en effectuant des builds continus / officiels / nocturnes, en exécutant des tests ou en effectuant des tâches par lots répétitives. Ceci est appelé "projet logiciel libre" dans Jenkins. Configurer le projet Aller à la page d'accueil de Jenkins, sélectionnez "Nouveau travail", puis choisissez "Créer un projet logiciel libre". Ce type de travail comprend les éléments suivants: SCM facultatif, tel que CVS ou Subversion où réside votre code source. déclencheurs facultatifs pour contrôler le moment où Jenkins exécutera les builds. une sorte de script de compilation qui exécute la génération (ant, maven, script shell, fichier de commandes, etc.) où le travail réel se déroule en étapes facultatives pour collecter des informations sur la construction, comme l'archivage des artefacts et / ou l'enregistrement du javadoc résultats. Étapes facultatives pour informer les autres personnes / systèmes du résultat de la génération, comme l'envoi d'e-mails, de messages instantanés, la mise à jour du suivi des problèmes, etc.

Générations pour les projets de contrôle non-source Il est parfois nécessaire de construire un projet simplement à des fins de démonstration ou l'accès à un référentiel SVN / CVS est indisponible. En choisissant de configurer le projet comme "Aucun" sous "Gestion du code source", vous devrez:

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

Jenkins Définir les variables d'environnement

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

Configuration des builds automatiques

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

http: // YOURHOST / jenkins / job / PROJECTNAME / build

Cela vous permet d'accrocher les compilations de Jenkins à une variété de configurations. Pour plus d'informations (en particulier si cela est fait avec la sécurité activée), voir API d'accès distant.

Construit par les changements de source

Vous pouvez demander à Jenkins d'interroger votre système de contrôle de révision à la recherche de 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. Toutefois, si votre période d'interrogation est plus courte que celle requise pour interroger votre système de contrôle des révisions, vous pouvez vous retrouver avec plusieurs générations 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 des révisions, soit utiliser un déclencheur post-validation. Vous pouvez examiner le journal d'interrogation pour chaque version afin de déterminer le temps nécessaire pour interroger votre système.

Au lieu d'interroger un intervalle fixe, vous pouvez également utiliser un déclencheur d'URL (décrit ci-dessus), mais avec / polling au lieu de / build à la fin de l'URL. Cela fait que Jenkins interroge le SCM à la recherche de modifications plutôt que de générer immédiatement. Cela empêche Jenkins d’exécuter une génération sans modifications pertinentes pour les modifications affectant les modules ou les branches sans rapport avec le travail. Lors de l'utilisation / de l'interrogation, le travail doit être configuré pour l'interrogation, mais la planification peut être vide.

Construit par courrier électronique (sendmail)

Si vous avez le compte root de votre système et que vous utilisez sendmail, je trouve que le plus simple est de modifier / etc / aliases et d'ajouter l'entrée suivante: jenkins-foo: "| / bin / wget -o / dev / null

http: // YOURHOST / jenkins / job / PROJECTNAME / build "

puis exécutez la commande "newaliases" pour informer sendmail de la modification. Chaque fois que quelqu'un envoie un e-mail à "jenkins-foo @ yoursystem", cela déclenchera une nouvelle génération. Voyez ceci pour plus de détails sur la configuration de sendmail. Construit par courrier électronique (qmail) Avec qmail, vous pouvez écrire /var/qmail/alias/.qmail-jenkins comme suit: | / bin / wget -o / dev / null http: // YOURHOST / jenkins / job / PROJECTNAME / 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 logiciel plus générique de style libre.

Jenkins analyse les POM de Maven pour obtenir une grande partie 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écouvre ce qui devrait être fait quand il est seul. Par exemple, il enregistrera automatiquement le rapport JUnit lorsque Maven exécutera la phase de test. Ou si vous exécutez l'objectif 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. Il vous suffit donc de configurer les informations SCM et les objectifs que vous souhaitez exécuter, et Jenkins trouvera tout le reste.

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

Archiver les artefacts produits par une construction

Publier les résultats du test

Déclencher des travaux pour des projets qui sont des dépendances en aval

Déployer vos artefacts dans un référentiel Maven

Résultats des tests par module

Reconstruire éventuellement uniquement les modules modifiés, accélérant ainsi vos builds

Chaînage automatique à partir de 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 telle manière qu'une nouvelle construction dans l'une de ces dépendances lance automatiquement une nouvelle génération de votre projet. Jenkins comprend toutes les 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épendances ne sont pas prises en charge, consultez [ 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 Créer chaque fois qu'une dépendance SNAPSHOT est créée

Installation:

1 . allez dans Manage Jenkins >> configure System

2. dans l'onglet Maven “Cliquez sur l'installation de maven ......

Vous pouvez soit amener Jenkins à installer automatiquement une version spécifique de Maven, soit fournir un chemin vers une installation Maven locale (vous pouvez configurer autant de versions de Maven pour vos projets de construction que vous le souhaitez et utiliser différentes versions de Maven pour différents projets. Si vous cochez la case Installer automatiquement, Jenkins téléchargera et installera la version demandée de Maven pour vous et l'installera dans le répertoire tools du répertoire de base 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 allant à 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 chaque fois que cela sera nécessaire (sur de nouvelles machines de génération, par exemple) en la téléchargeant depuis Apache et en la décompressant.

Créez un nouveau travail Maven:

1. En cliquant sur «New Job / New Item» à gauche
2. Donne lui un nom
3. Choisissez le projet «Construire un Maven 2/3»
4. Sauvez votre travail

Maintenant, vous devez configurer votre travail

1. Choisissez le SCM que vous voulez utiliser (ex. En utilisant git)

2. choisir la cible Maven pour appeler

3. Ajouter l'URL du référentiel et les informations d'identification.

4. vérifier l'utilisateur privé maven repo:

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

5. Projet de construction

Construisez votre projet en cliquant sur build now et cliquez sur la barre de progression dans la main gauche «Build Executor Status» pour voir jenkins installer Maven, extraire votre projet et le construire en utilisant 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 de 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 sur cette page .

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érifier toutes les 5 minutes si le nouveau code a été validé dans notre projet
• Code de sortie de repo SCM
• Maven compile de notre code Java
• Exécutez nos tests d'intégration et publiez les résultats

Voici les étapes à suivre:

1. Assurez-vous d'avoir au moins une version 2.0 de Jenkins (vous pouvez le vérifier dans le coin inférieur droit de votre page), par exemple:

   

2. Sur la page d'accueil de Jenkins, cliquez sur Nouvel élément

3. Entrez le nom du projet et sélectionnez Pipeline

4. Dans la section Build Triggers , sélectionnez l'option Poll SCM et ajoutez le programme CRON de 5 minutes suivant: */5 * * * *

5. Dans la section Pipeline , choisissez le script de pipeline ou le script de pipeline dans SCM.

6. Si vous avez sélectionné Script de pipeline dans SCM à l'étape précédente, vous devez maintenant spécifier l'URL de votre référentiel SCM (Git, Mercurial, Subversion) dans l'URL du référentiel, par exemple http://github.com/example/example.git . Vous devez également spécifier le chemin de script de votre fichier script Groovy dans votre référentiel example.git, par exemple pipelines/example.groovy

7. Copiez le code Groovy suivant, directement dans la fenêtre de script Groovy si vous avez déjà cliqué sur Script de pipeline ou dans votre example.groovy si vous avez choisi Script de pipeline dans 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') =~ '<version>(.+)</version>'
    matcher ? matcher[0][1] : null
}

Vous pouvez maintenant compiler et tester votre premier projet Jenkins en utilisant le pipeline Jenkins 2 Groovy.