Building images in Compose in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of docker-compose build with context path

Given this docker-compose.yml snippet, what will be the output when running docker-compose build?

Docker

services:
  web:
    build:
      context: ./app
      dockerfile: Dockerfile.web
    image: mywebapp:latest

A Successfully built image 'mywebapp:latest' using Dockerfile.web from ./app directory

B Error: Cannot find Dockerfile in the root directory

C Build completed but image tagged as 'latest' without 'mywebapp' prefix

D Build fails due to missing context path

💡 Hint

The build context and dockerfile path determine where Docker looks for files.

The build context './app' tells Docker to use that directory. The dockerfile 'Dockerfile.web' is found there, so the image builds successfully and is tagged as 'mywebapp:latest'.

❓ Configuration

intermediate

Correct syntax for build args in Compose

Which docker-compose.yml snippet correctly passes build arguments to the Docker build process?

A

build:
  context: .
  args:
    APP_ENV: production
    DEBUG: 'false'

B

build:
  context: .
  build_args:
    APP_ENV: production
    DEBUG: 'false'

C

build:
  context: .
  args:
    - APP_ENV=production
    - DEBUG=false

D

build:
  context: .
  build-args:
    APP_ENV: production
    DEBUG: 'false'

💡 Hint

Check the official Compose syntax for build arguments.

The correct key is 'args' under 'build'. It accepts a map of argument names and values. Other keys like 'build_args' or 'build-args' are invalid.

❓ Troubleshoot

advanced

Diagnosing build failure due to missing Dockerfile

You run docker-compose build but get the error: "Cannot locate specified Dockerfile: Dockerfile.prod". Your docker-compose.yml contains:

services:
  api:
    build:
      context: ./backend
      dockerfile: Dockerfile.prod

What is the most likely cause?

A The dockerfile key must be an absolute path, not relative

B The context path ./backend is incorrect and should be ./api

C Dockerfile.prod does not exist inside the ./backend directory

D Docker Compose requires the Dockerfile to be named exactly 'Dockerfile'

💡 Hint

Check the location of the Dockerfile relative to the context.

The dockerfile path is relative to the build context. If Dockerfile.prod is missing inside ./backend, the build fails with this error.

🔀 Workflow

advanced

Order of steps in multi-stage build with Compose

In a multi-stage Docker build defined in a Dockerfile, which step happens first when running docker-compose build?

A Docker builds only the stages referenced by the final image

B Only the final stage is built, skipping earlier stages

C Docker builds all stages in parallel

D All stages are built sequentially from the first to the last stage

💡 Hint

Think about how Docker processes multi-stage builds.

Docker builds each stage in order because later stages can depend on earlier ones. The final image uses the last stage, but all stages are built sequentially.

✅ Best Practice

expert

Optimizing build cache usage in Compose builds

Which practice best helps Docker Compose reuse build cache effectively when building images?

A Use COPY commands with wildcards to include all files in one step

B Keep the build context minimal and avoid changing files unnecessarily

C Add a random build argument to force cache invalidation each time

D Always use the latest tag for base images to get fresh builds

💡 Hint

Think about what invalidates Docker cache during build.

Docker cache is invalidated if files in the build context change. Keeping context small and stable helps reuse cache. Using latest tags or random args forces rebuilds. COPY with wildcards can cause unnecessary cache misses.

Practice

1. What does the build key do in a Docker Compose file?

easy

A. It sets the network mode for the container.

B. It runs a container from an existing image.

C. It specifies environment variables for the container.

D. It tells Compose how to build a Docker image from a directory or Dockerfile.

Solution

1. Step 1: Understand the role of build in Compose

   The build key tells Docker Compose to create an image from source files, usually by specifying a directory with a Dockerfile.

2. Step 2: Compare with other keys

   Other keys like image specify existing images, and environment sets variables, so they do not build images.

3. Final Answer:

   It tells Compose how to build a Docker image from a directory or Dockerfile. -> Option D

4. Quick Check:

   build = build image [OK]

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

Common Mistakes:

• Confusing build with image key
• Thinking build runs containers
• Mixing build with environment variables

