CI/CD pipeline mental model in Jenkins - Commands & Configuration

Introduction

A CI/CD pipeline automates the steps to build, test, and deliver software. It helps teams release code faster and with fewer errors by running tasks automatically when code changes.

When you want to automatically check if new code works before adding it to the main project

When you want to build your software and run tests every time a developer saves changes

When you want to deploy your app to a server automatically after tests pass

When you want to catch errors early by running checks on every code update

When you want to save time by automating repetitive tasks like building and testing

Config File - Jenkinsfile

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                // Add build commands here
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
                // Add test commands here
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying application...'
                // Add deploy commands here
            }
        }
    }
}

This Jenkinsfile defines a simple CI/CD pipeline with three stages: Build, Test, and Deploy.

agent any means the pipeline can run on any available Jenkins agent.

Each stage groups related steps: building the app, running tests, and deploying the app.

The steps section contains commands that Jenkins runs for each stage.

Commands

This command creates a new Jenkins job named 'my-pipeline' using the Jenkinsfile to define the pipeline steps.

Terminal

jenkins-cli create-job my-pipeline < Jenkinsfile

Expected Output

Job 'my-pipeline' created successfully.

This command starts the pipeline job to run the build, test, and deploy stages automatically.

Terminal

jenkins-cli build my-pipeline

Expected Output

Started build #1 for job 'my-pipeline'.

This command shows the output logs of the first build of the 'my-pipeline' job so you can see what happened during each stage.

Terminal

jenkins-cli console my-pipeline 1

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] echo

Building the application...

[Pipeline] echo

Running tests...

[Pipeline] echo

Deploying application...

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

If you remember nothing else from this pattern, remember: a CI/CD pipeline automates building, testing, and deploying your code to catch errors early and deliver faster.

Common Mistakes

Not defining stages clearly in the Jenkinsfile

Without clear stages, Jenkins cannot organize tasks properly, making the pipeline hard to understand and maintain.

Define each major step (build, test, deploy) as separate stages in the Jenkinsfile.

Running deployment before tests complete

This can cause broken or buggy code to be deployed, leading to failures in production.

Always run tests stage before deployment stage to ensure code quality.

Not checking pipeline logs after running

You miss important information about errors or warnings that happened during the pipeline run.

Always review the console output logs to verify each stage ran successfully.

Summary

Create a Jenkinsfile to define build, test, and deploy stages for your pipeline.

Use Jenkins CLI commands to create and start the pipeline job.

Check the pipeline logs to confirm each stage completed successfully.

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