Build, test, deploy stages concept in Jenkins - Commands & Configuration

Introduction

When creating software, you need to build the code, check it works, and then send it to users. Jenkins helps automate these steps in order: build, test, and deploy. This makes sure your software is reliable and ready to use.

When you want to automatically compile your code after every change to catch errors early

When you need to run tests to verify your software works before sharing it

When you want to send your software to a server or cloud automatically after tests pass

When you want to save time by automating repetitive steps in software delivery

When you want to keep your team updated with the latest working version of your app

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building the application...'
        sh 'echo Build step simulated'
      }
    }
    stage('Test') {
      steps {
        echo 'Running tests...'
        sh 'echo Test step simulated'
      }
    }
    stage('Deploy') {
      steps {
        echo 'Deploying the application...'
        sh 'echo Deploy step simulated'
      }
    }
  }
}

This Jenkinsfile defines a pipeline with three stages: Build, Test, and Deploy.

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

Each stage has steps that run shell commands simulating the real work. The echo commands show messages in the Jenkins console.

Commands

Check that Jenkins job CLI tool is installed and working before creating jobs.

Terminal

jenkins-jobs --version

Expected Output

jenkins-jobs 3.3.1

Create a Jenkinsfile with build, test, and deploy stages to define the pipeline steps.

Terminal

echo 'pipeline { agent any; stages { stage("Build") { steps { echo "Building the application..."; sh "echo Build step simulated" } } stage("Test") { steps { echo "Running tests..."; sh "echo Test step simulated" } } stage("Deploy") { steps { echo "Deploying the application..."; sh "echo Deploy step simulated" } } } }' > Jenkinsfile

Expected Output

No output (command runs silently)

Start the Jenkins pipeline job named 'my-pipeline' which runs the build, test, and deploy stages.

Terminal

jenkins-cli build my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] echo

Building the application...

[Pipeline] sh

+ echo Build step simulated

Build step simulated

[Pipeline] echo

Running tests...

[Pipeline] sh

+ echo Test step simulated

Test step simulated

[Pipeline] echo

Deploying the application...

[Pipeline] sh

+ echo Deploy step simulated

Deploy step simulated

[Pipeline] End of Pipeline

Finished: SUCCESS

View the console output of the last run of the 'my-pipeline' job to verify each stage ran correctly.

Terminal

jenkins-cli console my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] echo

Building the application...

[Pipeline] sh

+ echo Build step simulated

Build step simulated

[Pipeline] echo

Running tests...

[Pipeline] sh

+ echo Test step simulated

Test step simulated

[Pipeline] echo

Deploying the application...

[Pipeline] sh

+ echo Deploy step simulated

Deploy step simulated

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

If you remember nothing else from this pattern, remember: organizing your pipeline into build, test, and deploy stages helps catch problems early and deliver software reliably.

Common Mistakes

Skipping the test stage or not failing the pipeline when tests fail

This lets broken code reach users, causing errors and bad experience.

Always include tests and configure the pipeline to stop if tests fail.

Running deploy before tests finish or succeed

Deploying untested code risks introducing bugs to production.

Make deploy stage depend on successful completion of test stage.

Not using stages in Jenkinsfile and putting all steps in one block

Makes it hard to see progress and debug failures in the pipeline.

Use separate stages for build, test, and deploy for clarity and control.

Summary

Create a Jenkinsfile with separate build, test, and deploy stages to organize your pipeline.

Run the pipeline job to automate building, testing, and deploying your application.

Check the pipeline console output to verify each stage completed successfully.

Practice

1. What is the main purpose of splitting a Jenkins pipeline into build, test, and deploy stages?

easy

A. To organize the process into clear steps and catch errors early

B. To run all commands at the same time for speed

C. To skip testing and deploy directly

D. To only build the code without testing or deploying

Solution

1. Step 1: Understand the purpose of stages

   Stages separate the pipeline into logical parts: building, testing, and deploying.

2. Step 2: Recognize benefits of stages

   This separation helps find errors early and keeps the process organized.

3. Final Answer:

   To organize the process into clear steps and catch errors early -> Option A

4. Quick Check:

   Stages = clear steps + early error detection [OK]

Hint: Stages split work to catch errors early and stay organized [OK]

Common Mistakes:

• Thinking stages run in parallel by default
• Skipping test stage to save time
• Confusing build with deploy

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

