You are currently viewing What are Docker Layers: Everything You Need to Know

What are Docker Layers: Everything You Need to Know

If you use docker on your device, you must have heard about docker layers. You might want to know more about it and how it works. Because understanding its work will help you to understand docker better and also helps you solve issues related to docker layers. So with this guide, docker layers explained in detail to clear your doubts and help you know all the essential concepts about it. As this is a part of our Docker consulting service, so through this blog to get the best knowledge about docker layers.

Docker is a powerful tool for containerization, and at the heart of Docker’s efficiency and flexibility are its layers. Understanding Docker layers is essential for managing and optimizing container images effectively. In this guide, we’ll demystify Docker layers and their role in containerization.

What Are Docker Layers?

Docker layers are the primary components that serve as the building blocks for developing, deploying, and scaling applications. They are the individual parts that, when stacked on top of each other, make up the final image. Each layer represents a specific set of changes or instructions in your Dockerfile, such as adding files, installing software, or configuring settings. 

Using this technique, inefficiencies in software development relating to application dependency management, versioning difficulties, and long-term maintenance activities are dramatically reduced. In general, pictures and image layers contribute to the simplification of IT operations and the increased agility of development teams.

Docker layers help make your container images efficient and easy to manage. They also enable faster image builds and optimize the use of system resources. Understanding Docker layers is essential for creating lean and effective container images.

How Docker Layers Work?

Imagine you’re building a sandcastle on the beach. Each layer of sand represents an action you take. You start with the base layer (your base image), and then you add more layers as you shape your castle. Each bucket of sand you add is like a new instruction in your Dockerfile, creating a new layer.

  • Base Image Layer: Every Docker image starts with a base image. This is like the most important base of a building. It provides the essential components, like the operating system, to your container. The base image is read-only and serves as the starting point for your container.
  • Intermediate Layers: When you create a Docker image, each instruction in your Dockerfile adds a new layer. These layers are like the construction steps in building a house. Each layer represents a change or an addition. For example, if you’re installing software or copying files, each of these actions results in a new layer. These layers are also read-only, and Docker stores them efficiently.
  • Final Writable Layer: At the top of the layer stack is the final writable layer. This layer is unique to your container and allows you to make changes during the container’s runtime. It’s like the top floor of a building where you live and can rearrange your furniture (or container) as you please. This layer is writable, and any changes made during the container’s operation are stored here.

Read more: Our Blog Post On docker restart policy

Benefits of using Docker layers

Docker layers are very beneficial and important for your container as they provide following benefits:

Efficient Use of Resources: Docker layers allow for efficient use of storage space. Common base images are shared among multiple containers, reducing redundancy. This means you don’t need to store the same data multiple times, saving disk space.

Faster Builds: Docker can cache and reuse layers. When you make changes to your container image, only the affected layers need to be rebuilt. Unchanged layers are retrieved from the cache, resulting in faster image building. The process of development and deployment is sped up significantly as an outcome of this.

Version Control: Docker layers enable version control for container images. When you update an image, only the changed layers need to be downloaded or transmitted. This reduces bandwidth usage and speeds up the distribution of updated images.

Improved Security: Docker layers provide isolation and protection. Each layer is isolated from the others, which enhances security. Changes made in one layer do not affect the integrity of other layers. This isolation minimizes conflicts and ensures that vulnerabilities or issues in one layer don’t impact the entire image.

Granular Updates: With Docker layers, you can make granular updates to your container images. If you only need to change a small part of your application, you can focus on updating the specific layers affected, rather than rebuilding the entire image. This saves time and resources.

Optimized Caching: Docker’s build system optimally caches layers. This means that even if you change the order of commands in your Dockerfile, Docker can use cached layers when the same commands were run previously. This makes your Docker build process smarter and more efficient.

Simplified Maintenance: Managing and maintaining container images becomes more manageable with Docker layers. If an issue or vulnerability is discovered in a particular layer, you can address it without affecting the rest of the image. This separation simplifies the maintenance process.

Docker Image Layers Mutability

You have the ability to change the composition of a Docker image since it is mutable. However, the changes you mentioned rely on the image layer. Docker constructs the image by incorporating the most recent changes made to the layer.

When you make changes to a Docker image layer, Docker will rebuild that specific layer and all other layers that depend on it. It’s a good idea to place the layers with the fewest or no changes at the bottom of the hierarchy.

