Building Docker images in pipeline in Jenkins - Step-by-Step Execution

Process Flow - Building Docker images in pipeline

Start Pipeline

↓

Checkout Code

↓

Run Docker Build

↓

Tag Docker Image

↓

Push Image to Registry

↓

End Pipeline

The pipeline starts by getting the code, then builds the Docker image, tags it, pushes it to a registry, and finishes.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Build Docker Image') {
      steps {
        script {
          docker.build('myapp:latest')
        }
      }
    }
  }
}

This Jenkins pipeline builds a Docker image named 'myapp:latest' from the current directory.

Process Table

Step	Action	Command Run	Result	Next Step
1	Start Pipeline	N/A	Pipeline started	Checkout Code
2	Checkout Code	git checkout	Code downloaded	Run Docker Build
3	Run Docker Build	docker build -t myapp:latest .	Docker image 'myapp:latest' built	Tag Docker Image
4	Tag Docker Image	docker tag myapp:latest registry/myapp:latest	Image tagged for registry	Push Image to Registry
5	Push Image to Registry	docker push registry/myapp:latest	Image pushed to registry	End Pipeline
6	End Pipeline	N/A	Pipeline finished successfully	N/A

💡 Pipeline ends after pushing the Docker image to the registry.

Status Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
docker_image	none	myapp:latest (built)	registry/myapp:latest (tagged)	registry/myapp:latest (pushed)	registry/myapp:latest (available in registry)

Key Moments - 3 Insights

Why do we tag the Docker image after building it?

Tagging the image (see Step 4) prepares it with the correct name for the registry so it can be pushed and identified properly.

What happens if the docker build command fails?

If the build fails at Step 3, the pipeline stops and does not proceed to tagging or pushing, preventing broken images from being pushed.

Why do we need to checkout code before building the image?

The Docker build uses the code files as context, so checking out the code (Step 2) ensures the latest files are available for the image.

Visual Quiz - 3 Questions

Look at the execution table, what is the docker_image variable value after Step 4?

A myapp:latest (built)

B registry/myapp:latest (tagged)

C registry/myapp:latest (pushed)

D none

💡 Hint

Check variable_tracker column 'After Step 4' for docker_image value.

At which step does the pipeline push the Docker image to the registry?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look at the 'Action' and 'Command Run' columns in execution_table for pushing.

If the checkout code step is skipped, what will likely happen during the Docker build?

A Docker build will succeed with latest code

B Docker image will be pushed without building

C Docker build will fail or build old code

D Pipeline will skip to tagging

💡 Hint

Refer to key_moments about why checkout is needed before build.

Concept Snapshot

Jenkins pipeline builds Docker images by:
1. Checking out code
2. Running 'docker build' to create image
3. Tagging image for registry
4. Pushing image to registry
Each step must succeed to continue pipeline.

Full Transcript

This Jenkins pipeline example shows how to build a Docker image in a CI/CD process. It starts by checking out the source code from version control. Then it runs the docker build command to create an image named 'myapp:latest'. After building, it tags the image with the registry path to prepare for pushing. Finally, it pushes the tagged image to the Docker registry. The pipeline ends successfully after the push. Variables like the docker_image name change as the image is built, tagged, and pushed. If any step fails, the pipeline stops to avoid pushing incomplete images.

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