Pipeline triggers and upstream/downstream in Jenkins - Mini Project: Build & Apply

Pipeline triggers and upstream/downstream

📖 Scenario: You work in a team where multiple Jenkins pipelines depend on each other. One pipeline builds the application, and another deploys it. You want the deploy pipeline to start automatically after the build pipeline finishes successfully.

🎯 Goal: Build two Jenkins pipelines where the deploy pipeline is triggered automatically after the build pipeline completes. You will create the build pipeline, configure the deploy pipeline to trigger after the build, and verify the trigger works.

📋 What You'll Learn

Create a Jenkins pipeline named BuildApp with a simple build step

Create a Jenkins pipeline named DeployApp

Configure DeployApp to trigger automatically after BuildApp completes

Print a message in DeployApp to confirm it was triggered

💡 Why This Matters

🌍 Real World

In real projects, build and deploy pipelines often depend on each other. Automating triggers saves time and reduces errors.

💼 Career

Understanding pipeline triggers is essential for DevOps engineers to create efficient CI/CD workflows.

1

Create the BuildApp pipeline

Create a Jenkins pipeline named BuildApp with a pipeline block. Inside the stages, add one stage named Build that runs a shell command to print Building application....

Jenkins

// Your code here to create BuildApp pipeline
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Add shell command here
            }
        }
    }
}

Hint

Use pipeline block with agent any. Inside stages, add a stage('Build') with steps running sh 'echo Building application...'.

2

Create the DeployApp pipeline

Create a Jenkins pipeline named DeployApp with a pipeline block. Inside the stages, add one stage named Deploy that runs a shell command to print Deploying application....

Jenkins

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'echo Building application...'
            }
        }
    }
}

// Your code here to create DeployApp pipeline
pipeline {
    agent any
    stages {
        stage('Deploy') {
            steps {
                // Add shell command here
            }
        }
    }
}

Hint

Similar to the build pipeline, create a pipeline block with agent any. Add a stage('Deploy') with steps running sh 'echo Deploying application...'.

3

Configure DeployApp to trigger after BuildApp

In the DeployApp pipeline, add a triggers block inside the pipeline block. Use the upstream trigger to start DeployApp automatically after BuildApp completes successfully.

Jenkins

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'echo Building application...'
            }
        }
    }
}

pipeline {
    agent any
    triggers {
        // Add upstream trigger here
    }
    stages {
        stage('Deploy') {
            steps {
                sh 'echo Deploying application...'
            }
        }
    }
}

Hint

Inside the DeployApp pipeline, add triggers { upstream('BuildApp') } to trigger after the build pipeline.

4

Print confirmation in DeployApp pipeline

Add a post block inside the DeployApp pipeline. In the success section, add a step to print DeployApp triggered after BuildApp to confirm the trigger worked.

Jenkins

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'echo Building application...'
            }
        }
    }
}

pipeline {
    agent any
    triggers {
        upstream('BuildApp')
    }
    stages {
        stage('Deploy') {
            steps {
                sh 'echo Deploying application...'
            }
        }
    }
    // Add post block here
}

Hint

Use a post block with success inside the DeployApp pipeline to print the confirmation message.

Practice

1. What is the main purpose of using pipeline triggers in Jenkins?

easy

A. To delete old job logs automatically

B. To manually run jobs one by one

C. To stop all jobs from running

D. To automatically start a job when another job finishes

Solution

1. Step 1: Understand pipeline triggers

   Pipeline triggers are used to start one job automatically after another job finishes.

2. Step 2: Identify the purpose

   This automation helps connect jobs without manual intervention.

3. Final Answer:

   To automatically start a job when another job finishes -> Option D

4. Quick Check:

   Pipeline triggers = automatic job start [OK]

Hint: Triggers start jobs automatically after others finish [OK]

Common Mistakes:

• Thinking triggers run jobs manually
• Confusing triggers with log cleanup
• Believing triggers stop jobs

2. Which syntax correctly triggers a downstream job named Build-App after the current pipeline completes successfully?

easy

A. build job: 'Build-App', propagate: true, wait: true

B. trigger job: 'Build-App' onSuccess

C. start job 'Build-App' after success

D. run job 'Build-App' always

Solution

