Introduction à Jenkins 2 et à la puissance des pipelines

1. Vue d'ensemble

Dans cet article, nous allons présenter l'utilisation des pipelines à travers un exemple de livraison continue à l'aide de Jenkins.

Nous allons créer un pipeline simple mais très utile pour notre exemple de projet:

  • Compilation
  • Analyse statique simple (parallèle à la compilation)
  • Tests unitaires
  • Tests d'intégration (parallèlement aux tests unitaires)
  • Déploiement

2. Configuration de Jenkins

Tout d'abord, nous devons télécharger la dernière version stable de Jenkins (2.73.3 au moment de la rédaction de cet article).

Navigons jusqu'au dossier où se trouve notre fichier et exécutons- le à l'aide de la commande java -jar jenkins.war . Gardez à l'esprit que nous ne pouvons pas utiliser Jenkins sans une configuration initiale des utilisateurs.

Après avoir déverrouillé Jenkins en utilisant le mot de passe initial généré par l'administrateur, nous devons remplir les informations de profil du premier utilisateur administrateur et nous assurer d'installer tous les plugins recommandés.

Nous avons maintenant une nouvelle installation de Jenkins prête à être utilisée.

Toutes les versions disponibles de Jenkins peuvent être trouvées ici.

3. Pipelines

Jenkins 2 est livré avec une fonctionnalité intéressante appelée Pipelines , qui est très extensible lorsque nous devons définir un environnement d'intégration continue pour un projet.

Un pipeline est une autre façon de définir certaines étapes Jenkins à l'aide de code et d'automatiser le processus de déploiement de logiciels.

Il utilise un langage DSL (Domain Specific Language) avec deux syntaxes différentes:

  • Pipeline déclaratif
  • Pipeline scripté

Dans nos exemples, nous allons utiliser le Scripted Pipeline qui suit un modèle de programmation plus impératif construit avec Groovy .

Passons en revue quelques caractéristiques du plugin Pipeline :

  • les pipelines sont écrits dans un fichier texte et traités comme du code; cela signifie qu'ils peuvent être ajoutés au contrôle de version et modifiés ultérieurement
  • ils resteront après les redémarrages du serveur Jenkins
  • nous pouvons éventuellement suspendre les pipelines
  • ils prennent en charge des exigences complexes telles que l'exécution de travaux en parallèle
  • le plugin Pipeline peut également être étendu ou intégré à d'autres plugins

En d'autres termes, mettre en place un projet Pipeline signifie écrire un script qui appliquera séquentiellement certaines étapes du processus que nous voulons accomplir.

Pour commencer à utiliser des pipelines, nous devons installer le plugin Pipeline qui permet de composer une automatisation simple et complexe.

Nous pouvons également avoir la vue des étapes du pipeline, de sorte que lorsque nous exécutons une construction, nous voyons toutes les étapes que nous avons configurées.

4. Un exemple rapide

Pour notre exemple, nous utiliserons une petite application Spring Boot. Nous allons ensuite créer un pipeline qui clone le projet, le construit et exécute plusieurs tests, puis exécute l'application.

Installons le Checkstyle , statique Analyse Collector et JUnit plug - ins, qui sont respectivement utiles pour recueillir Checkstyle résultats, construire un graphe d'analyse combinée des rapports d'essais et illustrez exécuté avec succès et des tests a échoué.

Tout d'abord, comprenons la raison de Checkstyle ici: c'est un outil de développement qui aide les programmeurs à écrire un meilleur code Java en suivant des normes acceptées et bien connues.

Static Analysis Collector est un module complémentaire qui collecte différentes sorties d'analyse et imprime les résultats dans un graphique de tendance combiné. En outre, le plug-in fournit des rapports d'intégrité et crée une stabilité basée sur ces résultats groupés.

Enfin, le plugin JUnit fournit un éditeur qui consomme les rapports de test XML générés lors des builds et produit des informations détaillées et significatives relatives aux tests d'un projet.

Nous allons également configurer Checkstyle dans le pom.xml de notre application :

 org.apache.maven.plugins maven-checkstyle-plugin 2.17 

5. Création d'un script de pipeline

First, we need to create a new Jenkins job. Let's be sure to select Pipeline as the type before hitting the OK button as described in this screenshot:

The next screen allows us to fill in more details of the different steps of our Jenkins job, such as the description, triggers, some advanced project options:

Let's dive into the main and most important part of this kind of job by clicking on the Pipeline tab.

Then, for the definition select Pipeline script and check Use Groovy Sandbox.

Here is the working script for a Unix environment:

node { stage 'Clone the project' git '//github.com/eugenp/tutorials.git' dir('spring-jenkins-pipeline') { stage("Compilation and Analysis") { parallel 'Compilation': { sh "./mvnw clean install -DskipTests" }, 'Static Analysis': { stage("Checkstyle") { sh "./mvnw checkstyle:checkstyle" step([$class: 'CheckStylePublisher', canRunOnFailed: true, defaultEncoding: '', healthy: '100', pattern: '**/target/checkstyle-result.xml', unHealthy: '90', useStableBuildAsReference: true ]) } } } stage("Tests and Deployment") { parallel 'Unit tests': { stage("Runing unit tests") { try { sh "./mvnw test -Punit" } catch(err) { step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-*UnitTest.xml']) throw err } step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-*UnitTest.xml']) } }, 'Integration tests': { stage("Runing integration tests") { try { sh "./mvnw test -Pintegration" } catch(err) { step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-' + '*IntegrationTest.xml']) throw err } step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-' + '*IntegrationTest.xml']) } } stage("Staging") { sh "pid=\$(lsof -i:8989 -t); kill -TERM \$pid " + "|| kill -KILL \$pid" withEnv(['JENKINS_NODE_COOKIE=dontkill']) { sh 'nohup ./mvnw spring-boot:run -Dserver.port=8989 &' } } } } }

First, we're cloning the repository from GitHub, then changing the directory to our project, which is called spring-jenkins-pipeline.

Next, we compiled the project and apply Checkstyle analysis in a parallel way.

The following step represents a parallel execution of unit tests and integration tests, then deployment of the app.

Parallelism is used to optimize the pipeline, and have the job runs faster. It's a best practice in Jenkins to simultaneously run some independent actions that can take a lot of time.

For example, in a real-world project, we usually have a lot of unit and integration tests that can take longer.

Note that if any test failed the BUILD will be marked as FAILED too and the deployment will not occur.

Also, we're using JENKINS_NODE_COOKIE to prevent immediate shut down of our application when the pipeline reaches the end.

To see a more general script working on other different systems, check out the GitHub repository.

6. Analysis Report

After creating the job, we'll save our script and hit Build Now on the project home of our Jenkins dashboard.

Here's an overview of the builds:

A little further down we'll find the stage view of the pipeline, with the result of each stage:

Each output is accessible when hovering over a stage cell and clicking the Logs button to see the log messages printed in that step.

We can also find more details of the code analysis. Let's click on the desired build from the Build History on the right menu and hit Checkstyle Warnings.

Here we see 60 high priority warnings browsable by clicking:

The Details tab displays pieces of information that highlight warnings and enable the developer to understand the causes behind them.

In the same way, the full test report is accessible by clicking on Test Result link. Let's see the results of the com.baeldung package:

Here we can see each test file with its duration and status.

7. Conclusion

Dans cet article, nous avons configuré un environnement de livraison continue simple pour exécuter et afficher une analyse de code statique et un rapport de test dans Jenkins via une tâche Pipeline .

Comme toujours, le code source de cet article se trouve à l'adresse over sur GitHub.