Search for a command to run...
No comments yet. Be the first to comment.
Azure Solution for SmartBuildings
RAG
Make it variables and reusable
Scaling pipeline to accept Dynamic inputs
Scaling with branches
The goal of this project is to create and run the first Jenkins Pipeline that automates the process of building and testing an application.
In this exercise, we will configure Jenkins to pull application code from a Git repository, execute build commands using Maven, and run automated tests. This introduces the fundamental structure of a Jenkins Declarative Pipeline, including stages such as workspace cleanup, source code checkout, build execution, and testing.
By the end of this project, you will understand how Jenkins pipelines automate repetitive development tasks and form the foundation of modern CI/CD workflows.
The purpose of this exercise is to demonstrate how Jenkins pipelines automate the software development lifecycle by defining a structured workflow for building and testing applications.
In traditional development environments, developers manually run build and test commands. Jenkins pipelines eliminate these manual steps by automatically executing them whenever a job is triggered.
Through this project, you will learn how to:
Define a Declarative Jenkins Pipeline
Organize automation tasks using pipeline stages
Integrate Jenkins with Git repositories
Execute build and test commands automatically
Understand how CI pipelines validate code changes
This hands-on exercise introduces the core concept of Continuous Integration, where code is automatically built and verified before moving further in the deployment pipeline.
Before starting this project, ensure the following requirements are completed:
Ready to use Host and the directory structure to run Dockerfiles and docker-compose.yml (Refer to Part 1)
Demo-app repo: Fork the application repository used for the pipeline demonstration:
/home/jenkins/jenkins_home/docker-compose.yml
docker-compose.yml
services:
jenkins:
container_name: jenkins
image: jenkins/jenkins
ports:
- "8080:8080"
volumes:
- $PWD/jenkins_home:/var/jenkins_home
networks:
- net
networks:
net:
Note- No need to use customized Dockerfile since this will download a jenkins image from Docker Hub which has enough packages required for this project
docker compose up -d
# Login
docker exec -it -u root jenkins bash
# Install maven
apt-get install maven
Note- Since I have Maven already installed, it shows it exists
maven-pipeline
Create Jenkinsfile seperatly and paste it into Pipleine script area
Demo application repo can be forked
pipeline {
agent any
stages {
stage('Clean Workspace') {
steps {
deleteDir()
}
}
stage('Checkout Code') {
steps {
git url: 'https://github.com/abhinandan-chougule/demo-app-java-maven.git', branch: 'main'
}
}
stage('Build with Maven') {
steps {
sh 'mvn clean install'
}
}
stage('Run Tests') {
steps {
sh 'mvn test'
}
}
}
}
Build Now
Note- We will make use of Jenkins is from above project
Fork repo
Jenkinsfile placed at below locaion in repo and will be used
maven-github-pipeline
Definition: Pipeline script from SCM
SCM: Git
Repository URL : Forked repo HTTP URL
Branch Specifier (blank for 'any'): */main
Script Path: jenkins/Jenkinsfile
Build now
This is not cloning the repo again, instead it's checking if there are any latest commits and changes
Done!!!
Project: 5 Multibranch Pipeline
devbranch"
Done!!!
Create a Jenkins pipeline named parameter-pipeline that accepts user inputs through parameters to control a deployment configuration. The pipeline should allow the user to specify a custom deployment name, choose the target AWS Availability Zone, and confirm the deployment before execution.
The purpose of this Configuration is to demonstrate how parameterized Jenkins pipelines work. By defining parameters, the pipeline becomes more flexible and interactive, allowing users to provide deployment-specific inputs at runtime instead of hardcoding values in the pipeline.
This exercise introduces three commonly used Jenkins parameter types:
String Parameter – to provide a custom deployment name.
Choice Parameter – to select the AWS Availability Zone (EU-WEST-2A, EU-WEST-2B, EU-WEST-2C).
Boolean Parameter – to confirm whether the deployment should proceed.
Using parameterized pipelines is a common practice in DevOps CI/CD workflows, enabling controlled deployments across different environments or regions while minimizing manual changes to pipeline code.
Here is the code that will be used
pipeline {
agent any
parameters {
string(
name: "deploymentName",
defaultValue: "",
description: "Deployment Name?"
)
choice(
name: "azDeploy",
choices: ["ap-southeast-1a", "ap-southeast-1b", "ap-southeast-1c"],
description: "What AZ?"
)
booleanParam(
name: "confirmDeploy",
defaultValue: false,
description: "CONFIRM DEPLOYMENT?"
)
}
stages {
stage("Deploy") {
steps {
echo "Deployment Name: ${params.deploymentName}"
echo "AZ Selected: ${params.azDeploy}"
echo "Deployment Confirmation: ${params.confirmDeploy}"
}
}
}
}
parameter-pipeline"
pipeline script
Build Now
build with parameters
console output
Done!!!
Create a Jenkins pipeline that demonstrates how to define and use environment variables within a Jenkins Declarative Pipeline. The pipeline initializes different types of variables (string, number, and boolean) and verifies that they can be accessed and printed during pipeline execution.
The purpose of this task is to understand how environment variables work inside a Jenkins pipeline and how they can be referenced within stages and steps. By defining variables such as a string, a number, and a boolean inside the environment block, the pipeline provides a simple demonstration of how configuration values can be stored and reused across pipeline stages.
This approach helps standardize pipeline configurations and allows DevOps engineers to manage commonly used values in a centralized location within the pipeline. Environment variables are widely used in CI/CD workflows for tasks such as configuring application settings, defining build parameters, and passing values between different stages of a pipeline.
Through this exercise, users learn how Jenkins pipelines can manage and reference variables efficiently, which is a foundational concept when building more advanced automation and deployment pipelines.
pipeline {
agent any
environment {
def myString = "Hello World"
def myNumber = 10
def myBool = true
}
stages{
stage("Demo") {
steps {
echo "myString: ${myString}"
echo "myNumber: ${myNumber}"
echo "myBool: ${myBool}"
}
}
}
}
pipeline script
Build Now
Now we can see the pipeline using the variables given in the environment block
In this part of the Jenkins CI/CD series, we created and executed our first Jenkins pipeline. The pipeline automated a basic CI workflow that includes cleaning the workspace, cloning source code from Git, building the application using Maven, and running automated tests.
This project introduced the fundamental structure of Jenkins pipelines and demonstrated how build and test processes can be automated through a simple pipeline script.
Understanding how to create and execute pipelines is a critical step toward building scalable CI/CD workflows. Jenkins pipelines allow teams to standardize build processes, reduce manual intervention, and ensure consistent application validation.
In the next part of the series, we will expand Jenkins automation capabilities by enabling it to execute commands on remote servers using SSH, which is a common requirement in deployment and infrastructure automation workflows.
⬅️ Previous Article: Part 1 Install Jenkins with Docker
➡️ Next Article: Part 3 Jenkins SSH Remote Execution
⭐ If you found this article useful, follow https://ask-abhi.com for more DevOps tutorials.