Docker Pipeline plugin in Jenkins - Step-by-Step Execution

Process Flow - Docker Pipeline plugin

Start Jenkins Pipeline

↓

Define Docker Image

↓

Pull or Build Image

↓

Run Container with Commands

↓

Capture Output / Status

↓

Use Container for Build/Test

↓

Stop and Remove Container

↓

End Pipeline

This flow shows how Jenkins uses the Docker Pipeline plugin to define, run, and manage Docker containers during a pipeline build.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Run Docker') {
      steps {
        script {
          docker.image('alpine').inside {
            sh 'echo Hello from Docker'
          }
        }
      }
    }
  }
}

This Jenkins pipeline runs a simple command inside an Alpine Docker container using the Docker Pipeline plugin.

Process Table

Step	Action	Evaluation	Result
1	Start pipeline	N/A	Pipeline started on any agent
2	Define Docker image 'alpine'	docker.image('alpine')	Docker image object created
3	Run container with .inside block	docker.image('alpine').inside { ... }	Container started, shell inside container
4	Execute shell command	sh 'echo Hello from Docker'	Output: Hello from Docker
5	Exit container block	Container stops and cleans up	Container stopped and removed
6	Pipeline stage complete	Stage 'Run Docker' finished	Success
7	Pipeline ends	All stages complete	Pipeline success

💡 Pipeline ends after all stages complete successfully

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
dockerImage	undefined	alpine image object	container running	container stopped	container removed

Key Moments - 3 Insights

Why does the container stop after the .inside block ends?

The .inside method runs commands inside a temporary container. When the block finishes, Jenkins automatically stops and removes the container to keep the environment clean, as shown in execution_table step 5.

What happens if the Docker image 'alpine' is not present locally?

Jenkins will pull the 'alpine' image from Docker Hub before running the container, as implied in step 3 where the container starts successfully.

Can we run multiple commands inside the .inside block?

Yes, you can run multiple shell commands inside the .inside block. Each command runs inside the same container session until the block ends.

Visual Quiz - 3 Questions

Look at the execution table, what is the output of the shell command at step 4?

A Hello from Docker

B Container started

C Pipeline success

D Docker image created

💡 Hint

Check the 'Result' column in row for step 4 in the execution_table.

At which step does the container stop and get removed?

A Step 3

B Step 5

C Step 6

D Step 7

💡 Hint

Look for the step describing container stop and cleanup in the execution_table.

If the Docker image 'alpine' was missing locally, what would change in the execution flow?

A Container would run without image

B Pipeline would fail immediately

C Jenkins would pull the image before running container

D Pipeline would skip the Docker stage

💡 Hint

Refer to key_moments explanation about image presence and pulling.

Concept Snapshot

Docker Pipeline plugin lets Jenkins run commands inside Docker containers.
Use docker.image('name').inside { ... } to run commands inside a container.
Jenkins pulls the image if missing, starts container, runs commands, then stops and removes container.
This keeps builds clean and isolated.
Use inside block for temporary container sessions.

Full Transcript

This visual execution trace shows how Jenkins uses the Docker Pipeline plugin to run commands inside Docker containers during a pipeline. The pipeline starts, defines a Docker image 'alpine', and runs a container with the .inside method. Inside the container, it executes a shell command that prints 'Hello from Docker'. After the commands finish, Jenkins stops and removes the container automatically. The pipeline then completes successfully. Variables like the dockerImage track the container state from creation to removal. Key moments clarify why containers stop after the block and how Jenkins pulls images if missing. The visual quiz tests understanding of output, container lifecycle, and image pulling behavior. The snapshot summarizes the plugin usage for quick reference.

Practice

1. What is the primary purpose of the docker.build() method in Jenkins Docker Pipeline plugin?

easy

A. To remove unused Docker images

B. To run a Docker container interactively

C. To build a Docker image from a Dockerfile

D. To push a Docker image to a registry

Solution

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

   This method is used to create a Docker image from a Dockerfile in the workspace.

2. Step 2: Differentiate from other Docker Pipeline methods

   Running containers uses docker.image().inside { }, pushing uses docker.withRegistry(), and removing images is not handled by docker.build().

3. Final Answer:

   To build a Docker image from a Dockerfile -> Option C

4. Quick Check:

   docker.build() builds images [OK]

Hint: Remember: build = create image from Dockerfile [OK]

Common Mistakes:

• Confusing build with push or run commands
• Thinking docker.build() runs containers
• Assuming it handles image removal

2. Which of the following is the correct syntax to run commands inside a Docker container in a Jenkins pipeline?

easy

A. docker.image('myimage').inside { sh 'echo Hello' }

B. docker.build('myimage') { sh 'echo Hello' }

C. docker.run('myimage') { sh 'echo Hello' }

