Multiple FROM statements in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of a multi-stage Docker build

Given the following Dockerfile, what will be the output when running docker build .?

Docker

FROM alpine AS builder
RUN echo "Building stage"
FROM alpine
COPY --from=builder / /app
RUN echo "Final stage"

A

Step 1/5 : FROM alpine AS builder
 ---> Using cache
Step 2/5 : RUN echo "Building stage"
 ---> Running in container
Building stage
Step 3/5 : FROM alpine
 ---> Using cache
Step 4/5 : COPY --from=builder / /app
 ---> Using cache
Step 5/5 : RUN echo "Final stage"
 ---> Running in container
Final stage

B

Step 1/3 : FROM alpine
 ---> Using cache
Step 2/3 : RUN echo "Building stage"
 ---> Running in container
Building stage
Step 3/3 : RUN echo "Final stage"
 ---> Running in container
Final stage

C

Step 1/4 : FROM alpine AS builder
 ---> Using cache
Step 2/4 : RUN echo "Final stage"
 ---> Running in container
Final stage
Step 3/4 : FROM alpine
 ---> Using cache
Step 4/4 : COPY --from=builder / /app
 ---> Using cache
Building stage

D

Step 1/4 : FROM alpine
 ---> Using cache
Step 2/4 : RUN echo "Building stage"
 ---> Running in container
Building stage
Step 3/4 : FROM alpine AS builder
 ---> Using cache
Step 4/4 : COPY --from=builder / /app
 ---> Using cache
Final stage

💡 Hint

Remember that each FROM starts a new build stage and RUN commands execute in that stage.

The Dockerfile uses two FROM statements. The first stage named 'builder' runs 'echo "Building stage"'. The second stage starts fresh from alpine and copies files from the builder stage, then runs 'echo "Final stage"'. The output shows the build steps in order.

🧠 Conceptual

intermediate

Purpose of multiple FROM statements in Dockerfile

Why do developers use multiple FROM statements in a Dockerfile?

A To run multiple containers simultaneously from one Dockerfile

B To create multiple independent images from one Dockerfile

C To build smaller final images by copying artifacts from intermediate stages

D To speed up the build by running all commands in parallel

💡 Hint

Think about how multi-stage builds help reduce image size.

Multiple FROM statements allow building intermediate stages that produce build artifacts. The final stage copies only needed files, resulting in smaller images.

❓ Configuration

advanced

Correct COPY syntax for multi-stage build

Which COPY command correctly copies the file /app/build/output.bin from the stage named builder to the current stage's /usr/local/bin/ directory?

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

B COPY builder:/app/build/output.bin /usr/local/bin/

C COPY --stage=builder /app/build/output.bin /usr/local/bin/

D COPY --from=builder /app/build/output.bin /usr/local/bin/

💡 Hint

The syntax uses --from=stage_name to specify the source stage.

The correct syntax to copy from another build stage is COPY --from=stage_name source_path destination_path. Option D follows this syntax exactly.

❓ Troubleshoot

advanced

Error caused by missing stage name in COPY

What error will occur if you run this Dockerfile snippet?

FROM alpine AS builder
RUN echo "data" > /data.txt
FROM alpine
COPY /data.txt /app/

A COPY failed: stat /data.txt: no such file or directory

B Build succeeds and copies /data.txt from builder stage

C SyntaxError: COPY command missing --from option

D Permission denied error during COPY

💡 Hint

Consider where the file /data.txt exists and what the COPY command tries to do.

The second stage starts fresh from alpine and does not have /data.txt. COPY without --from tries to copy from the current build context or image, so it fails with file not found.

🔀 Workflow

expert

Order of stages in a multi-stage Dockerfile

Given these Dockerfile instructions, what is the correct order to build a multi-stage Dockerfile that compiles a Go app and then creates a minimal runtime image? 1. FROM golang:1.20 AS builder 2. RUN go build -o /app/myapp ./src 3. FROM alpine:latest 4. COPY --from=builder /app/myapp /usr/local/bin/myapp 5. CMD ["myapp"]

A 1,3,2,4,5

B 1,2,3,4,5

C 3,1,2,4,5

D 1,2,4,3,5

💡 Hint

The build stage must come before the final stage that copies the binary.

The builder stage starts with golang image and runs the build command. Then the final stage starts from alpine, copies the built binary from builder, and sets the CMD. The order is FROM builder, RUN build, FROM alpine, COPY, CMD.