1. Overview

Jenkins is a popular open-source automation server that facilitates CI/CD processes through its workflow or pipeline feature. In software development, continuous integration and continuous delivery have become standard practices to ensure that code changes are thoroughly tested and automatically deployed to production environments.

Running stages in parallel with Jenkins Workflow/Pipeline is a technique that allows developers to execute multiple stages simultaneously, which can improve the overall performance and speed of the development process.

In this tutorial, we’ll explore how to run stages in parallel with a Jenkins workflow or pipeline job.

2. Understanding Jenkins Workflow/Pipeline

Jenkins Workflow or Pipeline is a powerful feature that allows us to define the build, test, and deployment of the code. Each step in the software development life cycle is represented by a stage in a pipeline job. A stage can consist of multiple sequential steps or tasks.

We can use stages to build, test, and deploy software applications automatically. Developers use stages in Jenkins Workflow/Pipeline to define the sequence of tasks that can execute as part of the software development process.

3. Understanding the Stages in Jenkins Workflow/Pipeline

In Jenkins Workflow/Pipeline, stages represent a distinct phase in the software development process. Each stage has a specific function, such as compiling code, running tests, or deploying code. The process ensures that code changes are thoroughly tested and integrated into the main branch quickly and frequently. Additionally, this approach helps developers to catch errors early and release software applications more reliably and faster.

Typically, there are three different types of stages in a Jenkins pipeline job:

  • A sequential stage executes the stages in order, starting with the first stage and continuing with the second stage
  • Parallel stages execute simultaneously and independently of each other, meaning that multiple stages can complete simultaneously
  • Conditional stages are the one that executes on a specific condition, like passing or failing a test

Furthermore, these stages are designed to help streamline processes and improve efficiency by breaking them down into smaller, more manageable parts that can be executed in a structured and organized manner.

4. Running Stages in Parallel

In some cases, we might want to speed up our pipeline by running multiple stages in parallel. We might have a stage that builds our application and another that runs automated tests. These stages can be run in parallel because the tests don’t depend on the completed build. Furthermore, we need to define a parallel block to run stages in parallel with Jenkins Workflow or Pipeline.

4.1. Parallel Blocks in JenkinsFile

The parallel block is a section of code that defines multiple stages to run in parallel. Let’s look at a pipeline job with a parallel block:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'echo "Building the application"'
                // Add commands to build application
        stage('Test') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        sh 'sleep 5s'
                        sh 'echo "Running unit tests"'
                        // Add commands to run unit tests
                stage('Integration Tests') {
                    steps {
                        sh 'echo "Running integration tests"'
                        // Add commands to run integration tests
        stage('Deploy') {
            steps {
                sh 'echo "Deploying the application"'
                // Add commands to deploy application

In the pipeline job above, we have three stages: build, test, and deploy. In this pipeline job, we have added simple steps to each stage to demonstrate the execution and workflow of a pipeline. The build stage is responsible for building the application code. To illustrate, there is only one step in the build stage, which is an echo command that prints the message “Building the application” to the console. This stage can have additional commands to build the code.

The test stage has a parallel block that defines two stages to run in parallel: Unit Tests and Integration Tests. The parallel directive allows both stages to run at the same time. Therefore, in this stage, we can’t be certain which stage will complete its task first. In the “Unit Tests” stage, the script first sleeps 5 seconds using the sleep command before executing an echo command to print “Running unit tests” to the console. Then, it runs commands to execute unit tests. In the “Integration Tests” stage, the script executes commands to run integration tests.

Finally, the Deploy stage is responsible for deploying the application code. Inside this stage, there is only one step, which is an echo command that prints the message “Deploying the application” to the console.

5. Benefits of Running Stages in Parallel

Running stages in parallel has several advantages for developers. It reduces the development process duration, which leads to faster execution. Furthermore, developers can also complete more work in less time with this feature.

Running parallel stages can accelerate the detection of errors and bugs, rendering software applications more reliable. By utilizing parallel stages, developers can enjoy these benefits and produce high-quality software applications efficiently.

6. Conclusion

In this article, we explored how to run multiple stages in parallel with a Jenkins workflow or pipeline job. First, we looked at the basic concepts and execution of the Jenkins pipeline job and its stages. After that, we ran multiple parallel stages in a Jenkins pipeline job. Finally, we also explored the benefits of running stages in parallel.

We can also find scripts to run multiple stages in parallel over on GitHub.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.