D. docker.container('myimage').exec { sh 'echo Hello' }

Solution

1. Step 1: Identify the correct method to run commands inside a container

   The docker.image('myimage').inside { } syntax runs commands inside a container created from the image.

2. Step 2: Check other options for syntax errors or misuse

   docker.run() and docker.container() are not valid Jenkins Pipeline methods; docker.build() builds images but does not run containers.

3. Final Answer:

   docker.image('myimage').inside { sh 'echo Hello' } -> Option A

4. Quick Check:

   Use docker.image().inside { } to run commands [OK]

Hint: Use docker.image().inside { } to run commands inside containers [OK]

Common Mistakes:

• Using docker.build() to run commands
• Trying to use non-existent methods like docker.run()
• Confusing image build and container run syntax

3. Given the following Jenkins pipeline snippet, what will be the output of the sh command inside the container?

def img = docker.build('myapp:latest')
img.inside {
  sh 'echo Hello from Docker'
}

medium

A. Error: No such image 'myapp:latest'

B. Hello from Docker

C. Build logs of the Docker image

D. Nothing, the command is not executed

Solution

1. Step 1: Understand the build and run sequence

   The docker.build('myapp:latest') creates the image, then img.inside { } runs commands inside a container from that image.

2. Step 2: Analyze the sh command inside the container

   The shell command echo Hello from Docker runs inside the container and outputs the string.

3. Final Answer:

   Hello from Docker -> Option B

4. Quick Check:

   Commands inside img.inside { } run and output normally [OK]

Hint: Commands inside img.inside { } run inside container [OK]

Common Mistakes:

• Assuming build only creates logs, not image
• Thinking the command runs outside the container
• Expecting an error if image was just built

4. Identify the error in this Jenkins pipeline snippet using Docker Pipeline plugin:

docker.withRegistry('https://myregistry.com', 'my-credentials') {
  def img = docker.build('myapp')
  img.push()
}
img.inside {
  sh 'echo Running inside container'
}

medium

A. The img.push() should be called before docker.withRegistry

B. The docker.build method is missing the Dockerfile path

C. The credentials ID 'my-credentials' is invalid syntax

D. The img.inside block is outside the docker.withRegistry block and will fail

Solution

1. Step 1: Check scope of img variable

   The variable img is defined inside the docker.withRegistry block, so it is not accessible outside that block.

2. Step 2: Identify the error with img.inside usage

   Using img.inside outside the block where img is defined causes a runtime error because img is undefined there.

3. Final Answer:

   The img.inside block is outside the docker.withRegistry block and will fail -> Option D

4. Quick Check:

   Variable scope matters in Jenkins pipeline blocks [OK]

Hint: Keep variable usage inside the block where it's defined [OK]

Common Mistakes:

• Assuming variables are global across blocks
• Confusing credentials ID syntax
• Thinking push must be outside withRegistry

5. You want to build a Docker image, run tests inside a container from that image, and then push the image to a private registry using Jenkins Docker Pipeline plugin. Which pipeline snippet correctly implements this workflow?

hard

A. def img = docker.build('myapp:test')
img.inside {
sh 'run-tests.sh'
}
docker.withRegistry('https://registry.example.com', 'creds') {
img.push()
}

B. docker.withRegistry('https://registry.example.com', 'creds') {
def img = docker.build('myapp:test')
img.push()
img.inside {
sh 'run-tests.sh'
}
}

C. docker.withRegistry('https://registry.example.com', 'creds') {
img.push()
def img = docker.build('myapp:test')
img.inside {
sh 'run-tests.sh'
}
}

D. def img = docker.build('myapp:test')
docker.withRegistry('https://registry.example.com', 'creds') {
img.push()
}
img.inside {
sh 'run-tests.sh'
}

Solution

1. Step 1: Build image and run tests inside container first

   The image must be built before running tests inside it, so docker.build() and img.inside { } come first.

2. Step 2: Push image inside docker.withRegistry() block after tests

   Pushing requires registry credentials, so img.push() must be inside docker.withRegistry() block after tests pass.

3. Step 3: Verify variable scope and order

   def img = docker.build('myapp:test') img.inside { sh 'run-tests.sh' } docker.withRegistry('https://registry.example.com', 'creds') { img.push() } correctly builds image, runs tests inside container, then pushes image with credentials in proper order and scope.

4. Final Answer:

   def img = docker.build('myapp:test') img.inside { sh 'run-tests.sh' } docker.withRegistry('https://registry.example.com', 'creds') { img.push() } -> Option A

5. Quick Check:

   Build -> Test inside container -> Push with credentials [OK]

Hint: Build first, test inside container, then push inside withRegistry [OK]

Common Mistakes:

• Pushing image before running tests
• Using img.inside after pushing outside scope
• Defining variables inside wrong blocks