Building Docker images in pipeline in Jenkins - Commands & Configuration

Introduction

Building Docker images in a pipeline automates creating container images from your app code. This helps package your app with all its parts so it runs the same everywhere.

When you want to automatically create a Docker image every time you update your app code.

When you need to test your app inside a container before sending it to production.

When you want to store your app image in a registry for easy sharing and deployment.

When you want to speed up your development by automating image builds.

When you want to ensure consistency by building images in a controlled environment.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  stages {
    stage('Build Docker Image') {
      steps {
        script {
          docker.build('my-app-image:1.0')
        }
      }
    }
  }
}

This Jenkinsfile defines a pipeline with one stage called 'Build Docker Image'.

The docker.build command builds a Docker image named my-app-image with tag 1.0 from the Dockerfile in the current directory.

The agent any means Jenkins can run this pipeline on any available agent.

Commands

Check that Jenkins CLI or Jenkins environment is ready before running the pipeline.

Terminal

jenkins-jobs --version

Expected Output

jenkins-jobs 3.3.1

Manually build the Docker image locally to verify the Dockerfile works before automating in Jenkins.

Terminal

docker build -t my-app-image:1.0 .

Expected Output

Sending build context to Docker daemon  8.192kB

Step 1/5 : FROM python:3.9-slim

 ---> 123abc456def

Step 2/5 : COPY . /app

 ---> Using cache

Step 3/5 : WORKDIR /app

 ---> Using cache

Step 4/5 : RUN pip install -r requirements.txt

 ---> Using cache

Step 5/5 : CMD ["python", "app.py"]

 ---> Using cache

Successfully built abcdef123456

Successfully tagged my-app-image:1.0

→

-t - Assigns a name and tag to the image

Trigger the Jenkins pipeline named 'my-pipeline' that contains the Docker build step.

Terminal

jenkins build my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Build Docker Image)

[Pipeline] script

[Pipeline] {

[Pipeline] docker.build

[Pipeline] }

[Pipeline] }

[Pipeline] End of Pipeline

Finished: SUCCESS

Verify that the Docker image was successfully built and is available locally after the pipeline runs.

Terminal

docker images | grep my-app-image

Expected Output

my-app-image   1.0   abcdef123456   2 minutes ago   120MB

Key Concept

If you remember nothing else from this pattern, remember: automating Docker image builds in Jenkins pipelines ensures consistent, repeatable packaging of your app.

Common Mistakes

Not having a Dockerfile in the project directory before running the build.

Docker build fails because it needs instructions from the Dockerfile to create the image.

Always include a valid Dockerfile in the root or specified directory before building.

Using 'docker.build' without the correct image name and tag format.

Jenkins will fail to tag the image properly, causing confusion or overwriting images.

Use a clear image name and tag like 'my-app-image:1.0' in the docker.build command.

Running the Jenkins pipeline on an agent without Docker installed.

The build step will fail because Docker commands cannot run without Docker engine.

Ensure the Jenkins agent has Docker installed and configured before running the pipeline.

Summary

Write a Jenkinsfile with a stage that uses docker.build to create your Docker image.

Test your Dockerfile locally with 'docker build' to catch errors early.

Run the Jenkins pipeline to automate image building on code changes.

Verify the image exists locally after the pipeline completes.

Practice

1. What is the main purpose of using docker.build() in a Jenkins pipeline?

easy

A. To run tests inside a Docker container

B. To deploy a Docker container to a cloud service

C. To remove unused Docker images from the system

D. To create a Docker image from a Dockerfile during the pipeline execution

Solution

1. Step 1: Understand the role of docker.build()

   This command is used to build Docker images from a Dockerfile within a Jenkins pipeline.

2. Step 2: Differentiate from other Docker commands

   It does not deploy containers, remove images, or run tests directly; it only builds images.

3. Final Answer:

   To create a Docker image from a Dockerfile during the pipeline execution -> Option D

4. Quick Check:

   docker.build() builds images [OK]

Hint: Remember: docker.build() creates images, not containers [OK]

Common Mistakes:

• Confusing image build with container deployment
• Thinking docker.build() removes images
• Assuming docker.build() runs tests