2. Which of the following is the correct syntax to specify a custom Dockerfile in a Compose service?

easy

A. build: ./app
dockerfile: Dockerfile.custom

B. build:
path: ./app
file: Dockerfile.custom

C. build:
context: ./app
dockerfile: Dockerfile.custom

D. build:
source: ./app
file: Dockerfile.custom

Solution

1. Step 1: Recall correct keys under build

   The correct keys are context for directory and dockerfile for custom Dockerfile name.

2. Step 2: Check each option

   build: context: ./app dockerfile: Dockerfile.custom uses context and dockerfile correctly. Others use invalid keys like path, file, or source.

3. Final Answer:

   build: context: ./app dockerfile: Dockerfile.custom -> Option C

4. Quick Check:

   Use context and dockerfile keys [OK]

Hint: Use 'context' and 'dockerfile' keys exactly [OK]

Common Mistakes:

• Using 'path' or 'file' instead of 'context' and 'dockerfile'
• Indentation errors under build
• Putting dockerfile outside build block

3. Given this Compose snippet:

services:
  web:
    build:
      context: ./webapp
    image: mywebapp:latest

What happens when you run docker compose up --build?

medium

A. It builds the image from ./webapp and tags it as mywebapp:latest, then starts the container.

B. It pulls the image mywebapp:latest from Docker Hub and runs it.

C. It builds the image but does not tag it as mywebapp:latest.

D. It starts the container without building or pulling any image.

Solution

1. Step 1: Understand build and image keys together

   The build key builds an image from the given context. The image key tags the built image with the given name.

2. Step 2: Effect of --build flag

   The --build flag forces Compose to build the image before starting containers.

3. Final Answer:

   It builds the image from ./webapp and tags it as mywebapp:latest, then starts the container. -> Option A

4. Quick Check:

   build + image = build and tag image [OK]

Hint: build + image tags image before running [OK]

Common Mistakes:

• Thinking image pulls from Docker Hub automatically
• Assuming build does not tag image
• Ignoring --build flag effect

4. You wrote this Compose service:

services:
  api:
    build: ./api
    dockerfile: Dockerfile.api

When running docker compose build, you get an error. What is wrong?

medium

A. You must specify context instead of build.

B. The dockerfile key must be inside the build block, not at the same level.

C. The build key cannot be a string; it must be a dictionary.

D. Docker Compose does not support custom Dockerfile names.

Solution

1. Step 1: Check Compose syntax for build and dockerfile

   The dockerfile key must be nested inside the build dictionary, not at the same level as build.

2. Step 2: Identify the error cause

   Here, build is a string, and dockerfile is separate, causing Compose to fail parsing.

3. Final Answer:

   The dockerfile key must be inside the build block, not at the same level. -> Option B

4. Quick Check:

   dockerfile inside build block [OK]

Hint: Put dockerfile under build, not beside it [OK]

Common Mistakes:

• Placing dockerfile outside build block
• Using build as string with dockerfile key separately
• Assuming dockerfile key is global

5. You want to build two services in Compose, frontend and backend, each with different Dockerfiles in the same directory ./app. How do you configure the build section for both services correctly?

hard

A. Use context: ./app for both, and specify different dockerfile names under each service's build.

B. Use different context paths for each service pointing to the same directory.

C. Use one service with build and the other with image only.

D. You cannot build two images from the same directory with different Dockerfiles.

Solution

1. Step 1: Understand build context and dockerfile usage

   You can use the same context directory but specify different dockerfile names to build different images from the same folder.

2. Step 2: Check options for multiple services

   Use context: ./app for both, and specify different dockerfile names under each service's build. correctly uses the same context with different Dockerfiles. Use different context paths for each service pointing to the same directory. is redundant, C limits building, and D is false.

3. Final Answer:

   Use context: ./app for both, and specify different dockerfile names under each service's build. -> Option A

4. Quick Check:

   Same context + different dockerfile names [OK]

Hint: Same folder, different dockerfile names per service [OK]

Common Mistakes:

• Trying to use different contexts for same folder
• Thinking multiple Dockerfiles in one folder is unsupported
• Not specifying dockerfile key for each service