Copying from build stage to final stage in Docker - Step-by-Step Execution

Process Flow - Copying from build stage to final stage

Start: Multi-stage Dockerfile

↓

Build Stage: Compile or build app

↓

Copy artifacts from build stage

↓

Final Stage: Use copied artifacts

↓

Build final image

↓

Run container with final image

This flow shows how Docker builds an image in stages, copying files from the build stage to the final stage to keep the final image small.

Execution Sample

Docker

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

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

This Dockerfile builds a Node.js app in the build stage, then copies the build output to an Nginx image in the final stage.

Process Table

Step	Action	Stage	Files Present	Result
1	Start build stage	build	empty	Working directory /app created
2	Copy package.json	build	package.json	package.json copied to /app
3	Run npm install	build	node_modules created	Dependencies installed
4	Copy all files	build	all source files	Source code copied to /app
5	Run npm run build	build	build folder created	App compiled into /app/build
6	Start final stage	final	empty	Base nginx image ready
7	Copy from build stage	final	/usr/share/nginx/html	Copied /app/build to nginx html folder
8	Build final image	final	/usr/share/nginx/html with build files	Final image ready with static files
9	Run container	final	running container	Nginx serves the built app
10	Exit	-	-	Process complete

💡 All build steps completed and final image contains only necessary files from build stage

Status Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	Final
/app contents	empty	package.json + node_modules	package.json + node_modules + build folder	empty	empty
/usr/share/nginx/html contents	empty	empty	empty	build folder copied here	build folder present

Key Moments - 3 Insights

Why is the build folder empty in the final stage before copying?

Because each stage has its own filesystem, files created in the build stage are not visible in the final stage until explicitly copied (see step 6 and 7 in execution_table).

What does the --from=build option do in the COPY command?

It tells Docker to copy files from the build stage named 'build' into the current stage (final), as shown in step 7.

Why do we use multi-stage builds instead of one big stage?

To keep the final image small by only copying necessary files, avoiding development dependencies and build tools in the final image (see final image contents in step 8).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the build folder created?

A Step 5

B Step 3

C Step 7

D Step 2

💡 Hint

Check the 'Files Present' column for the build folder creation in the build stage

At which step does the final stage start copying files from the build stage?

A Step 6

B Step 8

C Step 7

D Step 5

💡 Hint

Look for the COPY --from=build action in the execution_table

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

A It will contain the build folder anyway

B It will be empty and not serve the app

C It will fail to build

D It will copy files from the base image

💡 Hint

Refer to step 7 and 8 where copying build files is essential for final image content

Concept Snapshot

Multi-stage Docker builds use separate stages.
Build stage compiles or prepares files.
Final stage copies only needed files with COPY --from=build.
This keeps final images small and clean.
Use named stages for clarity.

Full Transcript

This visual execution shows how Docker multi-stage builds work. First, the build stage creates the app build files. Then the final stage starts fresh and copies only the build output from the build stage. This keeps the final image small by excluding build tools and source files. The COPY --from=build command is key to transfer files between stages. Each stage has its own filesystem, so files are not shared unless copied. This method is common for building and packaging apps efficiently in Docker.