pipeline {
agent any (1)
stages {
stage('Build') { (2)
steps { (3)
sh 'make' (4)
}
}
stage('Test'){
steps {
sh 'make check'
junit 'reports/**/*.xml' (5)
}
}
stage('Deploy') {
steps {
sh 'make publish'
}
}
}
}Pipeline
Table of Contents
This chapter will cover all aspects of Jenkins Pipeline, from running Pipelines to writing Pipeline code, and even extending Pipeline itself.
This chapter is intended to be used by Jenkins users of all skill levels, but beginners may need to refer to some sections of "Using Jenkins" to understand some topics covered in this chapter.
If you are not yet familiar with basic Jenkins terminology and features, start with Getting Started with Jenkins.
What is Jenkins Pipeline?
Jenkins Pipeline (or simply "Pipeline" with a capital "P") is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins.
A continuous delivery pipeline is an automated expression of your process for getting software from version control right through to your users and customers. Every change to your software (committed in source control) goes through a complex process on its way to being released. This process involves building the software in a reliable and repeatable manner, as well as the progression of the built software (called a "build") through multiple stages of testing and deployment.
Pipeline provides an extensible set of tools for modeling simple-to-complex delivery pipelines "as code" via the Pipeline Domain Specific Language (DSL) syntax. [1]
Typically, the definition of a Jenkins Pipeline is written into a text file
(called a Jenkinsfile) which in turn is checked into a
project’s source control repository.
[2]
This is the foundation of "Pipeline-as-Code"; treating the continuous delivery
pipeline a part of the application to be versioned and reviewed like any other code.
Creating a Jenkinsfile provides a number of immediate benefits:
-
Automatically create Pipelines for all Branches and Pull Requests
-
Code review/iteration on the Pipeline
-
Audit trail for the Pipeline
-
Single source of truth [3] for the Pipeline, which can be viewed and edited by multiple members of the project.
While the syntax for defining a Pipeline, either in the web UI or with a
Jenkinsfile, is the same, it’s generally considered best practice to define
the Pipeline in a Jenkinsfile and check that in to source control.
Here’s an example of a Jenkinsfile:
Jenkinsfile (Declarative Pipeline)
| 1 | agent indicates that Jenkins should allocate an executor and workspace for
this part of the Pipeline. |
| 2 | stage describes a stage of this Pipeline. |
| 3 | steps describes the steps to be run in this stage |
| 4 | sh executes the given shell command |
| 5 | junit is a Pipeline step provided by the
JUnit plugin
for aggregating test reports. |
Why Pipeline?
Jenkins is, fundamentally, an automation engine which supports a number of automation patterns. Pipeline adds a powerful set of automation tools onto Jenkins, supporting use cases that span from simple continuous integration to comprehensive continuous delivery pipelines. By modeling a series of related tasks, users can take advantage of the many features of Pipeline:
-
Code: Pipelines are implemented in code and typically checked into source control, giving teams the ability to edit, review, and iterate upon their delivery pipeline.
-
Durable: Pipelines can survive both planned and unplanned restarts of the Jenkins master.
-
Pausable: Pipelines can optionally stop and wait for human input or approval before continuing the Pipeline run.
-
Versatile: Pipelines support complex real-world continuous delivery requirements, including the ability to fork/join, loop, and perform work in parallel.
-
Extensible: The Pipeline plugin supports custom extensions to its DSL [1] and multiple options for integration with other plugins.
While Jenkins has always allowed rudimentary forms of chaining Freestyle Jobs together to perform sequential tasks, [4] Pipeline makes this concept a first-class citizen in Jenkins.
Building on the core Jenkins value of extensibility, Pipeline is also extensible both by users with Pipeline Shared Libraries and by plugin developers. [5]
The flowchart below is an example of one continuous delivery scenario easily modeled in Jenkins Pipeline:
Figure 1. Pipeline Flow
Pipeline Terms
- Step
-
A single task; fundamentally steps tell Jenkins what to do. For example, to execute the shell command
makeuse theshstep:sh 'make'. When a plugin extends the Pipeline DSL, that typically means the plugin has implemented a new step.
- Node
-
Most work a Pipeline performs is done in the context of one or more declared
nodesteps. Confining the work inside of a node step does two things:-
Schedules the steps contained within the block to run by adding an item to the Jenkins queue. As soon as an executor is free on a node, the steps will run.
-
Creates a workspace (a directory specific to that particular Pipeline) where work can be done on files checked out from source control.
-
| Depending on your Jenkins configuration, some workspaces may not get automatically cleaned up after a period of inactivity. See tickets and discussion linked from JENKINS-2111 for more information. |
- Stage
-
stageis a step for defining a conceptually distinct subset of the entire Pipeline, for example: "Build", "Test", and "Deploy", which is used by many plugins to visualize or present Jenkins Pipeline status/progress. [6]
4. Additional plugins have been used to implement complex behaviors utilizing Freestyle Jobs such as the Copy Artifact, Parameterized Trigger, and Promoted Builds plugins
Please submit your feedback about this page through this quick form.
Alternatively, if you don't wish to complete the quick form, you can simply indicate if you found this page helpful?
See existing feedback here.