CI/CD pipeline mental model in Jenkins - Mini Project: Build & Apply

CI/CD Pipeline Mental Model with Jenkins

📖 Scenario: You are working as a DevOps engineer. Your team wants to automate the process of building, testing, and deploying a simple application using Jenkins. This will save time and reduce errors by running these steps automatically whenever code changes.

🎯 Goal: Build a simple Jenkins pipeline script that models the CI/CD process with stages for build, test, and deploy. You will create the pipeline steps one by one and finally print the pipeline structure.

📋 What You'll Learn

Create a Jenkins pipeline script with three stages: Build, Test, Deploy

Define a variable for the application name

Use the variable in the pipeline stages

Print the pipeline stages and application name at the end

💡 Why This Matters

🌍 Real World

Automating software build, test, and deployment saves time and reduces human errors in real projects.

💼 Career

Understanding Jenkins pipelines is essential for DevOps roles to implement continuous integration and continuous delivery.

1

Define the application name variable

Create a variable called appName and set it to the string "MyApp".

Jenkins

# Create a variable called appName and set it to "MyApp"
# Your code here

Hint

Use def appName = "MyApp" to create the variable.

2

Create the Jenkins pipeline with stages

Add a pipeline block with an agent any and a stages section containing three stages named Build, Test, and Deploy.

Jenkins

def appName = "MyApp"
// Add a pipeline block with agent any and stages Build, Test, Deploy
# Your code here

Hint

Use pipeline { agent any stages { stage('Build') { steps { ... } } } structure.

3

Use the appName variable inside each stage

Inside each stage's steps, add an echo statement that prints the action and uses the appName variable with ${appName} syntax. For example, in the Build stage, print "Building ${appName}...".

Jenkins

def appName = "MyApp"
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Add echo statement using ${appName}
                # Your code here
            }
        }
        stage('Test') {
            steps {
                // Add echo statement using ${appName}
                # Your code here
            }
        }
        stage('Deploy') {
            steps {
                // Add echo statement using ${appName}
                # Your code here
            }
        }
    }
}

Hint

Use echo "Building ${appName}..." inside the Build stage steps, and similarly for Test and Deploy.

4

Print the pipeline stages and application name

Add a post section with a always block that prints "Pipeline completed for ${appName}" using echo.

Jenkins

def appName = "MyApp"
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo "Building ${appName}..."
            }
        }
        stage('Test') {
            steps {
                echo "Testing ${appName}..."
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying ${appName}..."
            }
        }
    }
    // Add a post always block to print completion message
    # Your code here
}

Hint

Use post { always { echo "Pipeline completed for ${appName}" } } after the stages block.

Practice

1. What is the main purpose of a CI/CD pipeline in Jenkins?

easy

A. To manually run tests on software

B. To store software documentation

C. To write code faster

D. To automate building, testing, and deploying software

Solution

1. Step 1: Understand CI/CD pipeline role

   A CI/CD pipeline automates the process of building, testing, and deploying software to make delivery faster and more reliable.

2. Step 2: Identify Jenkins pipeline function

   Jenkins pipelines organize these automation steps into stages for clarity and control.

3. Final Answer:

   To automate building, testing, and deploying software -> Option D

4. Quick Check:

   CI/CD pipeline purpose = Automate build, test, deploy [OK]

Hint: CI/CD means automate build, test, deploy steps [OK]

Common Mistakes:

• Thinking CI/CD is for manual testing only
• Confusing pipeline with code writing
• Assuming pipeline stores documentation

2. Which of the following is the correct syntax to define a stage in a Jenkins declarative pipeline?

easy

A. stage: Build { steps: { echo 'Building...' } }

B. stage('Build') { steps { echo 'Building...' } }

C. stage = 'Build' { steps { echo 'Building...' } }

D. stage('Build') => { steps { echo 'Building...' } }

Solution

1. Step 1: Recall Jenkins declarative pipeline syntax

   In Jenkins declarative pipelines, stages are defined using stage('Name') { ... } syntax.

2. Step 2: Check each option's syntax

   stage('Build') { steps { echo 'Building...' } } uses correct syntax with parentheses and braces. Options B, C, and D use invalid symbols or assignment.

3. Final Answer:

   stage('Build') { steps { echo 'Building...' } } -> Option B

4. Quick Check:

   Correct stage syntax uses parentheses and braces [OK]

Hint: Stages use stage('name') { steps { ... } } syntax [OK]

Common Mistakes:

• Using colons instead of parentheses
• Assigning stage with = instead of defining block
• Using arrow => instead of braces

3. Given this Jenkins pipeline snippet, what will be the output?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        echo 'Starting tests'
        echo 'Tests passed'
      }
    }
  }
}

medium

A. Starting tests only

B. Tests passed\nStarting tests

C. Starting tests\nTests passed

D. No output, pipeline fails

Solution

1. Step 1: Analyze the pipeline steps

   The 'Test' stage has two echo commands executed in order: first 'Starting tests', then 'Tests passed'.

2. Step 2: Determine output order

   Jenkins runs steps sequentially, so output will be 'Starting tests' followed by 'Tests passed'.

3. Final Answer:

   Starting tests\nTests passed -> Option C

4. Quick Check:

   Echo commands run in order = Starting tests then Tests passed [OK]

Hint: Steps run top to bottom inside stage [OK]

Common Mistakes:

• Assuming output order is reversed
• Thinking only first echo runs
• Believing pipeline fails without error

4. Identify the error in this Jenkins pipeline snippet:

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

medium

A. Missing braces { } after stage('Build') declaration

B. Incorrect agent declaration

C. Missing echo command inside steps

D. Pipeline missing post section

Solution

1. Step 1: Check stage syntax

   The stage block must have braces { } after the stage name to enclose steps.

2. Step 2: Identify missing braces

   Here, stage('Build') is not followed by { }, causing a syntax error.

3. Final Answer:

   Missing braces { } after stage('Build') declaration -> Option A

4. Quick Check:

   Stage requires braces after name [OK]

Hint: Stage must have braces { } after name [OK]

Common Mistakes:

• Ignoring missing braces error
• Thinking agent declaration is wrong
• Assuming post section is mandatory

5. You want to create a Jenkins pipeline that builds your app only if tests pass. Which pipeline structure correctly models this CI/CD mental flow?

hard

A. stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } }

B. stages { stage('Build') { steps { echo 'Building...' } } stage('Test') { steps { echo 'Testing...' } } }

C. stages { stage('Build') { steps { echo 'Building...' } } post { always { echo 'Tests passed' } } }

D. stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } post { failure { error 'Tests failed' } } }

Solution

1. Step 1: Understand the requirement

   The app should build only if tests pass, requiring Test stage before Build stage to model the CI/CD flow where build follows successful tests.

2. Step 2: Analyze pipeline options

   stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } } places testing before building, correctly modeling the flow.

3. Step 3: Confirm other options

   stages { stage('Build') { steps { echo 'Building...' } } stage('Test') { steps { echo 'Testing...' } } } builds before tests (wrong order). stages { stage('Build') { steps { echo 'Building...' } } post { always { echo 'Tests passed' } } } wrong order and invalid post inside stages (syntax error). stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } post { failure { error 'Tests failed' } } } invalid post inside stages (syntax error).

4. Final Answer:

   stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } } -> Option A

5. Quick Check:

   Test stage before Build = correct CI/CD order [OK]

Hint: Test stage before build stage [OK]

Common Mistakes:

• Building before testing
• Placing post inside stages (syntax error)
• Wrong order with post always