Docker Pipeline plugin in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of Docker Pipeline build step

What is the output of the following Jenkins Pipeline snippet using the Docker Pipeline plugin?

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          def img = docker.build('my-image:latest')
          echo img.id
        }
      }
    }
  }
}

A The image ID string of the built Docker image, e.g., sha256:abc123...

B The literal string 'my-image:latest'

C An error: 'docker.build' is not a valid method

D The container ID of a running container

💡 Hint

The docker.build() method returns an image object with an id property.

The docker.build('my-image:latest') command builds the Docker image and returns an image object. The img.id property contains the image's unique ID string.

🧠 Conceptual

intermediate

Understanding Docker Pipeline plugin's 'inside' method

In Jenkins Docker Pipeline plugin, what does the 'inside' method do when called on a Docker image object?

A Pushes the Docker image to a remote registry.

B Builds a new Docker image from the current workspace.

C Runs the given block of pipeline steps inside a container created from the image.

D Removes the Docker image from the local Docker host.

💡 Hint

Think about running commands inside a container environment.

The 'inside' method runs the enclosed pipeline steps inside a container started from the specified Docker image, providing an isolated environment.

🔀 Workflow

advanced

Correct order of Docker Pipeline plugin steps to build, test, and push

Arrange the following Docker Pipeline plugin steps in the correct order to build an image, run tests inside it, and then push it to a registry.

A 1,4,2,3

B 1,2,4,3

C 4,2,1,3

D 4,1,2,3

💡 Hint

You must define the image variable before using it.

First, define the image variable by assigning the result of docker.build. Then build the image, run tests inside it, and finally push it.

❓ Troubleshoot

advanced

Diagnosing Docker Pipeline plugin authentication failure

You get an error 'unauthorized: authentication required' when running 'image.push()' in Jenkins Docker Pipeline plugin. What is the most likely cause?

A The Dockerfile has syntax errors.

B Docker registry credentials are not configured or not passed to the pipeline.

C The Jenkins agent does not have Docker installed.

D The Docker image was not built before pushing.

💡 Hint

Pushing requires authentication to the registry.

The 'unauthorized' error means the pipeline lacks proper credentials to push to the Docker registry.

✅ Best Practice

expert

Best practice for cleaning up Docker images in Jenkins pipeline

Which approach is best to avoid disk space issues caused by leftover Docker images when using the Docker Pipeline plugin in Jenkins?

A Use 'docker.image(...).remove()' after pushing the image to clean up local images.

B Manually delete images on the Jenkins agent outside the pipeline.

C Do not build images in the pipeline; use pre-built images only.

D Restart the Jenkins server daily to clear Docker cache.

💡 Hint

Cleaning up images programmatically after use is efficient.

Calling 'remove()' on the image object after pushing deletes the local image and frees disk space automatically.

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