Docker Image Optimization Tips

Discover essential tips for optimizing Docker images: enhance performance, reduce size, and boost resource efficiency.

Himanshu Pant

Published: December 19, 2023

Key takeaways

Use lightweight base images like Alpine, reduce the number of layers by putting multiple instructions into a single layer and using the multi-stage builds which allow to remove unnecessary build data.
Resources and images should be downsized to only the necessary ones, dependency installations should be precise, version tags should be applied, and the build tools should be erased or minimized to only one layer.
Optimise build process by using Docker BuildKit for parallel building and correctly arrange Dockerfile instructions with regard to layers to allow Docker to cache often changing parts, and thus reduce build time.

Docker has become an essential tool in modern software development, enabling the packaging and deployment of applications in lightweight, portable containers. However, as Docker images grow in complexity, optimizing them for size and performance becomes crucial. In this blog post, we’ll explore practical tips and strategies for creating lean and optimized Docker images, enhancing both performance and resource efficiency.

Understanding Docker Images

Before diving into optimization strategies, let’s briefly review the components of a Docker image. A Docker image consists of layers, where each layer represents a specific instruction in the Dockerfile. These layers are cached, allowing for faster builds and reducing the overall size of the image.

Tips for Optimizing Docker Images

1. Use Official Base Images Wisely

Choosing the right base image is the first step in optimizing your Docker image. Official images from Docker Hub are often well-maintained and regularly updated. Select the minimal image that satisfies your application’s dependencies to keep the image size small.

# Bad Example
FROM ubuntu:latest

# Good Example
FROM alpine:latest

# Bad Example

FROM ubuntu:latest

# Good Example

FROM alpine:latest

2. Minimize Layers

Each instruction in a Dockerfile creates a new layer. Minimize the number of layers by combining related instructions. This reduces the image size and speeds up builds.

# Bad Example
FROM alpine:latest
RUN apk update
RUN apk add --no-cache curl

# Good Example
FROM alpine:latest
RUN apk update && apk add --no-cache curl

# Bad Example

FROM alpine:latest

RUN apk update

RUN apk add --no-cache curl

# Good Example

FROM alpine:latest

RUN apk update && apk add --no-cache curl

3. Use Multi-Stage Builds

Multi-stage builds allow you to use multiple FROM statements in a single Dockerfile. This helps in creating a smaller final image by discarding unnecessary build artifacts from earlier stages.

# Multi-Stage Build Example
FROM node:14 AS builder
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

# Multi-Stage Build Example

FROM node:14 AS builder

WORKDIR /app

COPY . .

RUN npm install

RUN npm run build

FROM nginx:alpine

COPY --from=builder /app/dist /usr/share/nginx/html

4. Remove Unnecessary Files

Ensure that your Docker image only includes files required for runtime. Remove unnecessary files and dependencies that were only needed during the build process.

# Bad Example
COPY . /app

# Good Example
COPY src/ /app/src
COPY public/ /app/public
COPY package.json /app/

# Bad Example

COPY . /app

# Good Example

COPY src/ /app/src

COPY public/ /app/public

COPY package.json /app/

5. Optimize Dependencies Installation

Combine dependency installation steps to avoid unnecessary cache invalidation and reduce layer count. Also, consider using package managers that automatically clean up unnecessary files.

# Bad Example
RUN npm install
RUN npm install --global some-package

# Good Example
RUN npm install \
    && npm install --global some-package

# Bad Example

RUN npm install

RUN npm install --global some-package

# Good Example

RUN npm install \

&& npm install --global some-package

6. Use Specific Tags

When pulling base images or dependencies, use specific version tags instead of latest to ensure consistency and avoid unexpected changes.

# Bad Example
FROM node:latest

# Good Example
FROM node:14

# Bad Example

FROM node:latest

# Good Example

FROM node:14

7. Enable BuildKit for Parallel Building

BuildKit is a new build frontend for Docker that brings improvements such as parallel building. Enable BuildKit to take advantage of these features.

# Enable BuildKit
export DOCKER_BUILDKIT=1

1 2	# Enable BuildKit export DOCKER_BUILDKIT=1

8. Clean Up in a Single Layer

When you need to install build tools, clean up unnecessary files in the same layer to minimize the overall image size.

# Bad Example
RUN apk add --no-cache build-base \
    && make \
    && apk del build-base

# Good Example
RUN apk add --no-cache build-base \
    && make \
    && apk del build-base \
    && rm -rf /var/cache/apk/*

# Bad Example

RUN apk add --no-cache build-base \

&& make \

&& apk del build-base

# Good Example

RUN apk add --no-cache build-base \

&& make \

&& apk del build-base \

&& rm -rf /var/cache/apk/*

9. Optimize Dockerfile Instruction Order

Place frequently changing instructions towards the end of the Dockerfile to leverage Docker’s layer caching mechanism effectively.

# Good Example
COPY package.json /app/
RUN npm install
COPY . /app/

# Good Example

COPY package.json /app/

RUN npm install

COPY . /app/

Conclusion

Optimizing Docker images is a crucial aspect of efficient containerized application development. By following these practical tips and strategies, you can create lean, efficient, and high-performance Docker images. Regularly review and update your Dockerfiles to incorporate the latest best practices and keep your containerized applications running smoothly. Remember, small changes in your Dockerfile can result in significant improvements in image size and build times.