Multiple FROM statements in Docker - Step-by-Step Execution

Process Flow - Multiple FROM statements

Start Dockerfile

↓

FROM base image 1

↓

Build stage 1

↓

FROM base image 2

↓

Build stage 2

↓

Final image created

↓

Use artifacts from previous stages if needed

↓

End Dockerfile

Dockerfile starts with first FROM to create stage 1, then second FROM starts stage 2, allowing multi-stage builds and artifact sharing.

Execution Sample

Docker

FROM python:3.12-slim AS builder
RUN pip install --no-cache-dir flask
FROM python:3.12-slim
COPY --from=builder /usr/local/lib/python3.12/site-packages /app/libs
CMD ["python3"]

This Dockerfile uses two FROM statements to build dependencies in one stage and copy them into a clean final image.

Process Table

Step	Action	Stage	Result
1	Start Dockerfile	None	Ready to read first FROM
2	FROM python:3.12-slim AS builder	builder	Base image python:3.12-slim loaded as builder stage
3	RUN pip install --no-cache-dir flask	builder	Flask installed in builder stage
4	FROM python:3.12-slim	final	New stage 'final' starts with clean python:3.12-slim image
5	COPY --from=builder /usr/local/lib/python3.12/site-packages /app/libs	final	Copied flask libs from builder stage to final image
6	CMD ["python3"]	final	Set command to run python3 in final image
7	Build complete	final	Final image created with flask libs from builder stage

💡 Dockerfile ends after last command; final image ready with multi-stage build artifacts

Status Tracker

Variable	Start	After Step 3	After Step 5	Final
builder image	empty	python:3.12-slim + flask installed	unchanged	unchanged
final image	empty	empty	python:3.12-slim + flask libs copied	ready to run python3

Key Moments - 2 Insights

Why do we start a new stage with a second FROM instead of continuing the first?

Each FROM starts a new build stage with a clean base image. This allows separating build dependencies from the final image, as shown in steps 2 and 4 of the execution_table.

How does COPY --from=builder work to share files between stages?

COPY --from=builder copies files from the named previous stage 'builder' into the current stage. Step 5 shows copying flask libraries from builder to final image.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the final image start building?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check the 'Stage' column to see when 'final' stage begins.

According to variable_tracker, what is the state of the builder image after step 3?

A Base image plus flask installed

B Only base image loaded

C Empty

D Final image ready

💡 Hint

Look at 'builder image' row after 'After Step 3' column.

If we remove the COPY --from=builder command, what happens to the final image?

A It still has flask installed

B It will be empty

C It will not have flask libraries

D It will fail to build

💡 Hint

Refer to step 5 in execution_table where COPY copies flask libs to final image.

Concept Snapshot

Multiple FROM statements allow multi-stage Docker builds.
Each FROM starts a new stage with a clean base image.
Use AS to name stages for reference.
COPY --from=stage copies files between stages.
This reduces final image size by excluding build tools.

Full Transcript

This visual execution shows how Dockerfiles with multiple FROM statements work. The Dockerfile starts with a base image named 'builder' where dependencies like flask are installed. Then a second FROM starts a clean 'final' stage. Files are copied from the builder stage to the final stage using COPY --from=builder. This creates a smaller final image with only needed files. The execution table traces each step, showing when stages start and what actions happen. The variable tracker shows how the builder and final images change over time. Key moments clarify why new stages start with FROM and how files are shared. The quiz tests understanding of stage transitions and file copying. This method helps keep Docker images efficient and clean.