How to optimize Docker image with layer caching

Optimizing things is important part of development process. Even when we are living in the world of fast Internet connections, we still don't want to spend few seconds watching white screen and waiting for website content. And it is just a few seconds! Not that far ago we had to wait much more time, but now everything must be accessible immediately. Let's take a look on Docker image building optimization this time.

If anyone here do not know what Docker is, I will explain it in other article... or you can simply go to official site.

In Docker there is something called 'layer caching'. Each line in Dockerfile generates its own layer during building process. The layers are cached and reused between different building processes if no changes are detected. Let's take a look on this simple Dockerfile I just created for very simple ExpressJS project created from this tutorial:

This Dockerfile takes node image and make some simple changes. Copies index.js, packages.json and than runs npm install to download all necessary packages. CMD will run this application on container start.

As we agreed before, every line creates own cached layer. Let's try to build this Docker image and see what is happening.

Docker image from this Dockerfile was built completely from scratch now, so it took 1 minute to build. Of course, when we have node image on disk it takes about 4 seconds to build rest of the image. Let's try to build again now.

A lot less line of scripts, huh? As you can see, there is 'Using cache' text in multiple lines and whole process took less than 1s. This is the power of layer caching. Nothing here was built from scratch, every layer comes from cache.

But let's make some changes in index.js and build image again.

Oh oh... what just happened? Starting from 'Step 3/6: COPY index.js .' line - everyting was built without cache. This is expected Docker behaviour! If any layer must be created from scratch because of some change in source files - every next layer is built from scratch too. Can we optimize this process? Sure! And it is very simple - put less frequently changing steps on top of Dockerfile (let them be executed as soon as possible), and frequently changing steps on bottom (end of building process). In this particular case, index.js file (or any file with code) will change probably more often than package.json, so let's make a simple change in Dockerfile:

Now let's build our image, than make some change in index.js, and build image again. That's a result:

Et voila! Only 5th and 6th step is built from scratch - and it takes a lot less time than running npm install command, etc. I know, I know - results are not that spectacular, as you probably expected, because we are saving only few seconds here, but imagine that you have a lot bigger project with hundreds or thousands of files. Optimizing processes like building Docker images in your deployment or development workflow saves you a lot of time, resources and - obviously - money, so keep it in mind next time when you will be creating new Dockerfiles in your project.

GitHub repo: https://github.com/codetain/docker-caching