How to write a Jenkins pipeline

Writing a Jenkins pipeline involves defining the build process using a domain-specific language (DSL). Pipelines can be written using either the Scripted Pipeline syntax or the Declarative Pipeline syntax. These pipelines are typically defined in a Jenkinsfile, which is checked into the source code repository alongside your application code. One can define stages, steps, and other configurations within the Jenkinsfile to orchestrate your build, test, and deployment processes.

How to build a pipeline in Jenkins?

Building a pipeline in Jenkins involves creating a new pipeline job within Jenkins and defining its configuration. A pipeline job can be created by navigating to the Jenkins dashboard, clicking on "New Item," providing a name for your job, and selecting "Pipeline" as the job type. Once the job is created, you define your pipeline script in the job configuration using either Scripted Pipeline or Declarative Pipeline syntax.

How to automate Jenkins pipeline?

Automating a Jenkins pipeline involves configuring triggers that initiate pipeline execution automatically based on predefined events. These triggers can include code commits to the version control system (e.g., Git), scheduled times, or other external triggers. In the job configuration page of a given pipeline job, it is possible to define build triggers under the "Build Triggers" section. By configuring appropriate triggers, it is possible to ensure that your pipeline runs automatically in response to relevant events, streamlining the continuous integration and delivery workflows.

What is the Jenkins pipeline? Types and stages of Jenkins CI:CD Pipelines

Q: What is Jenkins Pipeline?

Jenkins Pipeline is a suite of plugins that supports the integration and implementation of continuous delivery pipelines into Jenkins. It allows to define the build process as code, enabling you to automate and manage your entire software delivery pipeline in a more structured and efficient manner.

Posted On: 5 April 2024

An open-source automation server, Jenkins has emerged as a powerful tool for orchestrating software delivery pipelines as it is flexible and extensible. The Jenkins Pipeline allows teams to define and manage their software delivery workflows as it seamlessly fits into the DevOps practices while helping developers with hassle-free CI/CD. We shall learn a lot more in detail about what is Jenkins pipelines, what is Jenkins CI CD pipelines, types, and stages in this blog.

On that note, we walk you through the following in this blog:

What is a Jenkins Pipeline?
Different Types of Jenkins CI/CD Pipelines
Jenkins Pipeline stages
Why Use Jenkins Pipeline?
Integrate ACCELQ Test Automation with Jenkins Pipeline

What is Jenkins Pipeline?

The Jenkins Pipeline is a fundamental concept in Continuous Integration and Continuous

