Why multi-stage builds reduce image size in Docker - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do multi-stage builds reduce Docker image size?

Which explanation best describes why multi-stage builds help reduce the final Docker image size?

A They merge all layers into a single layer to reduce overhead.

B They allow copying only the necessary artifacts from build stages, excluding build tools and temporary files.

C They remove all unused files from the base image before starting the build.

D They compress the image layers automatically during the build process.

💡 Hint

Think about how build tools and temporary files affect image size and what multi-stage builds let you do with them.

Multi-stage builds let you use multiple FROM statements. You can build your app in one stage with all tools, then copy only the final app files to a smaller base image. This excludes build tools and temporary files, reducing image size.

💻 Command Output

intermediate

Output size difference with multi-stage build

Given the following Dockerfile snippet, what will be the approximate size difference between the final image using multi-stage build versus a single-stage build?

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

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

A The final image is empty because no files are copied.

B The final image is larger because it includes both Go compiler and Alpine base.

C The final image size is the same as the builder stage.

D The final image is much smaller because it excludes the Go compiler and source files.

💡 Hint

Consider what files and tools are present in each stage and what is copied to the final image.

The builder stage includes the Go compiler and source code, which are large. The final stage copies only the compiled binary to a small Alpine base image, making the final image much smaller.

❓ Configuration

advanced

Identify the correct multi-stage Dockerfile snippet

Which Dockerfile snippet correctly uses multi-stage builds to reduce image size by building a Node.js app and copying only the production files?

A

FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
CMD ["node", "dist/index.js"]

B

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

FROM node:18-slim
WORKDIR /app
COPY --from=build /app ./
CMD ["node", "dist/index.js"]

C

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

FROM node:18-slim
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

D

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

FROM node:18-slim
WORKDIR /app
COPY --from=build /app/package.json ./
CMD ["node", "dist/index.js"]

💡 Hint

Look for copying only the build output and production dependencies, not the entire source.

Option C copies only the build output folder and node_modules from the build stage to the smaller base image. Option C copies the entire /app folder including source files, increasing size. Option C copies only package.json, missing build output. Option C is single-stage.

❓ Troubleshoot

advanced

Why does the final image include build tools despite multi-stage build?

A developer uses a multi-stage Dockerfile to build a Java app but notices the final image is still very large and contains build tools. What is the most likely cause?

A They copied the entire build directory including build tools instead of only the compiled jar.

B They used a multi-stage build but forgot to specify the final CMD instruction.

C They used an Alpine base image which is larger than the build image.

D They did not run 'docker system prune' after building.

💡 Hint

Think about what files are copied from the build stage to the final image.

If the entire build directory is copied, it includes build tools and temporary files, making the final image large. Only the compiled artifact (e.g., jar file) should be copied.

✅ Best Practice

expert

Best practice for minimizing image size with multi-stage builds

Which practice best helps minimize Docker image size when using multi-stage builds for a compiled language project?

A Use a minimal base image in the final stage and copy only the compiled binary and necessary config files.

B Install all build tools in the final stage to ensure compatibility.

C Copy the entire source code and build tools to the final stage for debugging.

D Use a single-stage build with all dependencies to simplify the Dockerfile.

💡 Hint

Consider what files are essential to run the app and what can be left out.

Using a minimal base image and copying only the compiled binary and necessary config files keeps the final image small and efficient. Including build tools or source code increases size unnecessarily.