If you were to reconstruct the images above without making any alterations, each layer could be constructed using the cache. Docker has the ability to detect any modifications. Imagine a scenario where you have made a modification to your Dockerfile. To add a new package to the existing application, you need to explicitly include it in the package.json file. If there are any new changes, running “COPY package*.json ./” will be triggered in this case. To incorporate the new changes, you’ll need to rebuild the relevant image layer using Docker.

However, it’s important to mention that according to the image hierarchy, there is a layer below. The command “COPY package*.json ./” will be executed from the cache because there are no changes detected to the package.json files. When you use the command “COPY package*.json ./”, any new changes will cause all the layers above to be rebuilt. I have an example of a typical image rebuild that I’d like to share with you.

Docker Image Layers Mutability-1

If, for example, you added new code to the application, the same thing should happen. When this happens, the changes will be rebuilt from COPY././ up:

Docker Image Layers Mutability-2

Where are the layers found?

In order to explore the contents of each layer of the image, you will need to view the layers on the Docker host at:


At the moment, when using Docker on OSX, the Docker host is a linux virtual machine known as a docker machine. If you’re using OSX, you can access the docker-machine by using the SSH command. This will allow you to view the aufs directory:

Where are the layers found

The directory /var/lib/docker/aufs contains three other directories: diff, layers, and mnt.

  • The diff directory is where the contents of image layers are stored.
  • The way image layers are stacked can be found in the layers directory.
  • Containers that are currently running are mounted under the “mnt” directory.

To understand how the layers work better, it’s interesting to talk about the AUFS file driver. If you’re not familiar with this, here are a few important words that it would be helpful to know:

  • Union Mount is a method of merging multiple directories into a single directory that appears to have the content from all of them.
  • AUFS is short for Another Union Filesystem or Advanced Multi-Layered Unification Filesystem, which was introduced in version 2. AUFS is a tool that allows Linux file systems to be combined using a union mount.
  • The AUFS storage driver in Docker uses the union mount system to handle image layers.
  • AUFS Branches- Each layer of a Docker image is referred to as an AUFS branch.

Union filesystems are really amazing because they combine all the files from different image layers and make them appear as a single directory that you can only read from at the Union mount point. When there are copies of files in different layers, the file on the top layer is the one that is shown or displayed.

Docker Layers Explained

Images are composed of layers. Every layer represents the changes made to the image since the previous one was added. When you’re building an image, the platform will create a new layer for each instruction in the file. The container begins executing instructions from the first one in the file, and it continues to do so in the order they are written. The initial instruction could involve installing packages, while subsequent instructions may involve tasks like copying files or creating directories. 


The imagedb is a database specifically designed to store information about Docker layers and their relationships. It keeps track of how one layer depends on another, providing valuable insights into the structure and dependencies of Docker images. The Docker daemon keeps the imagedb. The daemon is a process that runs on the host machine and is responsible for managing containers. When you run a container, the platform relies on this database to fetch details about each layer.


The layerdb is a database that stores information about how different layers are related to each other. It also includes instructions on how to build layers. The database is kept in the daemon. When you run a container using an image, the Docker daemon utilises both the imagedb and layerdb to initiate the container.


Caches are used to make the process of building an image faster. The “layer cache database” is where all the files that make up each layer are stored. Every file in this database has a corresponding hash value and a row associated with it. Every Docker layer also corresponds to a row in the cache database.

Check Out: Our blog post on how to install docker on mac

The Writeable Layer

The final layer in Docker is the layer that can be modified. This is the only thing that a client can modify. There is a row in the cache database for this special layer.

The writeable layer is where developers can make changes to an image by adding or removing files. Developers can modify an image once it has been created with files known as “writeable layers.” The daemon’s cache database also stores the writeable layers, but each of them has a distinct row in the database.


Docker layers make your container images efficient and manageable. They help reduce duplication, save space, and speed up image builds. Understanding how they work and following these beachfront (best) practices will help you build Docker containers that are lightweight, efficient, and ready to conquer the container world.

Docker layers are a fundamental concept that plays a crucial role in making containerization efficient, resource-friendly, and scalable. They are a key reason why Docker has become a popular choice for packaging and deploying applications in a consistent and reliable manner.

In this blog, we have discussed what are docker layers and its benefits. We hope that this blog has helped you to get a clear idea about the topic and you might have gained more knowledge. If you like this blog and want to read more about docker, its commands and how to fix different docker issues, you can read our articles as we’ve covered all the topics.

Related Articles