Delivery (CI/CD. What is a pipeline in Jenkins? The Jenkins Pipeline allows developers to define, manage, and automate a series of steps that transform source code into a deployable application. Jenkins Pipeline is one of the critical elements of Jenkins DevOps success.

This Pipeline encompasses tasks like code compilation, testing, packaging, and deployment, all of which can be seamlessly integrated into a single workflow. Jenkins Pipeline types can be divided into: Declarative and Scripted.

Jenkins Pipeline is a collection of plugins that helps launch “build, test, and deploy” processes in a pre-defined sequence. There are over 1000 plugins within the Jenkins ecosystem which means developers can opt for the best resources to execute CI CD pipelines. The concept of what is a Jenkins CI CD pipeline and how to build one has been discussed in detail in one of our recent blogs.

The objective here is to extend the CD practice capabilities, which aims to bring the software from version control to a user-facing release.

Different Types of Jenkins CI/CD Pipelines

Jenkins Pipelines offer a structured and efficient approach to orchestrating the build, test, and deployment needs. It enhances collaboration, reduces error, and accelerates software delivery.

Different Types of Jenkins Pipelines are designed to cater to specific needs and scenarios. The four main types of Jenkins pipelines are– Declarative, Scripted, Multibranch, and Shared Library; each of them brings distinct benefits and capabilities to the table. Let us prioritize the first two types for now.

While Scripted syntax and the associated Scripted pipelines have been around for some time, Declarative syntax and its associated Declarative pipelines are relatively new.

Scripted Pipeline

A scripted pipeline uses the Groovy (JVM-based) language to create a pipeline as code. Some software developers prefer this pipeline because the use of Groovy code paves the way for making numerous APIs available. As a result, developers can orchestrate rather complex CD pipelines.

For creating scripted pipelines in Jenkins, developers must include a pipeline code within the UI and save it. Here’s the general syntax of a scripted pipeline:

Jenkinsfile (Scripted Pipeline)

node {  

    stage('Build') { 

       …….

    }

    stage('Test') { 

       …….

    }

    stage('Deploy') { 

       …….

    }

}

Source: Jenkins.io

Challenges with a scripted pipeline:

The imbalance between developers’ experience in Groovy and Jenkins creates an impedance mismatch that is not easy to remove.
Although scripted syntax is powerful and expedites the creation of complex pipelines, it concurrently makes the pipeline hard to read and hard to manage.

Declarative Pipeline

The declarative pipeline follows a relatively newer syntax, which narrows the scope of the pipeline structure through a pre-defined “minimum necessary structure.” On the technical front, the declarative syntax follows a conditional statement logic that generates a series of stages, executed sequentially throughout the pipeline’s lifecycle. Here’s the general syntax of a declarative pipeline:

Jenkinsfile (Declarative Pipeline)

pipeline {

    agent any 

    stages {

        stage(‘Build’) { 

            steps {

                …….

            }

        }

        stage(‘Test’) { 

            steps {

                …….

            }

        }

        stage(‘Deploy’) { 

            steps {

                …….

            }

        }

    }

}

Source: Jenkins.io

Challenges with declarative pipeline:

Since declarative pipelines don’t make use of Groovy code, the declarative syntax doesn’t access valuable APIs. But, at the end of the day, the declarative syntax is uncomplicated to read and comparatively easier to manage.

Jenkins Pipeline stages:

Jenkins defines two kinds of stages for declarative pipelines:

Parallel Stages- A nested, variable number of stages can be executed in parallel in declarative pipelines. This is a common and well-known use case for carrying out “build” and “test” across different platforms. Whenever there’s a problem in these parallel stages, the developer can abort them using the failFast option.

Sequential Stages- The sequential stages facility extends the capability of parallel stages by allowing for nesting multiple stages within each parallel branch. A sequential stage is an excellent choice when a developer would like more visibility into the sequence of stages and the order in which they are executed.

The nested stage facility in declarative pipeline makes it easier to follow the lifecycle of a pipeline. It also allows developers to view the set of logical states more profoundly. The good thing is that Jenkins evolves rapidly around stages, which is the core of CI/CD. So, the chances are that the coming improvements will further simplify the process of testing and deploying applications.

Why Use Jenkins Pipeline?

With Jenkins Pipeline, developers can create a robust, maintainable, and scalable development environment that fills the gap between release and production. As soon as the Jenkins Pipeline is implemented in the source control repository, it advocates for the creation of pipelines for each branch. It further creates audit trails by default and executes against any changes to the code for testing and deployment.

Jenkins Pipeline offers powerful automation for software delivery pipelines, providing benefits such as:

Automation: Effortlessly automate the entire software delivery process, from build to deployment, reducing errors and ensuring consistent results.
Flexibility: Customize pipelines to fit specific project requirements, workflows, and technology stacks.
Reusability: Define pipelines as code for easy sharing and reuse across projects and teams, promoting collaboration and consistency.
Visibility: Gain clear visibility into each stage and step of the delivery process, enhancing accountability and troubleshooting capabilities.
CI/CD Support: Facilitate continuous integration and delivery practices with frequent code integration, automated testing, and seamless deployment.

Note: A single source of truth prevails for this pipeline so that everything is known, accessible, and editable at every point through time by resources.

Integrate ACCELQ Test Automation with Jenkins Pipeline

Test automation s integral to the Agile and DevOps approaches due to their ability to speed up software development and bring out the value of repeatable codes in a sophisticated development environment. The CI/CD agile software development process brings with it the need to automate tests. Hence, it’s here that the opportunity to tap into the power of test automation is increasingly tempting. Considering the power of Jenkins in driving CI/CD, it’s a natural choice to integrate test automation with Jenkins.

ACCELQ provides a native Jenkins plugin to help run CI pipeline-specific automation scripts on Jenkins and get the best performance. Download here!

Reach out to us for more info.

Bhuvaneswari Gireesh

Content Manager

She has over ten years of digital content experience and is deeply passionate about technology. Adept at producing different kinds of digital content, she is also a voracious reader. While English language is her first love, fitness comes a close second.