Docker Multi-stage Builds

Docker Multi-stage builds is a powerful feature that allows you to build more efficient and smaller Docker images by utilizing multiple stages in the build process. This feature was introduced in Docker 17.05 and has since become a popular practice for optimizing container images.

In this blog post, we will explore what Docker multi-stage builds are, why anyone should use them, and the benefits they offer.

What is Docker Multi-stage Builds?

In traditional Docker builds, each step in the Dockerfile creates a new layer in the image. As a result, the final image can become large and bloated with unnecessary files and dependencies.

Docker multi-stage builds, on the other hand, allow you to create multiple build stages within a single Dockerfile. Each stage can use a different base image and perform specific build steps. The final image only contains the artifacts from the final stage, which results in a smaller, more efficient image.

In other words, multi-stage builds help you to create lean and optimized images by allowing you to perform multiple tasks in a single Dockerfile.

Why use Docker Multi-stage Builds?

There are several benefits to using Docker multi-stage builds:

Smaller Image Sizes

One of the primary benefits of multi-stage builds is that they result in smaller Docker images. This is because only the necessary files are included in the final stage, and intermediate build stages are discarded. This can lead to significant savings in terms of storage space and network bandwidth.

Improved Build Times

Multi-stage builds can also help to improve build times. Separating the build process into multiple stages allows you to leverage caching to speed up the build process. Only the stages that have changed since the last build will be rebuilt, while the other stages can be retrieved from the cache.

Better Security

Another benefit of multi-stage builds is improved security. By separating the build process into multiple stages, you can ensure that only the necessary dependencies are included in the final image. This can help to reduce the attack surface of the application.


Let’s take a look at a practical example of how to use multi-stage builds in a Dockerfile.

Node.js Application

Here’s an example of a Dockerfile for a Node.js application that uses multi-stage builds:

# First stage: build the Node.js app
FROM node:14-alpine AS builder
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Second stage: run the app in a lightweight image
FROM node:14-alpine
COPY --from=builder /app/dist ./dist
CMD ["npm", "start"]

In this example, the first stage uses the node:14-alpine image to build the Node.js application. It installs dependencies, builds the app, and produces a dist directory with the compiled code.

The second stage uses the same base image, but only copies the dist directory from the first stage. This results in a much smaller image containing only the necessary files to run the app.

This post is licensed under CC BY 4.0 by the author.