Building images with docker build - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this Docker build command?

You run the command docker build -t myapp:latest . in a directory with a valid Dockerfile. What will be the result?

A Docker will build the image but tag it as 'latest' without the 'myapp' name.

B Docker builds the image and tags it as 'myapp:latest' if successful.

C Docker builds the image but does not tag it because the '-t' flag is ignored.

D Docker will throw an error because the tag format is incorrect.

💡 Hint

The '-t' flag is used to name and tag the image during build.

The command 'docker build -t myapp:latest .' builds the Docker image from the current directory and tags it with the name 'myapp' and tag 'latest'. This is the standard way to name images during build.

💻 Command Output

intermediate

What error does this Docker build command produce?

You run docker build -f Dockerfile.dev . but the file 'Dockerfile.dev' does not exist in the directory. What error will Docker show?

A Permission denied error accessing Dockerfile.dev

B Syntax error in Dockerfile.dev

C Build completes successfully using default Dockerfile

D Error response from daemon: Dockerfile not found: Dockerfile.dev

💡 Hint

The '-f' flag specifies a Dockerfile name. If missing, Docker uses 'Dockerfile'.

Docker looks for the file specified by '-f'. If it does not exist, it returns an error saying the Dockerfile was not found.

🔀 Workflow

advanced

Which option correctly builds a Docker image using a specific Dockerfile and no cache?

You want to build an image named 'webapp:1.0' using the Dockerfile named 'Dockerfile.prod' and ensure no cache is used during build. Which command is correct?

A docker build -t webapp:1.0 -f Dockerfile.prod --no-cache .

B docker build --no-cache -t webapp:1.0 Dockerfile.prod

C docker build -f Dockerfile.prod -t webapp:1.0 . --no-cache

D docker build -t webapp:1.0 . -f Dockerfile.prod --no-cache

💡 Hint

The order of flags matters; the context path must be last.

The correct syntax places the '-f' and '--no-cache' flags before the context path '.' and specifies the tag with '-t'. Option A follows this syntax exactly.

❓ Troubleshoot

advanced

Why does this Docker build command fail with a syntax error?

You run docker build -t myimage . -f Dockerfile and get a syntax error. What is the cause?

A Dockerfile name is case sensitive and 'Dockerfile' is incorrect

B The tag '-t' must be after the context path '.'

C The '-f' flag must come before the context path '.'

D The context path '.' must be omitted when using '-f'

💡 Hint

Flags must appear before the context path in the command.

Docker expects all flags before the context path. Placing '-f Dockerfile' after '.' causes Docker to treat it as a build context, leading to an error.

✅ Best Practice

expert

What is the best practice to reduce image size when building with Docker?

You want to build a small Docker image for production. Which practice below helps reduce the final image size?

A Use multi-stage builds to copy only necessary artifacts into the final image

B Use the 'latest' tag to always get the newest base image

C Install all build tools inside the final image for debugging

D Avoid specifying a base image to keep the image minimal

💡 Hint

Multi-stage builds separate build environment from runtime environment.

Multi-stage builds allow you to compile or build your app in one stage and copy only the needed files to a smaller final image, reducing size and attack surface.

Practice

1. What does the docker build command do?

easy

A. It creates a Docker image from a Dockerfile and context files.

B. It runs a Docker container from an image.

C. It deletes unused Docker images.

D. It lists all running Docker containers.

Solution

1. Step 1: Understand the purpose of docker build

   The docker build command reads instructions from a Dockerfile and packages files from the build context into a new image.

2. Step 2: Differentiate from other Docker commands

   Running containers, deleting images, or listing containers are done by other commands like docker run, docker rmi, and docker ps.

3. Final Answer:

   It creates a Docker image from a Dockerfile and context files. -> Option A

4. Quick Check:

   docker build = create image [OK]

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

Common Mistakes:

• Confusing build with run command
• Thinking build deletes images
• Mixing build with container listing

2. Which of the following is the correct syntax to build a Docker image named myapp from the current directory?

easy

A. docker build . -name myapp

B. docker build myapp -t .

C. docker build -t myapp .

