Jenkinsfile

Jenkinsfile with Multi-Stage Pipeline (Best Practices & Scenarios)

A Jenkinsfile is a script that defines a Jenkins pipeline. Multi-stage pipelines help in structuring CI/CD workflows efficiently, ensuring code is built, tested, and deployed systematically.

---

1. Basic Multi-Stage Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any

    environment {
        DOCKER_IMAGE = "myapp:latest"
    }

    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/user/repo.git'
            }
        }

        stage('Build') {
            steps {
                sh 'docker build -t $DOCKER_IMAGE .'
            }
        }

        stage('Test') {
            steps {
                sh 'docker run --rm $DOCKER_IMAGE npm test'
            }
        }

        stage('Push to Registry') {
            when {
                branch 'main'
            }
            steps {
                withDockerRegistry([credentialsId: 'docker-hub-credentials', url: 'https://index.docker.io/v1/']) {
                    sh 'docker push $DOCKER_IMAGE'
                }
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh './deploy.sh'
            }
        }
    }

    post {
        success {
            echo 'Pipeline executed successfully!'
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}

---

2. Breakdown of Key Sections

2.1 agent

• Defines where the pipeline will run.

• Example:

  agent any  // Runs on any available agent

• Best Practice: Use labels to specify a dedicated agent.

  agent { label 'docker' }

---

2.2 environment (Global Variables)

• Stores environment variables.

• Example:

  environment {
      DOCKER_IMAGE = "myapp:latest"
  }

• Best Practice: Keep credentials in Jenkins Credentials Store instead of hardcoding them.

---

2.3 stages (Multi-Stage Structure)

Stage	Purpose
Checkout	Fetch source code
Build	Compile/build the application
Test	Run unit/integration tests
Push to Registry	Push Docker image to registry (e.g., Docker Hub, ECR, GCR)
Deploy	Deploy application

---

2.4 when Conditionals

• Used to run stages conditionally.

• Example: Run only on main branch:

  when {
      branch 'main'
  }

• Best Practice: Use when to avoid unnecessary runs on feature branches.

---

2.5 post Actions

• Defines actions based on pipeline success/failure.

• Example:

  post {
      success {
          echo 'Pipeline executed successfully!'
      }
      failure {
          echo 'Pipeline failed!'
      }
  }

---

3. Optimized Jenkinsfile with Multi-Stage Docker Build

pipeline {
    agent any

    environment {
        IMAGE_NAME = 'myapp'
        IMAGE_TAG = 'latest'
        DOCKER_REGISTRY = 'mydockerhub'
    }

    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/user/repo.git'
            }
        }

        stage('Build') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}")
                }
            }
        }

        stage('Test') {
            steps {
                script {
                    docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}").inside {
                        sh 'npm test'
                    }
                }
            }
        }

        stage('Push Image') {
            when {
                branch 'main'
            }
            steps {
                withDockerRegistry([credentialsId: 'docker-hub-credentials', url: '']) {
                    script {
                        docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}").push()
                    }
                }
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh './deploy.sh'
            }
        }
    }

    post {
        success {
            echo "Pipeline completed successfully!"
        }
        failure {
            echo "Pipeline failed!"
        }
    }
}

---

4. Multi-Stage Jenkinsfile with Parallel Execution

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/user/repo.git'
            }
        }

        stage('Build and Test') {
            parallel {
                stage('Build') {
                    steps {
                        sh 'docker build -t myapp:latest .'
                    }
                }
                stage('Test') {
                    steps {
                        sh 'docker run --rm myapp:latest npm test'
                    }
                }
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh './deploy.sh'
            }
        }
    }
}

✅ Best Practice: Use parallel to speed up execution.

---

5. Best Practices for Jenkinsfiles

✅ Use Declarative Pipelines

• Prefer declarative syntax (pipeline {}) over scripted (node {}) for readability.

✅ Keep Secrets in Jenkins Credentials

• Store API keys, Docker passwords securely:

  withCredentials([string(credentialsId: 'docker-hub-pass', variable: 'DOCKER_PASS')]) {
      sh 'docker login -u myuser -p $DOCKER_PASS'
  }

✅ Use when Conditions for Better Control

• Avoid unnecessary stages for non-main branches.

✅ Use Docker Caching

• Improve build speed by caching layers.

  docker.build("myapp:latest", "--cache-from=myapp:latest .")

✅ Implement Parallel Execution

• Run independent stages in parallel to save time.

---

6. Scenario-Based Jenkinsfile Interview Questions

Q1: How do you run unit tests inside a container?

Answer: Use docker.image().inside {}

docker.image("myapp:latest").inside {
    sh 'npm test'
}

---

Q2: How do you ensure the deployment runs only on the main branch?

Answer: Use when { branch 'main' }

stage('Deploy') {
    when {
        branch 'main'
    }
    steps {
        sh './deploy.sh'
    }
}

---

Q3: How do you store and use secrets securely in Jenkins?

Answer: Use withCredentials()

withCredentials([string(credentialsId: 'my-secret', variable: 'SECRET')]) {
    sh 'echo $SECRET'
}

---

7. Summary

Topic	Key Takeaways
Multi-Stage Pipelines	Organize CI/CD workflows efficiently
Parallel Execution	Speed up build/test stages
when Condition	Control execution based on branch/environment
Docker Caching	Reduce build times
Jenkins Credentials	Store secrets securely

This multi-stage Jenkinsfile guide covers best practices, optimizations, and interview scenarios! 🚀 Let me know if you need more examples. 😊