The Top 10 Jenkins Pipelines Examples

Introduction to Jenkins Pipelines

Jenkins pipelines refer to a technique or a way of defining, designing and implementing automated workflows in Jenkins for continuous integration and delivery (CI/CD) of software projects.

Jenkins pipelines allow software developers to define and execute automated workflows within a single uniform platform. These pipelines can be configured to execute various tasks such as building, testing, packaging, deploying, and releasing software code.

Jenkins pipelines are important for software development for the following reasons:

• Automation: Jenkins pipelines help automate the entire software development process, eliminating the need for manual intervention. This speeds up the development process, reduces errors, and ensures consistency in the code.

• Continuous Integration: By integrating code changes to a central repository, Jenkins pipelines help developers detect and fix issues quickly, leading to more stable and error-free code. This ensures that code changes are continuously integrated and tested, reducing the risks associated with manual integration.

• Continuous Delivery and Deployment: Through Jenkins pipelines, developers can automate the process of deploying applications to various environments, such as development, staging, and production. This helps in ensuring that the application is delivered and deployed according to the specified schedule, with minimal human effort.

• Customization: Jenkins pipelines offer a great level of customization, allowing developers to create and configure pipelines according to their specific needs. This flexibility has made Jenkins pipelines a popular choice among development teams.

• Visibility: Jenkins pipelines provide visibility into the entire software delivery process, allowing development teams to monitor and track code changes, builds, tests, and deployments. This facilitates collaboration and communication among team members, leading to faster and more efficient development.

Jenkins Pipeline for Continuous Integration

pipeline {
agent any
stages {
stage('Checkout') {
steps {
// Checkout code from version control system
git 'https://github.com/example/repository.git'
}
}

stage('Build') {
steps {
// Compile, test, and build the code
sh 'mvn clean package'
}
}

stage('Test') {
steps {
// Run automated tests
sh 'mvn test'
}
}

stage('Deploy') {
steps {
// Deploy the built code to a development environment
sh 'mvn tomcat7:redeploy'
}
}

stage('Promote to Production') {
when {
// Only trigger this stage if the changes are made to a certain branch
branch 'master'
}
steps {
// Deploy to production environment
sh 'mvn tomcat7:redeploy -Denvironment=production'
}
}

stage('Cleanup') {
steps {
// Clean up workspace and delete temporary files
sh 'mvn clean'
}
}
}

post {
// Perform these steps after the pipeline is completed
// For example, send email notifications
always {
emailext body: "Pipeline successful!",
recipientProviders: [[$class: 'DevelopersRecipientProvider']],
subject: "Jenkins pipeline notification",
to: "developers@example.com"
}

// In case of a failure, send an email to the specified recipients
failure {
emailext body: "Pipeline failed!",
recipientProviders: [[$class: 'DevelopersRecipientProvider']],
subject: "Jenkins pipeline notification",
to: "developers@example.com"
}
}
}

Jenkins Pipeline for Continuous Delivery/Deployment

pipeline {
agent any

stages {
stage('Build') {
steps {
// Pull code from version control
// Execute build commands
// Run tests
}
}

stage('Staging Deploy') {
steps {
// Use a deploy script or tool to deploy to staging environment
}
}

stage('Smoke Test') {
steps {
// Run automated smoke tests on staging environment
// Verify application is functioning correctly
}
}

stage('Production Deploy') {
steps {
// Use a deploy script or tool to deploy to production environment
}
}

stage('Functional Test') {
steps {
// Run automated functional tests on production environment
// Verify application is functioning correctly
}
}

stage('Promote to Production') {
steps {
// Upon successful functional tests, promote the release to production
}
}
}
}

Jenkins Pipeline for Automated Testing