easy

A. stage('build') { steps { sh 'make build' } }

B. build { stage('steps') { sh 'make build' } }

C. steps { stage('build') { sh 'make build' } }

D. pipeline { build { sh 'make build' } }

Solution

1. Step 1: Recall Jenkins declarative syntax

   A stage is defined as stage('name') { steps { ... } }.

2. Step 2: Match syntax with options

   stage('build') { steps { sh 'make build' } } correctly uses stage('build') { steps { sh 'make build' } }.

3. Final Answer:

   stage('build') { steps { sh 'make build' } } -> Option A

4. Quick Check:

   Stage syntax = stage('name') + steps block [OK]

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

Common Mistakes:

• Placing steps outside stage block
• Using build as a block instead of stage
• Missing steps keyword

3. Given this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('build') {
      steps {
        echo 'Building...'
      }
    }
    stage('test') {
      steps {
        error 'Test failed!'
      }
    }
    stage('deploy') {
      steps {
        echo 'Deploying...'
      }
    }
  }
}

What will be the output when this pipeline runs?

medium

A. Pipeline skips build and test, runs deploy only

B. All stages run successfully including deploy

C. Build stage runs, then test stage fails and stops pipeline; deploy does not run

D. Pipeline runs build and deploy but skips test

Solution

1. Step 1: Analyze build stage

   The build stage prints 'Building...' successfully.

2. Step 2: Analyze test stage

   The test stage runs error 'Test failed!' which stops the pipeline with failure.

3. Step 3: Analyze deploy stage

   Because test failed, deploy stage does not run.

4. Final Answer:

   Build stage runs, then test stage fails and stops pipeline; deploy does not run -> Option C

5. Quick Check:

   Failure in test stops pipeline before deploy [OK]

Hint: Error in test stage stops pipeline before deploy [OK]

Common Mistakes:

• Assuming deploy runs despite test failure
• Thinking error only logs message without stopping
• Ignoring pipeline stop on error

4. You wrote this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('build') {
      steps {
        sh 'make build'
      }
    }
    stage('test') {
      sh 'make test'
    }
    stage('deploy') {
      steps {
        sh 'make deploy'
      }
    }
  }
}

Why does this pipeline fail to run correctly?

medium

A. The build stage uses sh instead of bat

B. The test stage is missing the steps block

C. The deploy stage should be outside stages

D. The agent keyword is misplaced

Solution

1. Step 1: Check syntax of each stage

   Build and deploy stages have steps { ... } blocks, but test stage does not.

2. Step 2: Understand Jenkins syntax rules

   Each stage must have a steps block to run commands; missing it causes failure.

3. Final Answer:

   The test stage is missing the steps block -> Option B

4. Quick Check:

   Missing steps block in stage = syntax error [OK]

Hint: Every stage needs a steps block for commands [OK]

Common Mistakes:

• Forgetting steps block inside a stage
• Mixing shell commands syntax
• Misplacing agent keyword

5. You want to create a Jenkins pipeline that builds your app, runs tests, and deploys only if tests pass. Which pipeline structure below correctly implements this with proper stages and error handling?

hard

A. pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } }

B. pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } post { failure { echo 'Tests failed, skipping deploy' } } }

C. pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } post { always { echo 'Deploying regardless of test result' } } }

D. pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } post { success { echo 'Deployment complete' } } }

Solution

1. Step 1: Understand pipeline flow

   Build runs first, then test, then deploy only if test passes (pipeline success).

2. Step 2: Analyze post blocks

   pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } post { success { echo 'Deployment complete' } } } uses post { success { ... } } to confirm deployment success message, matching requirement.

3. Step 3: Check other options

   pipeline { agent any stages { stage('build') { steps { sh 'build.sh' } } stage('test') { steps { sh 'test.sh' } } stage('deploy') { steps { sh 'deploy.sh' } } } } lacks error handling; B prints message on failure but does not prevent deploy; C deploys always.

4. Final Answer:

   Option D correctly runs deploy only on success and confirms deployment -> Option D

5. Quick Check:

   Deploy runs only if tests pass = post success block [OK]

Hint: Use post success block to run deploy only if tests pass [OK]

Common Mistakes:

• Deploy running even if tests fail
• Missing post blocks for error handling
• Confusing post always with success