2. Which of the following is the correct syntax to build a Docker image named myapp inside a Jenkins pipeline script block?

easy

A. docker.build image: 'myapp'

B. docker.build('image=myapp')

C. docker.build('myapp')

D. docker.build('build myapp')

Solution

1. Step 1: Recall the correct method signature

   The docker.build() method takes the image name as a string argument, e.g., docker.build('myapp').

2. Step 2: Identify incorrect syntax

   Options A, C, and D use invalid syntax or incorrect parameter formats.

3. Final Answer:

   docker.build('myapp') -> Option C

4. Quick Check:

   Correct syntax is docker.build('imageName') [OK]

Hint: Use docker.build('imageName') inside script block [OK]

Common Mistakes:

• Using key-value syntax incorrectly
• Adding extra words inside the string
• Missing quotes around image name

3. Given this Jenkins pipeline snippet inside a script block:

def image = docker.build('myapp:latest')
image.push()

What will happen when this pipeline runs?

medium

A. Builds the Docker image 'myapp:latest' and pushes it to the default Docker registry

B. Builds the Docker image but does not push it anywhere

C. Pushes an existing image 'myapp:latest' without building it

D. Fails because image.push() is not a valid method

Solution

1. Step 1: Understand docker.build() and image.push()

   The docker.build() command builds the image and returns an object representing it. Calling image.push() pushes the built image to the Docker registry.

2. Step 2: Confirm the sequence of actions

   The code builds 'myapp:latest' and then pushes it to the default Docker registry configured in Jenkins.

3. Final Answer:

   Builds the Docker image 'myapp:latest' and pushes it to the default Docker registry -> Option A

4. Quick Check:

   docker.build() + image.push() builds and pushes [OK]

Hint: docker.build() returns image object; call push() to upload [OK]

Common Mistakes:

• Assuming push happens automatically without calling push()
• Thinking push() is invalid method
• Confusing build and push steps

4. You wrote this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        docker.build('myapp')
      }
    }
  }
}

But the build fails with error: docker.build is not recognized. What is the most likely cause?

medium

A. The docker variable is not available outside a script block

B. The Dockerfile is missing in the workspace

C. The Jenkins agent does not have Docker installed

D. The image name 'myapp' is invalid

Solution

1. Step 1: Check usage of docker.build()

   In declarative pipelines, docker.build() must be called inside a script block to access the Docker DSL.

2. Step 2: Identify the error cause

   Calling docker.build() directly in steps without script causes the method to be unrecognized.

3. Final Answer:

   The docker variable is not available outside a script block -> Option A

4. Quick Check:

   Use script block for docker.build() [OK]

Hint: Always wrap docker.build() inside script block [OK]

Common Mistakes:

• Ignoring need for script block
• Assuming missing Dockerfile causes this error
• Blaming Docker installation without checking syntax

5. You want to build a Docker image in Jenkins pipeline and tag it with the current Git commit hash. Which snippet correctly achieves this inside a script block?

hard

A. def commit = sh('git rev-parse --short HEAD')
def image = docker.build('myapp:commit')

B. def commit = sh(script: 'git rev-parse --short HEAD', returnStdout: true).trim()
def image = docker.build("myapp:${commit}")

C. def commit = git rev-parse --short HEAD
def image = docker.build('myapp:${commit}')

D. def commit = sh(script: 'git rev-parse --short HEAD')
def image = docker.build('myapp:commit')

Solution

1. Step 1: Correctly capture Git commit hash in Jenkins

   Use sh with returnStdout: true and trim() to get the commit hash as a string.

2. Step 2: Use the commit variable in docker.build()

   Use double quotes and string interpolation to tag the image with the commit hash.

3. Final Answer:

   def commit = sh(script: 'git rev-parse --short HEAD', returnStdout: true).trim() def image = docker.build("myapp:${commit}") -> Option B

4. Quick Check:

   Use sh with returnStdout and string interpolation [OK]

Hint: Use sh(..., returnStdout:true).trim() and "myapp:${commit}" [OK]

Common Mistakes:

• Not using returnStdout to capture command output
• Using single quotes preventing variable interpolation
• Assigning shell command output incorrectly