---
title: "How to Reduce Docker Image Size"
source: "https://support.tools/reduce-docker-image-size/"
published: 2024-09-12
categories: ["Docker","Containers","Performance"]
tags: ["Docker","Image Optimization","Containers","DevOps"]
---


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.

```dockerfile
FROM alpine
```

For example, replacing:

```dockerfile
FROM ubuntu
```

with:

```dockerfile
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:

```dockerfile
# 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.

```dockerfile
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:

```plaintext
.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:

```dockerfile
ADD . /app
```

with:

```dockerfile
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.

```dockerfile
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:

```dockerfile
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.