Multi-Stage Builds in Docker: Reducing Image Size

Details: Category: Docker Dynamics; By Saurabh Chase; 08.Dec; Hits: 36

Multi-stage builds are a powerful feature in Docker that help reduce the size of container images by separating the build and runtime stages. By leveraging multi-stage builds, you can optimize your Dockerfiles, minimize dependencies, and improve image performance.

In this article, we’ll explore how to use multi-stage builds in Docker to create lightweight and efficient images.

Saurabh Chase

Innovator | Visionary | Influencer

tbd

Experience

tbd

More to Explore

Top Business Principles from Harvard Business School

10.Sep

What Are Multi-Stage Builds?
Multi-stage builds allow you to use multiple `FROM` statements in a single Dockerfile, each representing a different stage of the build process. Intermediate stages are discarded, leaving only the final stage in the resulting image.

Benefits of Multi-Stage Builds
1. Smaller Image Sizes: Exclude unnecessary build tools and dependencies from the final image.
2. Improved Security: Reduce the attack surface by including only runtime dependencies.
3. Cleaner Dockerfiles: Separate build and runtime configurations for better maintainability.

Example: Using Multi-Stage Builds

Let’s create a multi-stage build for a Node.js application:

1. Basic Multi-Stage Dockerfile:

# Build Stage
FROM node:14 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Runtime Stage
FROM node:14-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

In this example:
- The `builder` stage installs dependencies and builds the application.
- The final stage includes only the application and its runtime dependencies.

2. Building the Image:
Build the image using the following command:

docker build -t my-app:latest .

3. Running the Container:
Run the optimized image:

docker run -d -p 3000:3000 my-app:latest

Advanced Multi-Stage Techniques
1. Using Multiple Build Stages: Split the build process into more than two stages for complex applications. Example with a Go application:

# Base Stage
FROM golang:1.17 AS base
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

# Build Stage
FROM base AS builder
COPY . .
RUN go build -o myapp

# Final Stage
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
CMD ["./myapp"]

2. Including Tests: Add a testing stage to ensure application quality:

# Test Stage
FROM builder AS tester
RUN go test ./...

3. Optimizing Intermediate Stages: Use smaller base images like `alpine` for intermediate stages to save space and speed up builds.

Best Practices for Multi-Stage Builds
1. Minimize Dependencies: Include only the dependencies required for each stage.
2. Use Separate Stages for Tests: Run tests in a dedicated stage to validate code before building the final image.
3. Leverage Caching: Organize Dockerfile instructions to maximize layer caching.
4. Optimize Final Images: Use minimal base images for the runtime stage, such as `alpine` or `slim` variants.
5. Keep Dockerfiles Readable: Add comments and structure your Dockerfile for maintainability.

Conclusion
Multi-stage builds in Docker provide a simple yet powerful way to create optimized container images. By separating build and runtime stages, you can reduce image sizes, improve security, and streamline your development workflow. Start implementing multi-stage builds in your projects to achieve lightweight and efficient Docker images today.

Contact Us