Multi-stage builds concept in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of multi-stage builds in Docker

Why do we use multi-stage builds in Dockerfiles?

A To enable Dockerfiles to run on multiple operating systems automatically

B To run multiple containers simultaneously from one Dockerfile

C To reduce the final image size by copying only necessary artifacts from build stages

D To speed up container startup by preloading all dependencies in one stage

💡 Hint

Think about how multi-stage builds help with image size and efficiency.

Multi-stage builds let you separate build steps and copy only the needed files to the final image, making it smaller and cleaner.

💻 Command Output

intermediate

Output of multi-stage Docker build command

What will be the output of the following Docker build command if the Dockerfile has two stages named builder and final, and the final stage copies files from builder?

docker build -t myapp .

Docker

FROM node:18 AS builder
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine AS final
COPY --from=builder /app/build /usr/share/nginx/html

A Build completes successfully creating an image 'myapp' with only the nginx server and built files

B Build fails due to missing RUN command in the final stage

C Build completes but the image contains both node and nginx layers increasing size

D Build fails because the final stage cannot access files from the builder stage

💡 Hint

Consider how --from=builder works in multi-stage builds.

The final stage copies only the build output from the builder stage, so the final image contains only nginx and the built static files.

❓ Configuration

advanced

Correct multi-stage Dockerfile to build and run a Go app

Which Dockerfile correctly uses multi-stage builds to compile a Go app and produce a minimal final image?

A

FROM golang:1.20 AS builder
WORKDIR /app
COPY . .
RUN go build -o app

FROM alpine:latest
COPY --from=builder /app/app /app
CMD ["/app"]

B

FROM alpine:latest
WORKDIR /app
COPY . .
RUN go build -o app
CMD ["./app"]

C

FROM golang:1.20
WORKDIR /app
COPY . .
RUN go build -o app
CMD ["./app"]

D

FROM alpine:latest AS builder
WORKDIR /app
COPY . .
RUN go build -o app

FROM golang:1.20
COPY --from=builder /app/app /app
CMD ["/app"]

💡 Hint

Remember the builder stage needs Go tools, and the final image should be minimal.

Option A uses golang image to build, then copies the binary to a small alpine image for running, which is the correct multi-stage pattern.

❓ Troubleshoot

advanced

Why does the final image not contain expected files?

You wrote a multi-stage Dockerfile where the final stage copies files from the builder stage, but after building, the final image is missing those files. What is the most likely cause?

A Docker does not support copying files between stages

B The <code>--from=builder</code> path is incorrect or the files were not created in the builder stage

C The final stage must use the same base image as the builder stage to copy files

D The build command was missing the <code>--target</code> option to specify the final stage

💡 Hint

Check the paths and build steps in the builder stage.

If the files do not exist at the specified path in the builder stage, copying them will result in missing files in the final image.

🔀 Workflow

expert

Optimizing CI pipeline with multi-stage Docker builds

You want to optimize your CI pipeline to build Docker images faster using multi-stage builds. Which approach will best speed up builds while keeping images small?

A Use a single-stage build with all dependencies installed to avoid complexity

B Build all stages separately as independent images and then merge them manually

C Disable Docker layer caching to ensure fresh builds every time

D Use multi-stage builds with caching enabled for dependencies in the builder stage and copy only final artifacts to the last stage

💡 Hint

Think about caching and minimizing layers in multi-stage builds.

Using caching for dependencies in the builder stage avoids reinstalling them every build, and copying only needed files keeps the final image small and build fast.