Building Docker images in pipeline in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of Docker build command in Jenkins pipeline

What will be the output of the following Jenkins pipeline snippet when building a Docker image?

Jenkins

pipeline {
  agent any
  stages {
    stage('Build Docker Image') {
      steps {
        script {
          def image = docker.build('myapp:latest')
          echo "Image built: ${image.id}"
        }
      }
    }
  }
}

A Image built: <empty string>

B Image built: myapp:latest

C Error: docker.build is not a valid method

D Image built: sha256:<image_id_hash>

💡 Hint

The docker.build method returns an image object with an id property representing the image hash.

The docker.build method in Jenkins pipeline returns a Docker image object. The image.id contains the image's SHA256 hash, which is printed in the echo statement.

❓ Configuration

intermediate

Correct Jenkinsfile syntax for building and pushing Docker image

Which Jenkinsfile snippet correctly builds a Docker image and pushes it to Docker Hub?

A

pipeline {
  agent any
  stages {
    stage('Build and Push') {
      steps {
        script {
          def img = docker.build('myuser/myapp:latest')
          img.push('latest')
        }
      }
    }
  }
}

B

pipeline {
  agent any
  stages {
    stage('Build and Push') {
      steps {
        docker.build('myuser/myapp:latest')
        docker.push('myuser/myapp:latest')
      }
    }
  }
}

C

pipeline {
  agent any
  stages {
    stage('Build and Push') {
      steps {
        script {
          docker.withRegistry('https://registry.hub.docker.com', 'dockerhub-credentials') {
            def img = docker.build('myuser/myapp:latest')
            img.push()
          }
        }
      }
    }
  }
}

D

pipeline {
  agent any
  stages {
    stage('Build and Push') {
      steps {
        script {
          def img = docker.build('myuser/myapp')
          img.push()
        }
      }
    }
  }
}

💡 Hint

Pushing requires authentication and the use of docker.withRegistry block with credentials.

Option C correctly uses docker.withRegistry to authenticate with Docker Hub using stored credentials, then builds and pushes the image. Other options either miss authentication or have incorrect push syntax.

❓ Troubleshoot

advanced

Troubleshooting Docker build failure in Jenkins pipeline

A Jenkins pipeline fails with the error: 'Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?'. What is the most likely cause?

A The Jenkins agent does not have Docker installed or running.

B The Jenkinsfile has syntax errors in the pipeline script.

C The Dockerfile syntax is incorrect causing build failure.

D The Docker image name is invalid.

💡 Hint

The error message indicates a connection problem to the Docker daemon socket.

This error usually means the Jenkins agent machine does not have Docker installed or the Docker service is not running, so it cannot communicate with the Docker daemon.

🔀 Workflow

advanced

Order of steps to build and deploy Docker image in Jenkins pipeline

What is the correct order of steps in a Jenkins pipeline to build a Docker image and deploy it to a Kubernetes cluster?

A 4,1,2,3

B 4,2,1,3

C 1,4,2,3

D 1,2,4,3

💡 Hint

Authentication must happen before build and push steps.

First authenticate to Docker registry and Kubernetes cluster, then build the image, push it, and finally update the Kubernetes deployment to use the new image.

✅ Best Practice

expert

Best practice for caching Docker layers in Jenkins pipeline builds

Which approach is best to speed up Docker image builds in Jenkins pipelines by caching layers effectively?

A Always use the --no-cache option to ensure fresh builds

B Use a remote Docker registry as a cache source and pull existing layers before building

C Delete all images on the Jenkins agent before each build to avoid conflicts

D Build images without tagging to avoid cache pollution

💡 Hint

Caching layers reduces build time by reusing unchanged parts of the image.

Using a remote registry as a cache source allows Docker to reuse existing layers, speeding up builds. Options B, C, and D reduce caching benefits or cause inefficiencies.