Jenkins Declarative Pipelines: A Beginner-Friendly Guide

6 min readDec 20, 2023

Introduction to Jenkins Declarative Pipeline Syntax:

In the vast world of automated software development, Jenkins Declarative Pipelines stand out as a helpful tool, especially for beginners. In this blog post, we’ll break down the basics of Declarative Pipeline syntax, explore its structure, and dive into real-world examples using simple words.

Understanding Declarative Pipeline Structure:

Pipeline Structure:

A Declarative Pipeline has sections like pipeline, agent, and stages.
It follows a specific structure to make sure your pipeline is well-organized and easy to understand.

Basic Example:

Here’s a simplified example of a Declarative Pipeline:

Declarative Pipeline Structure:

1. Starting Point:

The script begins with the keyword pipeline. Think of this as the starting point, the overarching structure for your pipeline.

2. Agent Any:

The line agent any specifies that this pipeline can run on any available build agent. It's like saying, "Hey Jenkins, feel free to run this on any server you have."

3. Stages:

The stages section is like dividing your pipeline into different phases or stages of development. In this case, there are three stages: build, test, and deploy.

4. Build Stage:

Within the build stage, there is a steps section. Think of steps as individual tasks or actions to be performed. In this case, there is a single step, representing a specific action in the build process.

5. Test Stage:

Similarly, the test stage has its own set of steps. Each stage can have one or many steps, depending on what needs to be done.

6. Deploy Stage:

Finally, the deploy stage represents the deployment phase. Again, it has its own set of steps, indicating the actions to deploy the application.
Explanation in Simple Words:

Imagine you’re baking a cake. The pipeline is like the recipe, providing the structure for your baking adventure.

agent any says, "You can bake this cake in any kitchen."
stages are the main steps in your recipe: mixing, baking, and decorating.
In each stage, you have specific actions or steps. For mixing, you might have steps like "mix flour" and "add eggs."
Similarly, for baking, you have steps like “preheat oven” and “put the cake in.”

In Jenkins, this declarative pipeline is a set of instructions, guiding Jenkins on how to execute each stage of your software development process. Each stage contains the specific tasks needed for building, testing, and deploying your application.

This structure makes it clear and easy to follow, especially for beginners. Just like following a recipe, you go step by step, ensuring a smooth and organized development journey.

Real-world Examples:

NodeJS Application:

Tools Keyword:

The tools keyword is like telling Jenkins, "Hey, we need NodeJS for this job!" It ensures that the necessary NodeJS tooling is available on the build agent. Imagine it as equipping your kitchen with the right tools before cooking.

Stages:

The script is divided into four stages: cloning, dependencies, test, and deploy. Think of these stages as distinct phases in your development process.

Cloning Stage:

The cloning stage involves getting the source code for your project. It's like fetching the recipe before you start cooking. The git clone command brings in the code into the workspace allocated for this pipeline.

Dependencies Stage:

In the dependencies stage, the script handles project dependencies. Dependencies are like the ingredients needed for your recipe. The npm install command installs all the required NodeJS packages or ingredients.

Test Stage:

Moving on to the test stage. Here, you're ensuring that everything works as expected. Imagine doing a taste test in your cooking analogy. The script runs an NPM script command for testing.

Deploy Stage:

Finally, the deploy stage is like serving the final dish. This is where you make your application available for use. The script likely runs a command for deployment, making your NodeJS application accessible

Explanation in Simple Words:

Imagine you’re cooking a delicious meal. This declarative pipeline is your recipe, guiding you through each step:

Prepare Your Kitchen (tools): Ensure you have the right tools (NodeJS) in your kitchen (build agent).
Get the Recipe (cloning): Fetch the recipe (source code) from your cookbook (version control system).
Get the Ingredients (dependencies): Gather all the ingredients (project dependencies) needed for your dish (NodeJS application).
Taste Test (test): Taste test your dish (run tests) to make sure it's delicious (working correctly).
Serve the Dish (deploy): Finally, serve your delicious dish (deploy your NodeJS application) for everyone to enjoy.

This declarative pipeline script automates these steps, making your development process efficient and organized, just like following a recipe for a perfect meal.

2. Java Application with Maven:

Agent Section:

The agent section sets the environment for your "kitchen" (build agent). In this case, it specifies that the pipeline must execute on a build agent tagged with the docker label. Think of this as preparing a kitchen with the necessary tools for a specific recipe.

Environment Section:

The environment section is like gathering all your ingredients before cooking. It sets up script variables (ingredients) that will be used later in the pipeline. For example, it might define variables like Image and Version for your Docker image.

Stages:

The pipeline has two stages: build and publish. Stages are like phases in your cooking process.

Build Stage:

In the build stage, it specifies a different agent to execute on. This is like switching to a specialized kitchen for a specific part of the recipe. It leverages a Maven Docker container for building the Java application.
The post section captures compiled JAR files. Think of this as saving a dish you just cooked for later use. These JAR files become artifacts that can be referenced in later stages.

Publish Stage:

The publish stage is where your final dish (Java application) is shared with others. It executes only if the source control branch is the master branch, ensuring that only completed and tested features are shared.
The multi-line step declaration is a way of expressing more complex actions. It’s like providing detailed instructions for a part of the recipe that requires more steps.
String interpolation in the multi-line build step is like referring back to earlier steps in your recipe. For example, using the Image and Version variables defined in the environment section.

Explanation in Simple Words:

Imagine you’re cooking a special dish in your kitchen, and each part of the recipe requires specific tools and ingredients.

Setting Up Your Kitchen (agent): Make sure your kitchen is ready with the right tools. In this case, it's a kitchen labeled with the docker tag.
Gathering Ingredients (environment): Collect all the ingredients you'll need for your recipe. Define variables like Image and Version for later use.
Cooking in Phases (stages): Break down your recipe into different cooking phases. In this example, you have a build phase and a publish phase.
Specialized Cooking (build Stage): For a specific part of your recipe, switch to a specialized kitchen (Maven Docker container). Save the results (compiled JAR files) for later.
Sharing Your Dish (publish Stage): Share your completed dish (Java application) only if it's fully cooked (master branch). The detailed steps in the multi-line declaration ensure everything is just right.

This declarative pipeline automates your cooking process, ensuring that your Java application is built, tested, and shared reliably. Each stage represents a crucial part of the recipe, making your development kitchen efficient and organized.

Conclusion:

Declarative Pipelines provide a structured and opinionated approach to automation. It’s like following a recipe with clear steps. Whether you’re building a NodeJS or Java application, the syntax guides you through setting up your development pipeline.

For beginners, think of it as a roadmap for your software development journey. It helps you organize tasks, making it easier to understand and manage. With clear stages and steps, you can navigate the complex world of continuous integration and deployment without feeling overwhelmed.