Digest #12: How Docker Works - Docker Architecture

In our latest guide, we covered what containers are and demonstrated how to containerize an application using Docker. In this digest, we’ll dive into Docker’s architecture, exploring its key components like the Docker Engine, Images, and Containers and understand how they work together to streamline the process of building, shipping, and running applications in a consistent environment.

What is Docker?

Docker is a tool for creating and managing containers.

At the heart of Docker are two essential components: the Dockerfile and Docker Images.

The Dockerfile is a blueprint that defines each step required to build a Docker Image, from the installation of dependencies to specific environment configurations. Once built, a Docker Image acts as a standalone package, containing everything an application needs code, libraries, system tools, and runtime ensuring consistency across environments.

In simple terms, the Dockerfile builds the Docker Image, and the Image serves as the foundation for launching one or more Docker containers. Let's dive in and explore this further.

---

---

The Docker Architecture

Docker uses a client-server model where the Docker client communicates with the Docker daemon. The daemon does the work of building, running, and managing containers. Both the client and daemon can run on the same machine, or the client can connect to a remote daemon. They communicate through a REST API over UNIX sockets or a network.

The following diagram provides a visual overview of Docker's architecture and illustrates how its components interact

The Docker architecture mainly consists of 3 major components -

1. Docker Client

2. Docker Host

3. Docker Registry

The Docker Client

The Docker Client is the primary interface through which users interact with Docker, available as a command-line tool, API, or graphical interface. It allows users to issue commands, such as docker build and docker run, to manage containers and other Docker resources. The client sends these requests to the Docker daemon, which handles the orchestration and execution of the commands, allowing seamless communication between users and the Docker Host.

The Docker Host

The Docker Host is where the Docker daemon operates, coordinating and managing container lifecycles. Within the Docker Host, containerd—a lightweight container runtime—handles the execution, storage, and lifecycle of containers. containerd is critical for creating and managing containers in a standardized, efficient manner. To communicate with containerd, Docker uses the gRPC protocol, a high-performance, language-agnostic RPC (Remote Procedure Call) framework. This setup ensures seamless and fast communication between the Docker daemon and containerd, allowing smooth container creation, deletion, and management.

The Docker Registry

The Docker Registry serves as a storage repository for Docker images, acting as a central hub for sharing containerized applications. Public registries like Docker Hub provide access to a vast collection of pre-built images, while private registries enable secure storage of custom images. When a user initiates an image pull, the Docker daemon retrieves the image from the registry and stores it locally on the Docker Host. This local caching optimizes performance by allowing quick access to frequently used images without needing to re-download them.

Example: Running docker run nginx

When you run the command docker run nginx, each Docker component works together to complete the task:

1. Docker Client: The docker run nginx command is entered into the Docker Client, which sends a request to the Docker daemon to pull and run an instance of the nginx image.

2. Docker Host: The Docker daemon receives the request. It first checks if the nginx image is available locally on the Docker Host. If not, it connects to a Docker Registry to download the image.

3. Docker Registry: The Docker daemon reaches out to a Docker Registry (such as Docker Hub) to pull the nginx image. Once the image is retrieved, it’s cached locally on the Docker Host, making it available for quicker access if needed in the future.

4. Container Execution: With the nginx image ready, the Docker daemon instructs containerd to create and start a container from the nginx image. containerd then allocates the necessary resources and establishes network connections, running the nginx server as a containerized process.

5. Output: The nginx container begins serving web requests at the specified port, and users can access it by navigating to the container's IP address or mapped host port. The Docker Client can then display logs or further information as requested by the user.

Wrapping Up!

In this digest, we explored Docker's architecture and the role each component plays in containerizing applications. By breaking down the Docker Client, Host, and Registry, we gained insight into how they work together seamlessly to manage containers. Through a practical example with nginx, we saw how Docker simplifies application deployment, making it an essential tool for developers.

---