How to Reduce Docker Image Size // Support Tools

Reducing Docker image size is a critical part of optimizing containerized applications. Smaller images result in faster builds, lower transfer times, and reduced resource usage. In this guide, we will explore several techniques to reduce Docker image sizes while maintaining functionality.

Why Reducing Docker Image Size Matters

Faster Deployments: Smaller images transfer more quickly, leading to faster deployment times.
Lower Storage Requirements: Reducing the size of images helps conserve disk space on both local development environments and container registries.
Improved Security: Smaller images have fewer components, reducing the attack surface and improving security.
Efficiency: Optimized images reduce memory and CPU usage, enhancing performance.

Techniques to Reduce Docker Image Size

1. Choose a Minimal Base Image

Start with a minimal base image like alpine, which is significantly smaller than full-featured base images like ubuntu. Alpine Linux is only about 5MB, making it an ideal choice for smaller images.

FROM alpine

For example, replacing:

FROM ubuntu

with:

FROM alpine

can reduce image size by hundreds of megabytes.

2. Use Multi-Stage Builds

Multi-stage builds allow you to separate the build process from the final runtime environment, reducing the final image size by excluding build dependencies. Here’s an example of how to use multi-stage builds:

# Build stage
FROM golang:1.17-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# Final stage
FROM alpine
COPY --from=builder /app/myapp /myapp
ENTRYPOINT ["/myapp"]

In this example, the build environment (Go, build tools) is discarded, and only the final executable is included in the resulting image.

3. Minimize Layers

Every line in a Dockerfile that creates a new instruction (like RUN, COPY, or ADD) adds a new layer to the Docker image. Combine multiple commands into a single RUN instruction to minimize layers.

RUN apt-get update && apt-get install -y \
    package1 \
    package2 && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

This combines updates, installations, and cleanup into a single layer, reducing the final image size.

4. Remove Unnecessary Files

When building your image, be sure to exclude unnecessary files that aren’t needed in production. You can use a .dockerignore file to prevent specific files or directories from being copied into the image.

Create a .dockerignore file:

.git
node_modules
README.md
Dockerfile

This excludes source code files, documentation, and dependencies that aren’t needed for the final image.

5. Use `COPY` Instead of `ADD`

The ADD command in Docker can automatically extract compressed files and supports downloading files from URLs. However, unless you need these extra features, COPY is the more lightweight and efficient option.

Replace:

ADD . /app

with:

COPY . /app

6. Use `scratch` for Minimal Containers

For ultra-small containers, consider using scratch as the base image. The scratch image is an empty image with nothing installed, ideal for static binaries.

FROM scratch
COPY myapp /myapp
ENTRYPOINT ["/myapp"]

This approach is useful for applications that don’t need an operating system environment, reducing the image size to only the size of the binary.

7. Clean Up Cache and Temporary Files

When using package managers like apt or yum, always clean up the package cache and temporary files after installation to save space.

For example:

RUN apt-get update && apt-get install -y curl && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

This ensures that any temporary files created during installation are removed, reducing the final image size.

Final Thoughts

Optimizing Docker images by reducing their size leads to better performance, faster deployments, and a more secure container environment. By selecting minimal base images, using multi-stage builds, and cleaning up unnecessary files, you can ensure your Docker images remain efficient and lightweight.