Docker Logo

Keep it small: a closer look at Docker image sizing

A recent blog post, 10 things to avoid in docker containers, describes ten scenarios you should avoid when dealing with docker containers. However, recommendation #3 – Don’t create large images and the sentence “Don’t install unnecessary packages or run “updates” (yum update) that download files to a new image layer” has generated quite a few questions.  Some of you are wondering how a simple “yum update” can create a large image. In an attempt to clarify the point, this post explains how docker images work, some solutions to maintain a small docker image, yet still keep it up to date.

To better illustrate the problem, let’s start with a fresh Fedora 23 (or RHEL) image. (Use `docker pull fedora:23`). 

Once complete, running The `docker images`, command reveals an image size of 204.7 MB. We’ll now create a custom image that contains JDK 1.8 and WildFly 9.0.2.Final, using the following Dockerfile (downloads from GitHub).

Building this image results in a final size of 567.3 MB, and we can perform a “docker history <image name>” to see the size of its layers. Doing so demonstrates that JDK 1.8 has added 203.5 MB, and WildFly has added 159.1 MB to the total image size – that’s already a lot of space!


Further still, you’ll eventually need to create a WildFly 10.0.0.Final image. If you don’t want to install JDK 1.8 again, you might feel tempted to reuse the existing image by replacing WildFly 9.0.2.Final with 10.0.0.Final. In doing so, you’d likely expect that this new image will have almost the same size of 567 MB, but the resulting image size will actually increase to 728.1 MB. The image will have grown by 160 MB even if you remove WildFly 9.0.2.Final before adding WildFly 10.0.0.Final in the docker image. The difference in size is not due to the differences between WildFly versions.

Copy on Write

In order to understand this behavior, we need to understand that the Docker container file-system uses a Copy-on-Write technique technique that improves container startup time (incredibly fast!) when we compare containers to ordinary Virtual Machines. Though this technique contributes in several ways to make docker containers efficient, it can result in extra disk usage; thus, docker image authors need to consider several things to avoid creating large images.

To explain: Every RUN instruction in the Dockerfile writes a new layer in the image. Every layer requires extra space on disk; therefore, when we “uprgade” WildFly, we are in fact creating a new layer. In order to keep the number layers to a minimum, any file manipulation like moving, extracting, removing, etc, should ideally be made under a single RUN instruction.

The following line, for example, installs WildFly 10.0.0.Final in the container, and the download, extraction, move, and cleanup commands are made on a single line. This results in a final size of 569.1 MB:  

"cd /tmp && curl -O$WILDFLY_VERSION/wildfly-$WILDFLY_VERSION.tar.gz && tar xf wildfly-$WILDFLY_VERSION.tar.gz  && mv /tmp/wildfly-$WILDFLY_VERSION /opt/jboss/wildfly && rm /tmp/wildfly-$WILDFLY_VERSION.tar.gz"

In comparison, if each one of these commands were executed in a separate RUN instruction, the image will have 4 more layers, and have a final size of 867.1 MB. The command “docker history” allows you to easily visualise the layers and its size according to the following image:


Yum Update

But what about the use of “yum update”? To better illustrate the answer to this question I prepared two images: fedora:22, and fedora:23. These two customized images have the same `RUN dnf -y update` instruction in their respective Dockerfiles, yet the result is that that fedora:22 has a size of 531.2 MB, while the newer fedora:23 has a size of 358.2 MB.

Fedora:22 is larger because it had to download many more files to become “up to date” with Fedora:23. Thus, this example demonstrates that running latest versions of existing platforms (e.g. Fedora 23 instead of 22) can not only speed up image creation, but also save space by preventing additional files to be written to an intermediate layer.

We should NOT forget that “updates” trigger many file changes as it downloads new rpm packages and installs them. As explained before, we can’t change the previous image layers, but we can at least get rid of the rpm cache in a single RUN command. With a small modification to “RUN dnf -y update && dnf clean all”, the image is reduced from 358.2 MB to 216.2 MB (just 11.5 MB larger than the original fedora:23 image). So if you need to do an update, keep in mind that you should also clean up afterwards to free as much space as possible.



In conclusion, the problem is not running “yum/dnf update” in your image, and a basic understanding of docker’s layered file-system can make a big difference in the size of your image. Large images become an issue when thousands of containers need to be deployed across a cluster, but avoiding “updates” in your linux containers can lead to bugs and security vulnerabilities.

The solution is perform updates and cleanups in a single RUN instruction, which both updates the image, and frees space (resulting in a smaller image) at the same time.

Rafael Benevides

About the author:

Rafael Benevides is a Director of Developer Experience at Red Hat. In his current role he helps developers worldwide to be more effective in software development, and he also promotes tools and practices that help them to be more productive. He worked in several fields including application architecture and design. Besides that, he is a member of Apache DeltaSpike PMC – a Duke’s Choice Award winner project. And a speaker in conferences like JUDCon, TDC, JavaOne and Devoxx. Twitter | LinkedIn |

For more information about containers, visit and register at

Join Red Hat Developers, a developer program for you to learn, share, and code faster – and get access to Red Hat software for your development.  The developer program and software are both free!


  1. Nice post, say if user runs DB as container or storage as container and on each modification of data leads to increase the number of layers and as result will it have any impact on container performance


    1. For containers that need data persistence, mounting a persistent store to the container for storing data would be a better practice. The containers would only run as a service/daemon and won’t persist any meaningful data in the container.


  2. Nice post, if users create DB as containers or storage as containers and due to data modifications of data (DB or storage) has any impact on container performance


  3. I am curious about where the Atomic App component of Project Atomic fits. When is it better to use Atomic App (fedora, centos, or redhat) vs following the above approach?


    1. Hi Massimo.

      Yes. $ docker history also works in GCE for its image. For Kubernetes deployments you can check it trough $ kubectl rollout history deployment. Was that your question?

      Thanks for your comments.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s