pipeline {
agent any
environment{
JAVA_HOME ="path/to/java_home"
MAVEN_HOME = "path/to/maven_home"
}
stages {
stage('Checkout') {
steps {
checkout([$class: 'GitSCM', branches: [[name: '*/master']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])
}
}
stage('Build') {
steps {
sh 'mvn clean install'
}
}
stage('Unit Tests') {
steps {
sh 'mvn test'
}
post {
always {
junit 'target/surefire-reports/*.xml'
}
}
}
stage('Functional Tests') {
steps {
sh 'mvn integration-test'
}
post {
always {
junit 'target/failsafe-reports/*.xml'
}
}
}
stage('Acceptance Tests') {
steps {
sh 'mvn verify'
}
post {
always {
junit 'target/failsafe-reports/*.xml'
}
}
}
stage('Deployment') {
steps {
sh 'mvn deploy'
}
}
}
}

Jenkins Pipeline for Code Quality Analysis

node {
stage('Checkout') {
// Checkout code from version control
git 'git@github.com:username/repository.git'
}

stage('Build') {
// Perform build steps, such as compiling code
sh 'mvn clean install'
}

stage('Code Analysis') {
// Run static code analysis tools
// SonarQube
sh 'mvn sonar:sonar -Dsonar.host.url=<sonarqube_url> -Dsonar.login=<sonarqube_login> -Dsonar.password=<sonarqube_password>'
// PMD
sh 'mvn pmd:pmd'
}

stage('Quality Checks') {
// Run additional quality checks, such as unit tests
// JUnit test results will be recorded and displayed in Jenkins
sh 'mvn test'
}

stage('Deploy') {
// Deploy code to desired environment
sh 'mvn deploy'
}
}

Jenkins Pipeline for Containerization and Deployment to Kubernetes

node {
def app

stage('Clone repository') {
git 'https://github.com/example/repo.git'
}

stage('Build Docker image') {
app = docker.build('myapp:${BUILD_NUMBER}')
}

stage('Run unit tests') {
app.inside {
sh 'npm run test'
}
}

stage('Push image to Docker registry') {
docker.withRegistry('https://registry.example.com', 'credentials') {
app.push()
}
}

stage('Deploy to Kubernetes clusters') {
kubernetesDeploy (
configs: 'kubernetes-configs/*',
kubeconfigId: 'kubeconfig',
enableConfigSubstitution: true,
waitStrategy: '2 minutes',
secretNamespace: 'my namespace',
containers: [
[name: 'myapp', image: 'myapp:${BUILD_NUMBER}']
]
)
}
}

Jenkins Pipeline for Building and Deploying Java Applications

pipeline {
agent any

parameters {
string(defaultValue: '1.0', description: 'Version of the application', name: 'version')
choice(defaultValue: 'master', choices: ['master', 'develop', 'feature/*'], description: 'Git branch to build from', name: 'branch')
booleanParam(defaultValue: true, description: 'Run code analysis', name: 'runCodeAnalysis')
}

stages {
stage('Checkout') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: "${params.branch}"]],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'LocalBranch', localBranch: "**"]],
submoduleCfg: [],
userRemoteConfigs: [
[url: 'https://github.com/myorg/myrepo.git']
]
])
}
}
stage('Build') {
steps {
script {
def mavenHome = tool 'Maven'
sh "${mavenHome}/bin/mvn clean package"
}
}
}
stage('Unit Tests') {
steps {
script {
def mavenHome = tool 'Maven'
sh "${mavenHome}/bin/mvn test"
}
}
}
stage('Static Code Analysis') {
when {
expression {
params.runCodeAnalysis == true
}
}
steps {
script {
def findbugsHome = tool 'FindBugs'
sh "${findbugsHome}/bin/findbugs -gui target/classes"
}
}
}
stage('Integration Tests') {
steps {
script {
def mavenHome = tool 'Maven'
sh "${mavenHome}/bin/mvn verify"
}
}
}
stage('Package') {
steps {
script {
def appVersion = "${params.version}"
def appArtifact = "myapp-${appVersion}.jar"
archiveArtifacts artifacts: appArtifact, fingerprint: true
stash includes: "${appArtifact}", name: 'artifact'
}
}
}
stage('Deploy') {
steps {
script {
def server = 'http://myserver:8080'
def credentialsId = 'my_credentials'
unstash 'artifact'
def appVersion = "${params.version}"
def appArtifact = "myapp-${appVersion}.jar"
def pom = 'pom.xml'
def mavenHome = tool 'Maven'

withCredentials([[
$class: 'UsernamePasswordMultiBinding',
usernameVariable: 'USERNAME',
passwordVariable: 'PASSWORD',
credentialsId: "${credentialsId}"
]]) {
sh "${mavenHome}/bin/mvn deploy:deploy-file -Durl=${server}/repo -DrepositoryId=myrepo -Dfile=${appArtifact} -DpomFile=${pom} -Dpackaging=jar -Dversion=${appVersion} -DgroupId=myorg -DartifactId=myapp -DgeneratePom=true -DuniqueVersion=false -Dusername=${USERNAME} -Dpassword=${PASSWORD}"
}
}
}
}
}
post {
failure {
emailext body: "Pipeline for ${params.branch} branch failed. Please check Jenkins console output for more details.",
mimeType: 'text/html',
recipientProviders: [developers()],
replyTo: '',
subject: "Pipeline failed for ${params.branch} branch"
}
success {
emailext body: "Pipeline for ${params.branch} branch passed.",
mimeType: 'text/html',
recipientProviders: [developers()],
replyTo: '',
subject: "Pipeline passed for ${params.branch} branch"
}
always {
cleanWs()
}
}
}