D. docker build --image myapp .

Solution

1. Step 1: Identify the correct order and options for docker build

   The correct syntax uses -t to tag the image name, followed by the build context (here, current directory .).

2. Step 2: Check each option for syntax correctness

   docker build -t myapp . correctly places -t myapp before the context .. Options A, B, and D misuse flags or order.

3. Final Answer:

   docker build -t myapp . -> Option C

4. Quick Check:

   docker build -t name context [OK]

Hint: Use -t before context folder to name image [OK]

Common Mistakes:

• Placing image name after context
• Using wrong flags like --image or -name
• Omitting the build context folder

3. Given this Dockerfile in the current directory:

FROM alpine
RUN echo "Hello Docker" > /hello.txt

What will be the output of docker build -t testimage . if successful?

medium

A. An image named testimage is created with a file /hello.txt containing 'Hello Docker'.

B. A container runs and prints 'Hello Docker' to the terminal.

C. The build fails because echo is not a valid Docker command.

D. An image is created but /hello.txt is empty.

Solution

1. Step 1: Understand Dockerfile instructions

   FROM alpine sets base image; RUN echo "Hello Docker" > /hello.txt creates a file inside the image.

2. Step 2: Interpret the build command output

   The build creates an image named testimage with the file /hello.txt containing the text 'Hello Docker'. No container runs or prints output during build.

3. Final Answer:

   An image named testimage is created with a file /hello.txt containing 'Hello Docker'. -> Option A

4. Quick Check:

   RUN creates files in image, no output printed [OK]

Hint: RUN commands modify image, they don't print output during build [OK]

Common Mistakes:

• Thinking RUN prints to terminal during build
• Confusing image creation with container run
• Assuming build fails due to shell commands

4. You run docker build -t myapp . but get the error: failed to read dockerfile: open Dockerfile: no such file or directory. What is the most likely cause?

medium

A. The build context folder is empty.

B. The -t option is used incorrectly.

C. Docker daemon is not running.

D. The Dockerfile is missing from the current directory.

Solution

1. Step 1: Analyze the error message

   The error says Docker cannot find the Dockerfile in the build context folder (current directory).

2. Step 2: Identify the cause

   If the Dockerfile is missing, Docker cannot build the image. The -t option and daemon status do not cause this specific error.

3. Final Answer:

   The Dockerfile is missing from the current directory. -> Option D

4. Quick Check:

   Missing Dockerfile = build fails with file not found [OK]

Hint: Check Dockerfile exists in build folder if build fails [OK]

Common Mistakes:

• Assuming wrong flag causes error
• Not verifying Dockerfile presence
• Ignoring daemon status for this error

5. You want to build a Docker image named webapp:v1 using a Dockerfile located in ./app folder, but your current directory is the parent folder. Which command correctly builds the image?

hard

A. docker build -t webapp:v1 ./app

B. docker build -t webapp:v1 -f ./app/Dockerfile ./app

C. docker build ./app -t webapp:v1

D. docker build -f app/Dockerfile -t webapp:v1 ./app

Solution

1. Step 1: Understand build context and Dockerfile location

   The build context is the folder with the Dockerfile and files needed. Here, it's ./app.

2. Step 2: Choose correct command syntax

   docker build -t webapp:v1 -f ./app/Dockerfile ./app uses -t webapp:v1 to tag, -f ./app/Dockerfile to specify Dockerfile path, and ./app as context, which is correct. docker build -t webapp:v1 ./app assumes Dockerfile is in context folder but does not specify path explicitly. docker build ./app -t webapp:v1 has wrong order. docker build -f app/Dockerfile -t webapp:v1 ./app has incomplete Dockerfile path.

3. Final Answer:

   docker build -t webapp:v1 -f ./app/Dockerfile ./app -> Option B

4. Quick Check:

   Tag with -t, specify Dockerfile with -f, context last [OK]

Hint: Tag with -t, specify Dockerfile path with -f, context last [OK]

Common Mistakes:

• Wrong order of options and context
• Incorrect Dockerfile path with -f
• Using current folder when Dockerfile is elsewhere