Jenkinsfile per branch - Step-by-Step Execution

Process Flow - Jenkinsfile per branch

Start Jenkins Pipeline

↓

Detect current branch

↓

Load Jenkinsfile for branch

↓

Execute branch-specific pipeline

↓

Pipeline completes or fails

Jenkins detects the current branch, loads the matching Jenkinsfile, then runs the pipeline defined for that branch.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo "Building branch ${env.BRANCH_NAME}"
      }
    }
  }
}

A simple Jenkins pipeline that prints the current branch name during the build stage.

Process Table

Step	Action	Branch Detected	Jenkinsfile Loaded	Pipeline Output
1	Start pipeline	feature/login	Jenkinsfile-feature	N/A
2	Load Jenkinsfile	feature/login	Jenkinsfile-feature	N/A
3	Execute Build stage	feature/login	Jenkinsfile-feature	Building branch feature/login
4	Pipeline completes	feature/login	Jenkinsfile-feature	Success

💡 Pipeline ends after executing branch-specific Jenkinsfile for feature/login branch.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
env.BRANCH_NAME	undefined	feature/login	feature/login	feature/login	feature/login
Jenkinsfile Loaded	none	none	Jenkinsfile-feature	Jenkinsfile-feature	Jenkinsfile-feature
Pipeline Output	none	none	none	Building branch feature/login	Success

Key Moments - 2 Insights

How does Jenkins know which Jenkinsfile to use for each branch?

Jenkins detects the current branch name (see Step 1 in execution_table) and loads the Jenkinsfile matching that branch (Step 2). This allows branch-specific pipelines.

What happens if the Jenkinsfile for a branch is missing?

The pipeline will fail to load the Jenkinsfile at Step 2, causing the build to fail early. This is why each branch should have its own Jenkinsfile or fallback.

Visual Quiz - 3 Questions

Look at the execution_table, what is the branch detected at Step 1?

A feature/login

B main

C develop

D release

💡 Hint

Check the 'Branch Detected' column at Step 1 in the execution_table.

At which step does Jenkins load the branch-specific Jenkinsfile?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Jenkinsfile Loaded' column in the execution_table.

If the branch was 'main', how would the Jenkinsfile Loaded value change in the execution_table?

A Jenkinsfile-feature

B Jenkinsfile-main

C Jenkinsfile-develop

D No Jenkinsfile loaded

💡 Hint

The Jenkinsfile loaded matches the branch name as shown in the 'Jenkinsfile Loaded' column.

Concept Snapshot

Jenkinsfile per branch:
- Jenkins detects current branch via env.BRANCH_NAME
- Loads Jenkinsfile matching branch name
- Runs branch-specific pipeline steps
- Enables different workflows per branch
- Fails if Jenkinsfile missing for branch

Full Transcript

This visual execution shows how Jenkins runs a pipeline using a Jenkinsfile specific to the current branch. First, Jenkins detects the branch name, for example 'feature/login'. Then it loads the Jenkinsfile named for that branch, such as 'Jenkinsfile-feature'. Next, it executes the pipeline steps defined in that Jenkinsfile, here printing the branch name during the build stage. Finally, the pipeline completes successfully. If the Jenkinsfile for the branch is missing, the pipeline will fail early. This approach allows teams to customize CI/CD workflows per branch easily.

Practice

1. What is the main benefit of having a separate Jenkinsfile in each branch?

easy

A. It allows customizing the pipeline for each branch independently.

B. It forces all branches to use the same pipeline configuration.

C. It disables pipeline execution on branches without a Jenkinsfile.

D. It merges all branch pipelines into one global pipeline.

Solution

1. Step 1: Understand Jenkinsfile per branch concept

   Each branch can have its own Jenkinsfile, allowing different pipeline steps or settings per branch.

2. Step 2: Compare options

   It allows customizing the pipeline for each branch independently. correctly states the benefit. Options A, B, and D describe incorrect behaviors.

3. Final Answer:

   It allows customizing the pipeline for each branch independently. -> Option A

4. Quick Check:

   Separate Jenkinsfiles = branch-specific pipelines [OK]

Hint: Separate Jenkinsfiles mean separate pipelines per branch [OK]

Common Mistakes:

• Thinking one Jenkinsfile applies to all branches
• Assuming Jenkinsfile absence disables pipeline
• Believing pipelines merge automatically

2. Which of the following is the correct syntax to checkout from a specific branch in a multibranch pipeline?

easy

A. pipeline { agent any; stages { stage('Build') { steps { checkout([$class: 'GitSCM', branches: ['refs/heads/feature'], userRemoteConfigs: [[url: 'https://repo.git']]]) } } } }

B. pipeline { agent any; stages { stage('Build') { steps { git branch: 'main', url: 'https://repo.git' } } } }

