List of Dependent Child Images in Docker

This article explores how to get a list of dependent child images in Docker, a skill that can greatly enhance your ability to manage and troubleshoot Docker containers effectively.

1. Introduction

Docker, with its containerization technology, has become a cornerstone of modern software development. It allows developers to package applications and their dependencies into lightweight containers, ensuring consistent execution across diverse environments. As your Docker projects grow, you’ll often encounter situations where multiple containers are interconnected, forming a complex web of dependencies.

To maintain and troubleshoot such systems effectively, you need to have a clear understanding of how these containers are related. This article focuses on a common challenge: discovering dependent child images within your Docker environment. We’ll dive into the Docker image hierarchy, explore the intricacies of parent and child images, and then proceed to demonstrate methods for identifying and listing dependent child images.

2. Prerequisites

2.1 Docker Installation

Before we delve into the intricacies of Docker image dependencies, ensure you have Docker installed on your system. If you haven’t already, follow the official installation guide for your specific platform:


# Linux installation
curl -fsSL -o
sudo sh



2.2 Docker Compose (Optional)

While not strictly necessary for understanding Docker image dependencies, Docker Compose is a powerful tool for managing multi-container applications. It allows you to define and run multi-container Docker applications using a YAML file.

If you’re interested in exploring Docker Compose, you can install it by following the instructions in the official Docker Compose documentation.

3. Understanding Docker Images and Layers

3.1 Docker Images

Docker images are the building blocks of containers. They are like blueprints that define what a container should contain and how it should behave. When you run a Docker container, you’re essentially creating an instance of a Docker image.

Each Docker image is composed of multiple layers. These layers are read-only and are stacked on top of each other. When you make changes to a running container, those changes are stored in a new layer, which is writable. Understanding this layered approach is essential for comprehending image dependencies.

3.2 Image Layers

Let’s take a closer look at Docker image layers. Layers are a fundamental concept in Docker and play a critical role in how Docker operates. When you build a Docker image, it consists of a series of read-only layers, stacked on top of each other. Here’s why this is important:

  • Efficiency: Reusing layers from existing images improves build and deployment times. If two images share many layers, they occupy less space on disk.
  • Caching: Docker caches layers to optimize builds. If a layer hasn’t changed, Docker can reuse it from cache, saving time and bandwidth.

Layers are identified by unique hashes based on their contents. This means that even if you change a single byte in a file within a layer, Docker will consider it a new layer.

Understanding this layering system is crucial when dealing with dependent child images, as we’ll see later in this article.

4. Docker Image Hierarchies

4.1 Parent and Child Images

In Docker, images can have parent-child relationships. This concept is crucial to comprehend when dealing with image dependencies. A parent image is an image on which another image is based. The image that is built on top of a parent image is known as the child image.

Child images inherit everything from their parent images, including the layers, configurations, and environment variables. This inheritance makes it easy to reuse common configurations across multiple images.

Let’s illustrate this concept with a practical example. Suppose you have a web application running in a Docker container, and this container uses an image based on the popular Nginx web server. The Nginx image becomes the parent image, and your application image is the child image. This child image inherits Nginx’s configuration and layers, allowing you to build and run your web application within the Nginx environment. This relationship forms a hierarchy.

4.2 Use Cases for Analyzing Dependencies

Understanding parent-child relationships between Docker images is essential for various use cases:


When troubleshooting issues in a Dockerized application, knowing which images depend on each other can significantly simplify the debugging process. You can trace the problem back to its source by identifying the child image responsible for a particular container.

Security Audits

Security is a top concern when working with containers. By knowing the dependencies between images, you can assess the security risks associated with each image in your Docker ecosystem. For example, if a vulnerable library is present in a parent image, all child images built on top of it may inherit the same vulnerability.

Optimizing Image Sizes

Efficient image management is essential for minimizing resource consumption and speeding up deployments. Identifying unnecessary layers and dependencies can help reduce the size of Docker images, leading to faster container startup times and less disk space usage.

5. Docker Legacy Builder

Docker Legacy Builder, also known as the “docker” CLI, is the traditional way to build Docker images. To get the list of dependent child images using this method, we need to rely on third-party tools like docker history and docker images.

5.1 Build a Docker Image

Let’s start by creating a simple Docker image. Create a directory for your Docker project and add a simple Dockerfile like this:

# Dockerfile
FROM alpine:latest
RUN echo "Hello, Docker!"

A Dockerfile is a text-based configuration file used to define the specifications and instructions for creating a Docker image. It serves as a blueprint for building containerized applications, encapsulating everything from the base image selection to the installation of dependencies, application code, and runtime settings. Dockerfiles allow developers to automate and standardize the process of creating Docker images, ensuring consistency and reproducibility across different environments. By specifying each step in the Dockerfile, developers can easily package their applications and dependencies into a portable, self-contained unit known as a Docker image, which can be run consistently on any system with Docker installed.

Now, build the Docker image using the following command:

docker build -t my-docker-image .
Fig. 1: Build a Docker Image.
Fig. 1: Build a Docker Image.

5.2 List Dependent Child Images

To list the dependent child images, you can use the docker history command. This command will display the history of an image, including the layers and their sizes. By analyzing the history, you can identify child images.

docker history my-docker-image

The output will include a list of layers. Each layer represents a change to the filesystem, and child images will have additional layers built upon the parent image’s layers.

Example Output

Fig. 2: List Dependent Child Images.
Fig. 2: List Dependent Child Images.

In the output above, the second layer is the child image’s layer, alpine:latest

6. Docker BuildKit

Docker BuildKit is a modern build subsystem for Docker that provides enhanced functionality, including improved build performance and additional features. To get the list of dependent child images using Docker BuildKit, we can utilize the BUILDKIT_INLINE_CACHE=1 environment variable along with docker build.

6.1 Enable BuildKit

Before building your Docker image with BuildKit, ensure that it is enabled. You can enable it by setting the DOCKER_BUILDKIT=1 environment variable:


6.2 Build a Docker Image

Now, let’s create another Docker image using Docker BuildKit. Create a new directory for this example and add a Dockerfile like this:

# Dockerfile
# syntax=docker/dockerfile:1.2
FROM alpine:latest
RUN echo "Hello, Docker BuildKit!"

Build the Docker image using the following command:

docker build --build-arg BUILDKIT_INLINE_CACHE=1 -t my-docker-image-buildkit .
Fig. 3: Build a Docker Image using BuildKit.
Fig. 3: Build a Docker Image using BuildKit.

6.3 List Dependent Child Images

To list dependent child images with Docker BuildKit, we can use the docker images command along with the --filter flag to filter images by their parent image.

docker images --all --filter since=alpine

This command will display a list of images that were created after the specified image (alpine), indicating the child images.

Example Output

Fig. 4: Using docker images command.
Fig. 4: Using docker images command.

7. Conclusion

Understanding the relationships between parent and child images in Docker is crucial for managing and optimizing your containerized applications. In this article, we explored two methods to get the list of dependent child images in Docker: using Docker Legacy Builder and Docker BuildKit. We used practical examples and step-by-step explanations to help beginners grasp these concepts.

Odysseas Mourtzoukos

Mourtzoukos Odysseas is studying to become a software engineer, at Harokopio University of Athens. Along with his studies, he is getting involved with different projects on gaming development and web applications. He is looking forward to sharing his knowledge and experience with the world.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button