To reduce the size of Docker images, the key is to streamline it. 1. Select a smaller base image, such as alpine, scratch or distroless; 2. Use multi-stage building to separate the build and run environment; 3. Clean caches and temporary files after installation; 4. Merge operations to reduce unnecessary layers. These steps can effectively optimize the image size and improve deployment efficiency.

Want to make Docker image smaller? In fact, the key is the word "simplification". Too large images are not only slow to pull, but also troublesome to deploy, especially in the CI/CD process, which will slow down overall efficiency. If you want to reduce the image volume, you can start with basic image, construction process and final output.

Use smaller basic mirrors

Many projects use complete distributions such as ubuntu or debian as basic images by default, but they often come with a lot of unnecessary tools and libraries.
If you are just running a simple app (such as Go or Node.js), consider switching to a lighter image, for example:

• alpine series: For example node:18-alpine or golang:1.20-alpine
• scratch : empty mirror, suitable for static compilation languages ??such as Go
• distroless : A series of shell-free minimal images provided by Google, suitable for production environments

Note: Although alpine is small, it may also cause some programs to run due to incompatibility between musl libc and glibc, so they need to be verified in advance.

Multi-stage build rationally

This is one of the most effective ways to reduce the image volume. Simply put, it is to separate the build process and run environment, and only the files required to run are retained.

For example, if you are building a Go application:

 # FROM golang:1.20 as builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# Final run phase FROM alpine
COPY --from=builder /app/myapp /myapp
CMD ["/myapp"]

In this way, the final image will only have your executable files and necessary runtime dependencies, and there will be no unnecessary content such as source code, compiler, etc.

Clean caches and temporary files

Many people forget to clean up the cache or installation packages generated in the middle when writing Dockerfile. For example, after installing the software with apt /var/cache/apt/archives/ is not deleted, or after installing the module in npm, the cache is not cleared.

The correct way is to clean it up every time you install it, such as:

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

For Node.js project:

 RUN npm install && \
    npm run build && \
    npm cache clean --force

These seemingly inconspicuous small movements can save a lot of space.

Avoid unnecessary layers (Layers)

Docker is built on a layer, and each RUN and COPY operation will generate a layer. If you divide it too finely, it will generate a lot of redundant layers, affecting the size and performance of the mirror.

It is recommended to merge multiple operations into one RUN as much as possible, such as:

? Recommended:

 RUN apt-get update && \
    apt-get install -y curl && \
    curl -sL https://example.com/install.sh | sh

? Not recommended:

 RUN apt-get update
RUN apt-get install -y curl
RUN curl -sL https://example.com/install.sh | sh

Although it seems to be logical, each command has a new layer, which increases the volume.

Basically these are the methods. After all, optimizing Docker image volume is not a high-tech, the key is not to be lazy in details. Some steps seem dispensable, but the difference will be obvious after a long period of accumulation.

The above is the detailed content of How to reduce the size of a Docker image?. For more information, please follow other related articles on the PHP Chinese website!