C. pipeline { agent any; stages { stage('Build') { steps { load 'Jenkinsfile' } } } }

D. pipeline { agent any; stages { stage('Build') { steps { script { checkout scm } } } } }

Solution

1. Step 1: Identify correct syntax for branch checkout

   Using the git step with branch and url is the simplest correct way to checkout a specific branch.

2. Step 2: Analyze options

   The snippet using git branch: 'main', url: 'https://repo.git' is correct. The snippet using checkout([$class: 'GitSCM', branches: ['refs/heads/feature'], userRemoteConfigs: [[url: 'https://repo.git']]]) has invalid syntax for branches (expects list of maps like [[name: 'refs/heads/feature']]). The snippet using script { checkout scm } checks out the current SCM without specifying a branch. The snippet using load 'Jenkinsfile' loads a Groovy script but does not checkout a branch.

3. Final Answer:

   pipeline { agent any; stages { stage('Build') { steps { git branch: 'main', url: 'https://repo.git' } } } } -> Option B

4. Quick Check:

   Use git step with branch and url [OK]

Hint: Use git step with branch and url to specify branch [OK]

Common Mistakes:

• Using load to get Jenkinsfile instead of checkout
• Not specifying branch in checkout
• Confusing checkout scm with git step

3. Given this Jenkinsfile snippet inside a branch:

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          if (env.BRANCH_NAME == 'main') {
            echo 'Deploying main branch'
          } else {
            echo 'Deploying feature branch'
          }
        }
      }
    }
  }
}

What will Jenkins print if the branch is named feature/login?

medium

A. No output

B. Deploying main branch

C. Deploying feature branch

D. Pipeline fails with error

Solution

1. Step 1: Understand branch name condition

   The script checks if env.BRANCH_NAME equals 'main'. If yes, it prints 'Deploying main branch', else 'Deploying feature branch'.

2. Step 2: Apply branch name 'feature/login'

   Since the branch is 'feature/login', it does not equal 'main', so the else branch runs printing 'Deploying feature branch'.

3. Final Answer:

   Deploying feature branch -> Option C

4. Quick Check:

   Branch name check leads to else output [OK]

Hint: Check branch name string exactly for condition [OK]

Common Mistakes:

• Assuming partial match triggers main branch output
• Confusing env.BRANCH_NAME with other variables
• Expecting no output if branch is not main

4. You have a Jenkinsfile in your feature branch but the pipeline fails with error: groovy.lang.MissingPropertyException: No such property: env for class. What is the likely cause?

medium

A. The env variable is used outside a script block.

B. The Jenkinsfile is missing the pipeline block.

C. The branch name is incorrect in the Jenkinsfile.

D. The Jenkinsfile is not committed to the branch.

Solution

1. Step 1: Understand env variable usage

   In declarative pipelines, env variables must be accessed inside a script block to use Groovy expressions.

2. Step 2: Analyze error cause

   The error indicates env is not recognized, likely because it is used outside a script block where Groovy code runs.

3. Final Answer:

   The env variable is used outside a script block. -> Option A

4. Quick Check:

   Use env only inside script blocks [OK]

Hint: Access env variables only inside script blocks [OK]

Common Mistakes:

• Using env directly in steps without script
• Assuming missing pipeline block causes env error
• Not committing Jenkinsfile to branch

5. You want to maintain a single Jenkinsfile in the main branch but customize pipeline steps for feature/* branches without creating Jenkinsfiles in each feature branch. Which approach is best?

hard

A. Configure Jenkins to ignore feature branches.

B. Create symbolic links to the main Jenkinsfile in each feature branch.

C. Use separate Jenkinsfiles in each feature branch and merge them manually.

D. Use when { branch 'feature/*' } conditions inside the Jenkinsfile to run different stages.

Solution

1. Step 1: Understand single Jenkinsfile with branch conditions

   You can use when { branch 'pattern' } in declarative pipelines to run stages only on matching branches.

2. Step 2: Evaluate options

   Use when { branch 'feature/*' } conditions inside the Jenkinsfile to run different stages. uses branch conditions inside one Jenkinsfile, which fits the requirement. Create symbolic links to the main Jenkinsfile in each feature branch. is not practical or supported. Use separate Jenkinsfiles in each feature branch and merge them manually. contradicts the goal of single Jenkinsfile. Configure Jenkins to ignore feature branches. ignores feature branches, not customizing them.

3. Final Answer:

   Use when { branch 'feature/*' } conditions inside the Jenkinsfile to run different stages. -> Option D

4. Quick Check:

   Branch conditions enable single Jenkinsfile customization [OK]

Hint: Use when branch conditions for per-branch steps [OK]

Common Mistakes:

• Trying to link Jenkinsfiles across branches
• Creating multiple Jenkinsfiles despite single file goal
• Ignoring feature branches instead of customizing