Copying from build stage to final stage in Docker - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of using multiple stages in a Dockerfile?

Multiple stages help separate the build environment from the final runtime environment. This keeps the final image small and secure by copying only needed files from the build stage.

beginner

How do you copy files from a build stage to the final stage in a Dockerfile?

Use the COPY --from=<stage-name> <source> <destination> command to copy files from a named build stage to the current stage.

beginner

What does the --from flag do in the COPY command?

The --from flag tells Docker to copy files from a previous build stage instead of the local build context.

intermediate

Why is it beneficial to copy only specific files from the build stage to the final stage?

Copying only specific files reduces the final image size, improves security by excluding build tools, and speeds up deployment.

intermediate

Give an example of a simple multi-stage Dockerfile copying a binary from build to final stage.

Example:

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

FROM alpine:latest
COPY --from=build /app/myapp /usr/local/bin/myapp
CMD ["/usr/local/bin/myapp"]

What does the --from option in the COPY command specify?

A The destination directory inside the container

B The network mode for the build

C The user to run the copy command

D The source build stage to copy files from

The --from option specifies which build stage to copy files from in a multi-stage Dockerfile.

Why use multi-stage builds in Docker?

A To reduce final image size by copying only needed files

B To run multiple containers at once

C To speed up network downloads

D To automatically update images

Multi-stage builds allow copying only necessary files to the final image, reducing size and improving security.

In a multi-stage Dockerfile, what happens if you omit the --from flag in COPY?

A Docker copies files from the internet

B Docker copies files from the local build context

C Docker throws an error

D Docker copies files from the last build stage

Without --from, COPY copies files from the local build context (your project folder).

Which command copies a file named app from a build stage named builder to the final image?

A COPY /app --from=builder /app

B COPY app builder:/app

C COPY --from=builder /app /app

D COPY builder app /app

The correct syntax is COPY --from=builder /app /app to copy from the build stage named 'builder'.

What is a key benefit of separating build and final stages in Docker?

A Smaller, cleaner final images

B Faster internet speed

C More CPU cores used

D Automatic code testing

Separating build and final stages keeps the final image small and free of unnecessary build tools.

Explain how to copy files from a build stage to the final stage in a Dockerfile and why this is useful.

Think about separating build environment from runtime environment.

Describe a simple example of a multi-stage Dockerfile that builds a binary and copies it to a smaller final image.

Use a language like Go or C for the example.

Practice

1. What is the main purpose of using COPY --from= in a multi-stage Docker build?

easy

A. To copy files from the host machine to the build stage

B. To copy files from a previous build stage to the final image

C. To copy files from the final image back to the build stage

D. To copy files between two running containers

Solution

1. Step 1: Understand multi-stage builds

   Multi-stage builds allow you to create intermediate stages for building your app.

2. Step 2: Purpose of COPY --from=

   The COPY --from= command copies files from these intermediate stages into the final image, keeping it clean and small.

3. Final Answer:

   To copy files from a previous build stage to the final image -> Option B

4. Quick Check:

   COPY --from= copies from build stage [OK]

Hint: COPY --from= copies from build stage, not host or containers [OK]

Common Mistakes:

• Confusing COPY --from= with copying from host
• Thinking it copies files between containers
• Assuming it copies files back to build stage

2. Which of the following is the correct syntax to copy the file /app/build/output.bin from a build stage named builder to the final image's /app directory?

easy

A. COPY --from=builder /app/build/output.bin /app

B. COPY /app/build/output.bin /app --from=builder

C. COPY builder:/app/build/output.bin /app

D. COPY /app/build/output.bin builder:/app

Solution

1. Step 1: Recall COPY --from= syntax

   The correct syntax is COPY --from=stage source_path destination_path.

2. Step 2: Match the paths and stage name

   COPY --from=builder /app/build/output.bin /app correctly uses --from=builder followed by source and destination paths.

3. Final Answer:

   COPY --from=builder /app/build/output.bin /app -> Option A

4. Quick Check:

   Correct COPY --from= syntax is COPY --from=stage src dst [OK]

Hint: COPY --from= comes before source and destination paths [OK]

Common Mistakes:

• Placing --from= after source and destination
• Using colon syntax like builder:/path (invalid)
• Swapping source and destination paths

3. Given this Dockerfile snippet, what files will be present in the final image's /app directory?

FROM node:18 AS builder
WORKDIR /app
RUN echo "build file" > build.txt

FROM alpine
COPY --from=builder /app/build.txt /app/

medium

A. No /app directory created

B. An empty /app directory

C. The file build.txt with content "build file"

D. The file build.txt but empty

Solution

1. Step 1: Check build stage output

   The builder stage creates /app/build.txt with content "build file".

2. Step 2: COPY from builder to final image

   The final stage copies /app/build.txt from builder to /app/ in the final image.

3. Final Answer:

   The file build.txt with content "build file" -> Option C

4. Quick Check:

   File copied with content preserved [OK]

Hint: COPY --from= copies actual files, not empty placeholders [OK]

Common Mistakes:

• Assuming directory is empty after copy
• Thinking file content is lost
• Assuming /app directory is missing

4. Identify the error in this Dockerfile snippet that tries to copy from a build stage named builder:

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

FROM alpine
COPY /app/myapp --from=builder /usr/local/bin/myapp

medium

A. The --from=builder flag is placed after the source path

B. The build stage name builder is missing

C. The destination path /usr/local/bin/myapp is invalid

D. The RUN go build command is incorrect

Solution

1. Step 1: Check COPY command syntax

   The correct syntax is COPY --from=builder source destination. The flag must come before paths.

2. Step 2: Identify error in given command

   The command places --from=builder after the source path, which is invalid syntax.

3. Final Answer:

   The --from=builder flag is placed after the source path -> Option A

4. Quick Check:

   --from= must come before source path [OK]

Hint: Place --from= before source path in COPY command [OK]

Common Mistakes:

• Putting --from= after source path
• Forgetting to name the build stage
• Assuming destination path is invalid without checking

5. You want to build a Docker image for a Python app. The build stage installs dependencies and creates a dist/app.tar.gz file. The final stage should only copy this archive and extract it to /app. Which Dockerfile snippet correctly copies and extracts the archive from the build stage named builder?

hard

A. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /src/dist/app.tar.gz /app/\nRUN tar xzf /app/app.tar.gz

B. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY /src/dist/app.tar.gz --from=builder ./\nRUN tar xzf app.tar.gz

C. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /dist/app.tar.gz ./\nRUN tar xzf app.tar.gz

D. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /src/dist/app.tar.gz ./\nRUN tar xzf app.tar.gz

Solution

1. Step 1: Verify COPY --from= syntax and source path

   The builder stage (WORKDIR /src) creates dist/app.tar.gz at /src/dist/app.tar.gz. Correctly uses COPY --from=builder /src/dist/app.tar.gz ./ with --from=builder first and absolute source path.

2. Step 2: Confirm extraction command and paths

   Final stage WORKDIR /app, copy to ./ places app.tar.gz there. RUN tar xzf app.tar.gz extracts correctly.

3. Final Answer:

   COPY --from=builder /src/dist/app.tar.gz ./\nRUN tar xzf app.tar.gz -> Option D

4. Quick Check:

   COPY --from= before source path, extract in correct directory [OK]

Hint: COPY --from= before source path; extract where file copied [OK]

Common Mistakes:

• Placing --from= after source path
• Using wrong source path like /dist/app.tar.gz instead of /src/dist/app.tar.gz
• Extracting archive from wrong directory