In this blog we will dive deep into dockers architecture.

Docker installation:

Docker follows a client–server architecture, where the Docker client communicates with the Docker daemon to build, run, and manage containers.

Since Docker is native to Linux, it can be installed and run on any Linux-based operating system using the following command:

yum install docker -y 
docker --version //Check docker version 

Docker Architecture:

When Docker is installed, it sets up the complete Docker architecture along with its core components, including the Docker client, Docker daemon, Docker CLI, the Docker socket (docker.sock), and access to a Docker registry.

Installing Docker is fine. Have you ever tried building an image or running a container using Docker?

What actually happens behind the scenes when you execute a Docker command?

Let’s explore how these components interact to make containerization possible.

docker run -t image

We can see the below output:

Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?

To manage the Docker daemon, we need to start or stop the Docker service using the following command:

systemctl start docker //To start docker 
systemctl stop docker //To stop docker

Even when the Docker daemon is in an inactive state, the Docker socket (docker.sock) remains available. It serves as the communication bridge between the Docker client and the Docker daemon.

Whenever a user performs an action using the Docker client, the Docker CLI sends a REST API request through the Docker socket. This request is received by the Docker daemon, which is then activated to process the command, such as building an image, starting a container, or managing resources.

This socket-based communication model is a key part of Docker’s client–server architecture, enabling efficient and seamless interaction between the client and the daemon.

A Docker Registry serves as the centralized storage and distribution system for Docker images. It enables teams to store, version, share, and retrieve container images in a reliable and scalable manner.

When a user issues a docker pull or docker push command using the Docker client, the request is first sent to the Docker daemon. The Docker daemon then handles all communication with the Docker Registry, performing the actual image upload or download operation.

If the requested image is not available locally, the Docker daemon pulls it from the registry. Similarly, when an image is built locally and needs to be shared or deployed across environments, the Docker daemon pushes it to the registry.

What's next in the series:

• How to write docker file?

• How docker turns your code into image?

• How to build docker images and containers?

What is Docker?

Docker is a containerization tool. The name itself indicates that it is used to build containers. It is an open-source, centralized platform designed to create, deploy, and run applications across multiple environments. Docker is written in the Go programming language.

The key advantage of Docker is that it uses the host operating system to run applications. This means it allows applications to use the same Linux kernel as the host system, rather than creating an entire virtual operating system for each application.

Docker can be installed on multiple operating systems; however, the Docker Engine runs natively on Linux distributions. Docker performs OS-level virtualization, which enables lightweight, fast, and efficient application deployment.

Why was docker introduced?

For years, software delivery had one invisible enemy — the environment.

Before Docker was introduced, many teams faced a common problem: the same code that ran successfully on a developer’s system failed during testing and behaved unpredictably in production. These issues were difficult to debug and often took hours or even days to resolve. As a result, code deployments to production were delayed, and developers and operations teams frequently blamed each other while trying to identify the root cause.

Virtual Machines provided a partial solution, but they rely on hardware-level virtualization. Each virtual machine requires a complete operating system, which consumes significant hardware resources such as RAM and CPU. This approach lacked efficiency and resulted in long startup times.

This all changed with Docker. Since Docker uses OS-level virtualization, it ensures consistency across all environments while offering better scalability and higher efficiency.

What exactly did docker change to resolve issue between developers and operations team?

Docker introduced images and containers to run applications consistently across multiple environments.

A Docker image is a read-only template that contains a set of instructions used to create a container that can run on the Docker platform.

A Docker container is a lightweight, standalone, and executable software package that encapsulates an application along with all its required dependencies, such as libraries and runtime environments. Containers created from a Docker image can run on any machine that has Docker installed, ensuring consistency and portability across environments.

Docker Registry is a repository for storing and sharing the docker images. In registry we can store our images in public or private.

Conclusion:

Docker addressed one of the most persistent challenges in software delivery—environment inconsistency—by introducing a standardized way to package and run applications using containers. Through Docker images, containers, and registries, applications can be built once and executed reliably across development, testing, and production environments. By eliminating dependency conflicts and reducing infrastructure overhead, Docker streamlined collaboration between development and operations teams, reduced deployment delays, and improved delivery efficiency. Today, Docker stands as a foundational technology in modern DevOps, enabling scalable, portable, and reliable software delivery across the software industry.

What’s Next in This Series?

Upcoming blogs:

• Docker Architecture Explained

• Docker Images vs Containers

• Dockerfile Explained Line by Line