How to Minimize Docker Container Image Size Using DockerSlim



Docker lets you run an application within container environments. It allowed you to build images that let your application inherit characteristics such as portability, easy deployment, platform compatibility, etc. However, many encounter challenges with large Docker container sizes that take up significant storage space on your computer. Taking advantage of tools such as DockerSlim allows you to minimize Docker image size up to 30 times. This guide will teach how to minimize Docker image size using DockerSlim.


To continue in this article, it is helpful to have the following:

  • Docker installed on your computer.
  • Download DockerSlim from here.
  • To check if DockerSlim has successfully been installed, check the version:
    docker-slim -v

What is DockerSlim

DockerSlim allows you to build slimmer Docker images. It analyzes your Docker image’s contents and removes duplicate files, unused dependencies, and system libraries that the application doesn’t require to run. This significantly reduces Docker image size, making deploying and managing your application in different containerized environments easier.

DockerSlim uses static and dynamic analysis to reduce the Docker image layers. These approaches slim or remove layers with unnecessary binaries, libraries, files, and directories. As a result, they can optimize the container development process by making them smaller and more efficient.

DockerSlim also allows you to add custom configuration files and build scripts to fine-tune the optimization process to meet your specific application requirements. DockerSlim archives this using three commands, xray, lint, and profile. These commands provide analysis for your Dockerfile and Docker images to allow you to understand your container in detail.

Let’s dive and use these commands to learn how DockerSlim works to reduce and minimize Docker image sizes using DockerSlim

DockerSlim Lint Command

The lint command analyzes the container instructions in Dockerfile. It analyzes a Dockerfile and identifies potential issues and inefficiencies that could impact the image size. The lint command takes Dockerfile as input and performs a static analysis of its contents. It checks for common issues such as:

  • Any files and directories not needed by the image.
  • Redundant and unused dependencies.
  • Misconfigured environment variables with security vulnerabilities.
  • Dockerfile formats that can cause build failures.

To test its functionality, ensure you have a Dockerfile for your project. Below is an example Dockerfile with instructions for running a Node.js application as follows:

FROM node:16

WORKDIR /usr/src/app

COPY package.json .
RUN npm install
RUN chown -R node /usr/src/app/node_modules
COPY . .


CMD ["node","app.js"]

On this file directory location, run a lint command to analyze the above instructions:

docker-slim lint --target Dockerfile

In this example, DockerSlim gives you a warn to add a .dockerignore file to your application. .dockerignore allows you to specify files that Docker should avoid copying and can result in increased image size while still not needed to create the overall image build.

DockerSlim Xray Command

This command performs static analysis of the target container image. From this command, you can get to know what is inside the target container and what makes it large:

To test the command, create a simple Nginx image by pulling the Nginx Docker image as follows:

docker pull nginx:latest

Apply the xray command to the created image as follows:

docker-slim xray nginx

DockerSlim profile Command

The command analysis of the container image without generating an optimized image.

To test the command:

docker-slim profile --sensor-ipc-mode proxy --sensor-ipc-endpoint --http-probe=false nginx;

Minimize Docker image size using DockerSlim Build Command

Now that you understand what you need to make your image slimmer, DockerSlim uses a build command to optimize your overall image size. The build command acts as a DockerSlim compression strategy. It gives you the ability to compress your Docker images. To use it, let’s check the created image’s original size:

docker images nginx:latest

From the above, the image size is 135MB.

To optimize the image, run the below build command:

docker-slim build --sensor-ipc-mode proxy --sensor-ipc-endpoint --http-probe=false nginx;

Once the process is done, check the present Docker images, you should see an nginx.slim image:

docker images

Your image should be reduced to around 12.4MB.

This shows that DockerSlim can reduce and compress your image by approximately a 90.37% reduction from the original size.


This guide taught you how to analyze your images using the DockerSlim command. With that, you are able to understand your Docker image anatomy and know why it’s needed to optimize them and reduce the overall Docker image size. DockerSlim is a valuable tool for DevOps teams to optimize containerized workflows, thus helping you reduce infrastructure costs. I hope this helped you learn how to minimize Docker image sizes using DockerSlim.

Joseph is fluent in Fullstack web development and has a lot of passion for DevOps engineering. He loves to write code and document them in blogs to share ideas.


Leave a Comment

Your email address will not be published. Required fields are marked *

Skip to toolbar