What are Containers, Images, and Volumes in the Docker Engine

Hanwen Zhang
5 min readJun 8, 2024


Docker provides a consistent, reproducible, and isolated environment for applications, solving many of the problems associated with running software on different systems. In this post, we’ll explore the key components of the Docker ecosystem: Containers, Images, and Volumes.

Why Use Docker?

Docker allows developers to package applications along with their dependencies into a single unit called a container. This container can run on any machine that has the Docker Engine installed, ensuring that the application behaves the same way regardless of the environment.

Consistency: Docker images encapsulate all the necessary components to run an application, ensuring that the exact environment is replicated wherever the image is used.

Reproducibility: Dockerfiles are scripts that define how to build a Docker image, specifying all the dependencies, configurations, and steps required to set up the environment. This ensures that anyone building the image gets the same setup.

Isolation: Applications and their dependencies run in a self-contained unit called a container. This isolation means it doesn’t matter whether the host system is Windows, Mac, or a different version of Linux.

Key Components of Docker

The concept of Docker is to package the app as a container that runs in a VM on top of the docker engine in your machine, which is different and more efficient than running the entire VM in your machine that consumes your RAM, CPU, and storage

  • Dockerfile: a blueprint for building a docker image, contains code to build the Docker image based on the instructions of your Dockerfile that will ultimately run your app as a container
  • Image: a template for creating and running containers — an immutable snapshot contains all the information that our container needs to build a container the same way across all systems
  • Container: a running process of images (the running application) — we package all the applications into a container
  • Volume: store persisting data that are generated and used by containers, so when you add the container again the volumes are already there and everything continues to work as it was, they are independent of the container


Definition: A container is a lightweight, standalone, and executable unit of software that packages up code and all its dependencies.

Purpose: Containers ensure that the application runs consistently regardless of where it is deployed.

Behavior: Containers are isolated from each other and from the host system, but they can interact with each other through defined channels.

Example: Think of a container as a running instance of an application, similar to how an app runs on your phone.


Definition: A Docker image is a blueprint or template for creating containers.

Purpose: Images define the environment, including the application code, libraries, dependencies, and configuration needed to run an application.

Behavior: Images are read-only and consist of multiple layers. Each change to the image creates a new layer.

Example: Think of an image as a recipe for baking a cake, where the container is the actual cake made from the recipe.


Definition: A volume is a storage mechanism that allows data to persist outside the container’s lifecycle.

Purpose: Volumes store data that needs to be retained even if the container stops or is deleted.

Behavior: Volumes can be shared between multiple containers and managed independently of the container’s lifecycle.

Example: Think of a volume as a separate hard drive or USB stick where you save your important files, so they aren’t lost if you replace your computer.

Putting It All Together

Let’s use a car analogy to make these concepts more relatable:

Building the Car:

  • Image: The car manufacturer creates a blueprint (Docker image) with all the necessary details to build a car model.
  • Container: Using the blueprint, the manufacturer assembles and rolls out cars (Docker containers) onto the road.

Using the Car:

  • Container: Each car (container) operates independently, allowing people to drive them, use them for transport, and park them when not in use.

Storing Personal Items:

  • Volume: People store personal items in the car’s trunk (Docker volume), ensuring these items are safe and can be transferred to a new car if the current one is replaced.

Maintaining the Car:

  • If a car needs maintenance or an upgrade, the manufacturer updates the blueprint (Docker image) and assembles a new car (creates a new container from the updated image).

Different Models:

  • The manufacturer might have different blueprints for different car models (different Docker images for different applications). Each model is built according to its specific blueprint but can be customized with additional features (environment variables or configurations).

Fleet Management:

  • A company might manage a fleet of cars (a group of containers), ensuring they all have the necessary equipment (software dependencies) and can be replaced or updated as needed.

Virtual Machine v.s. Docker v.s. Kubernetes

Why use a Virtual Machine? VM is just like a computer system, and we can run multiple OS environments on a single physical machine.

Why use Docker? Docker creates VMs over one single OS environment, so-called the Container.

  • Efficiency: Docker containers are more efficient than traditional virtual machines (VMs) because they share the host OS kernel, reducing overhead and improving performance.
  • Consistency: Docker ensures that applications run the same way on any system, eliminating the “it works on my machine” problem.
  • Scalability: Docker works seamlessly with orchestration tools like Kubernetes, which manage and scale multiple containers in a cluster.

Why use Kubernetes? Kubernetes creates multiple Containers and gathers them in a cluster.



Hanwen Zhang

Full-Stack Software Engineer at a Healthcare Tech Company | Document My Coding Journey | Improve My Knowledge | Share Coding Concepts in a Simple Way