How to Shrink Docker Images by 99%: Multi‑Stage Builds, Distroless & Layer Optimization

Why Image Bloat Matters

Large Docker images slow build and deployment cycles, increase storage and bandwidth costs, and degrade application response time. The hidden costs are measured in time, money and performance.

Case Study: From 1.2 GB to 8 MB

A standard Python machine‑learning container of 1.2 GB was reduced to an 8 MB image (99 % size reduction) by applying a series of optimization techniques.

Typical Dockerfile (Problematic)

FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "main.py"]

This Dockerfile uses the full Python base image, installs unnecessary build tools, creates many layers, and may copy unwanted files, all of which inflate the image.

Optimization Techniques

Multi‑Stage Build : Separate build‑time dependencies from the runtime image.

Minimal Base Images : Use python:3.9‑slim or scratch instead of the full distribution.

Layer Consolidation : Combine multiple RUN commands into a single layer and clean up caches in the same step.

Distroless Images : Use Google’s distroless base ( gcr.io/distroless/python3-debian10) to include only runtime necessities.

Docker BuildKit : Enable BuildKit for faster, more cache‑aware builds ( DOCKER_BUILDKIT=1 docker build -t myapp .).

.dockerignore : Exclude large datasets, virtual environments, caches, logs, and other non‑essential files.

Security Practices : Use trusted base images, run containers as non‑root, limit exposed ports/IPs, scan images with tools like Trivy, and avoid hard‑coding secrets.

Multi‑Stage Build Example

# Stage 1: Build
FROM python:3.9‑slim AS builder
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential gcc && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN python compile_model.py
RUN pip install pyinstaller
RUN pyinstaller --onefile inference.py

# Stage 2: Production
FROM scratch
WORKDIR /app
COPY --from=builder /app/dist/inference /app/inference
COPY --from=builder /app/model /app/model
ENTRYPOINT ["/app/inference"]

The resulting image is about 85 MB, a >90 % reduction compared with the single‑stage build.

Distroless Image Example

FROM gcr.io/distroless/python3-debian10
COPY --from=builder /app/dist/main /app/main
COPY --from=builder /app/model /app/model
COPY --from=builder /app/config.yml /app/config.yml
ENTRYPOINT ["/app/main"]

Additional Tips

Remove unnecessary files and use external volumes for large data.

Leverage image analysis tools such as docker-slim or dive to inspect layer sizes.

Consider Unikernels for extreme size reductions (up to 80 % smaller).

Results

Image size : Reduced from 1.2 GB to 8 MB (99.33 % decrease).

Deployment time : Shortened by roughly 85 %.

Cloud cost : Lowered by about 60 %.

Start with the smallest possible base image, apply multi‑stage builds, continuously prune layers and dependencies, and follow security best practices to achieve dramatically smaller and more efficient Docker images.