Multi-stage builds for smaller images in MLOps - Step-by-Step Execution

Process Flow - Multi-stage builds for smaller images

Start: Define first stage

↓

Build app in first stage

↓

Define second stage

↓

Copy only needed files from first stage

↓

Build final smaller image

↓

Use smaller image for deployment

Multi-stage builds use multiple steps in one Dockerfile to build and then copy only needed files, making the final image smaller.

Execution Sample

MLOps

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
CMD ["node", "dist/index.js"]

This Dockerfile builds the app in the first stage, then copies only the built files to a smaller final image.

Process Table

Step	Action	Stage	Files Present	Image Size Impact
1	Start first stage with full node image	build	All source files copied	Large size due to full dependencies
2	Run npm install and build	build	Node modules and build output created	Size grows due to dependencies and build artifacts
3	Start second stage with slim node image	final	Empty except base image files	Small base size
4	Copy only /app/dist from build stage	final	Only built files present	Size small, no dev dependencies
5	Set command to run built app	final	Ready to run	Final image optimized
6	Image ready for deployment	final	Contains only runtime files	Small image size achieved

💡 Final image contains only necessary runtime files, making it smaller than the build stage image.

Status Tracker

Variable	Start	After Step 2	After Step 4	Final
Files in build stage	source files only	source + node_modules + build output	N/A	N/A
Files in final stage	empty	empty	only /app/dist copied	only /app/dist present
Image size	base size	large due to dependencies	base slim size	small optimized size

Key Moments - 3 Insights

Why do we use two FROM statements in one Dockerfile?

The first FROM builds the full app with all tools, the second FROM starts a clean smaller image to copy only needed files, as shown in execution_table steps 1 and 3.

What happens if we copy all files from the build stage instead of just the build output?

The final image will be large because it includes unnecessary source and node_modules files, losing the size benefit shown in step 4.

Why is the final image smaller even though it runs the same app?

Because it contains only the built app files without development dependencies, as seen in the variable_tracker for final stage files.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what files are copied to the final image?

A Node modules only

B All source files

C /app/dist only

D Empty folder

💡 Hint

Check the 'Files Present' column at step 4 in the execution_table.

At which step does the image size become small and optimized?

A Step 6

B Step 2

C Step 5

D Step 4

💡 Hint

Look at the 'Image Size Impact' column and find when the final image is ready.

If we remove the second FROM line, how would the final image size change?

A It would be smaller

B It would be larger

C It would be the same

D It would fail to build

💡 Hint

Refer to the concept_flow and execution_table steps showing the purpose of the second stage.

Concept Snapshot

Multi-stage builds use multiple FROM statements in one Dockerfile.
First stage builds app with all dependencies.
Second stage copies only needed files to a smaller base image.
Result: smaller final image with just runtime files.
Use COPY --from=build to transfer files between stages.

Full Transcript

Multi-stage builds help create smaller Docker images by splitting the build process into stages. The first stage uses a full image to build the app with all dependencies. The second stage starts from a smaller base image and copies only the built app files from the first stage. This reduces the final image size by excluding development tools and source files. The Dockerfile uses multiple FROM statements to define stages and COPY --from to transfer files. This method is common in MLOps to optimize container sizes for deployment.