Jenkins Pipeline for Building and Deploying Mobile Applications

pipeline {
agent any

stages {
stage('Build') {
steps {
// Checkout code from source control
git 'https://github.com/example/mobile-app.git'

// Build the app using Xcode
sh 'xcodebuild -workspace MyApp.xcworkspace -scheme MyApp -configuration Release build'

// Or build the app using Android Studio
sh './gradlew assembleRelease'
}
}

stage('Test') {
steps {
// Run automated tests using XCTest or Espresso
sh 'xcodebuild test -workspace MyApp.xcworkspace -scheme MyApp -configuration Release -destination "platform=iOS Simulator,name=iPhone 11"'

// Or run automated tests using Robolectric or Espresso
sh './gradlew test'
}
}

stage('Deploy') {
steps {
// Archive the app
sh 'xcodebuild archive -workspace MyApp.xcworkspace -scheme MyApp -configuration Release -archivePath MyApp.xcarchive'

// Or build the APK
sh './gradlew assembleRelease'

// Upload the app to your distribution channel (e.g. App Store or Google Play)
sh 'altool --upload-app -f MyApp.xcarchive -t ios --apiKey <Your API Key>'
// Or upload the APK
sh 'gcloud app deploy myApp.apk'
}
}
}
}

Jenkins Pipeline for Infrastructure as Code

stage('Checkout source code') {
// checkout code from source control management (e.g., Git)
git credentialsId: 'git-credentials', url: 'https://github.com/example/infrastructure.git'
}
stage('Install dependencies') {
// install any dependencies required for provisioning and deployment tools
sh 'pip install -r requirements.txt'
}
stage('Provision infrastructure') {
// use Terraform to provision infrastructure (e.g., create servers, load balancers, etc.)
sh 'terraform init'
sh 'terraform plan -out=tfplan'
sh 'terraform apply -input=false -auto-approve tfplan'
}
stage('Deploy application') {
// use Ansible to deploy application to the provisioned infrastructure
sh 'ansible-playbook -i inventory playbook.yml'
}
stage('Test deployment') {
// run any automated tests to ensure the deployment was successful
sh 'pytest tests/'
}
stage('Destroy infrastructure') {
// destroy infrastructure once deployment and testing is complete
sh 'terraform destroy -input=false -auto-approve'
}

Jenkins Pipeline for Security Testing

node {
stage('Checkout') {
git 'https://github.com/example/repo.git'
}
stage('Build') {
sh 'mvn clean package'
}
stage('Static Code Analysis') {
sh 'mvn findbugs:findbugs'
}
stage('Unit Tests') {
sh 'mvn test'
}
stage('Security Testing') {
sh 'mvn owasp:dependency-check'
sh 'mvn org.owasp:dependency-check-maven:check -Dformat=ALL'
sh 'mvn verify -DskipTests -DskipCucumberTests -Dfindbugs-maven-plugin.findbugs.skip=true -Dcheckstyle.skip=true -Dpmd.skip=true'
}
stage('Functional Tests') {
sh 'mvn gatling:test'
}
stage('Publish') {
junit 'target/surefire-reports/*.xml'
archiveArtifacts allowedFailures: 'dist/test-results/.xml', artifacts: 'target/.jar'
emailext attachLog: true, body: '', mimeType: 'text/html', subject: "Build \${currentBuild.fullDisplayName} test results are \${currentBuild.result}", to: 'example@example.com'
}
stage('Deploy') {
sh 'cf push app-name -p target/*.jar'
}
}