1. Step 1: Recall Jenkins pipeline syntax for triggering jobs

   The correct syntax uses the build step with parameters like job, propagate, and wait.

2. Step 2: Match the correct syntax

   build job: 'Build-App', propagate: true, wait: true matches the correct syntax exactly.

3. Final Answer:

   build job: 'Build-App', propagate: true, wait: true -> Option A

4. Quick Check:

   Correct build step syntax = build job: 'Build-App', propagate: true, wait: true [OK]

Hint: Use 'build job:' syntax to trigger downstream jobs [OK]

Common Mistakes:

• Using incorrect keywords like 'trigger' or 'start'
• Missing required parameters
• Wrong order or syntax errors

3. Given this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building...'
      }
    }
    stage('Trigger Test') {
      steps {
        build job: 'Test-Job', propagate: true, wait: true
      }
    }
  }
}

What happens when the 'Build' stage completes successfully?

medium

A. 'Test-Job' runs in parallel without waiting

B. The 'Test-Job' pipeline starts and Jenkins waits for it to finish

C. The pipeline stops after 'Build' stage

D. An error occurs because 'build' is not a valid step

Solution

1. Step 1: Understand the 'build' step with 'wait: true'

   The 'build' step triggers another job and waits for it to complete before continuing.

2. Step 2: Analyze the pipeline flow

   After 'Build' stage, 'Test-Job' starts and Jenkins waits for it to finish before moving on.

3. Final Answer:

   The 'Test-Job' pipeline starts and Jenkins waits for it to finish -> Option B

4. Quick Check:

   'build' with wait=true means wait for downstream job [OK]

Hint: Wait true means wait for downstream job to finish [OK]

Common Mistakes:

• Assuming downstream runs in parallel without waiting
• Thinking pipeline stops early
• Believing 'build' is invalid step

4. You have this pipeline snippet:

build job: 'Deploy-App', propagate: false, wait: true

What issue might occur if 'Deploy-App' fails?

medium

A. Jenkins throws a syntax error

B. The current pipeline stops immediately on failure

C. The current pipeline continues despite failure in 'Deploy-App'

D. 'Deploy-App' runs twice

Solution

1. Step 1: Understand 'propagate: false'

   This setting means the failure of the downstream job does not fail the current pipeline.

2. Step 2: Analyze failure behavior

   If 'Deploy-App' fails, the current pipeline will continue running instead of stopping.

3. Final Answer:

   The current pipeline continues despite failure in 'Deploy-App' -> Option C

4. Quick Check:

   propagate false = ignore downstream failure [OK]

Hint: propagate false lets pipeline ignore downstream failures [OK]

Common Mistakes:

• Assuming pipeline stops on downstream failure
• Confusing propagate with wait
• Expecting syntax errors

5. You want to create a Jenkins pipeline where Job A triggers Job B only if Job A succeeds, and Job B triggers Job C regardless of its result. Which configuration correctly achieves this?

hard

A. In Job A pipeline: build job: 'Job-B', propagate: true, wait: trueIn Job B pipeline: build job: 'Job-C', propagate: false, wait: false

B. In Job A pipeline: build job: 'Job-B', propagate: false, wait: falseIn Job B pipeline: build job: 'Job-C', propagate: true, wait: true

C. In Job A pipeline: build job: 'Job-B', propagate: true, wait: falseIn Job B pipeline: build job: 'Job-C', propagate: true, wait: true

D. In Job A pipeline: build job: 'Job-B', propagate: false, wait: trueIn Job B pipeline: build job: 'Job-C', propagate: false, wait: true

Solution

1. Step 1: Ensure Job B triggers only on Job A success

   Using propagate: true in Job A means failure in Job B will fail Job A, so Job B runs only if Job A succeeds.

2. Step 2: Ensure Job C triggers regardless of Job B result

   Using propagate: false and wait: false in Job B triggers Job C without waiting and ignores Job C's result.

3. Final Answer:

   Option A matches these requirements -> Option A

4. Quick Check:

   propagate true for success-only triggers, false for unconditional [OK]

Hint: Use propagate true for success-only, false for unconditional triggers [OK]

Common Mistakes:

• Using propagate false when success-only is needed
• Confusing wait true/false effects
• Triggering downstream jobs incorrectly