Skip to main content

Understanding Docker Architecture and Components

Introduction​

Now that you know what Docker is and how to install it, it's time to dive deeper into how Docker works behind the scenes. Understanding Docker's architecture and its core components is essential for working efficiently with containers, troubleshooting issues, and designing scalable, maintainable systems.

In this lesson, you'll learn about:

  • The fundamental architecture of Docker
  • Key components: Docker Daemon, CLI, Images, Containers, Registries, and more
  • How these pieces interact in real-world scenarios
  • Common pitfalls and best practices

Docker Architecture Overview​

At a high level, Docker uses a client-server architecture. This separation of concerns makes Docker powerful, scalable, and flexible.

Docker Architecture Diagram

Main components:

  • Docker Daemon (dockerd)
  • Docker Client (docker CLI)
  • Docker REST API
  • Docker Images
  • Docker Containers
  • Docker Registries

Docker Daemon (dockerd)​

The Docker Daemon is the heart of Docker. It's a background process running on your system that manages containers, images, networks, and storage. The daemon listens for Docker API requests and acts on them.

  • Runs as a system service: e.g., systemctl status docker
  • Responsible for: Building, running, and managing containers

Example: Checking if Docker Daemon is running

sudo systemctl status docker

Common Pitfall:
If the Docker daemon is not running, all docker commands will fail with connection errors.

Docker Client (docker CLI)​

The Docker Client is the command-line interface you interact with. When you run commands like docker run or docker build, you're using the Docker Client.

  • Communicates with the daemon: Via REST API (usually over a Unix socket or TCP)
  • Stateless: Sends your commands to the daemon and displays results

Example: Running a container

docker run hello-world

Docker REST API​

The Docker REST API is the interface through which the Docker Client and other tools talk to the Docker Daemon.

  • Enables programmatic access: You can control Docker from your own code
  • Accessible via Unix socket or TCP port

Example: Curling Docker's API

curl --unix-socket /var/run/docker.sock http://localhost/_ping
# Should return "OK"

Docker Images​

A Docker Image is a read-only template with instructions for creating a container. Images are built in layers, making them efficient and easy to share.

  • Immutable: Once built, doesn't change
  • Composed of layers: Each layer represents a set of file changes or instructions

Example: Listing local images

docker images

Use case:
You might use the official nginx image to quickly deploy a web server.

Docker Containers​

A Docker Container is a running instance of a Docker Image. Containers are lightweight, portable, and isolated from each other and the host system.

  • Ephemeral by default: Changes inside a running container do not persist unless you use volumes
  • Isolated: Each container has its own filesystem, network namespace, and resources

Example: Starting a container

docker run -d -p 8080:80 nginx

Docker Registries​

A Docker Registry is a storage and distribution system for Docker images. The most well-known registry is Docker Hub.

  • Public or private: Organizations may run their own registries
  • Push/Pull images: Developers share and retrieve images

Example: Pulling an image from Docker Hub

docker pull python:3.11-slim

Common Pitfall:
If you're not logged in or lack permissions for a private registry, docker pull or docker push will fail.

Supporting Components​

Storage Drivers​

Docker uses storage drivers to manage the filesystem for images and containers. Common drivers include overlay2 (default on modern Linux), aufs, and btrfs.

Network Drivers​

Docker provides networking drivers like bridge, host, overlay, and macvlan to manage container connectivity.

How Components Interact: A Typical Workflow​

  1. You run a command using the Docker CLI (docker run nginx).
  2. Docker CLI sends the request to the Docker Daemon via the REST API.
  3. Docker Daemon checks if the nginx image exists locally. If not, it pulls it from a registry (e.g., Docker Hub).
  4. Docker Daemon creates a container from the image and starts it.
  5. Docker Daemon manages the container's lifecycle (start, stop, delete).

Use Case Example: Deploying a Web App​

Suppose you want to deploy a web application in a container:

  1. Build an image from your code using a Dockerfile.
  2. Push the image to a registry (e.g., Docker Hub or a private registry).
  3. Pull the image on a production host.
  4. Run the container using the Docker CLI or via an API call.
  5. Manage the container's networking, storage, and lifecycle through Docker.

Common Mistakes & Pitfalls​

  • Docker Daemon not running: All commands fail; always check with systemctl status docker.
  • Confusing images and containers: Remember, an image is a template; a container is a running instance.
  • Editing a running container: Changes are lost when the container stops unless you commit the container as a new image or use volumes.
  • Network misunderstandings: Not realizing containers are isolated by default; must publish ports or use networks for communication.
  • Registry permissions: Failing to log in or trying to push to a registry without permission.

Summary​

  • Docker uses a client-server architecture with a daemon managing containers and images.
  • Docker Client interacts with the Docker Daemon via a REST API.
  • Images are templates; containers are running instances.
  • Registries store and distribute images.
  • Understanding these components and their roles is key to effective Docker usage.

Quiz​

  1. What is the role of the Docker Daemon (dockerd)?

    • A) It provides a web interface for Docker
    • B) It manages containers, images, networks, and storage
    • C) It is used to write Dockerfiles
    • Answer: B

  2. True or False: A Docker image is a running instance of a container.

    • Answer: False. An image is a template; a container is a running instance.

  3. Which command would you use to list all the Docker images on your system?

    • Answer: docker images

  4. What happens if you run docker run nginx and the image is not found locally?

    • Answer: Docker will pull the nginx image from the default registry (Docker Hub).

  5. Name two ways the Docker Client can communicate with the Docker Daemon.

    • Answer: Via a Unix socket (e.g., /var/run/docker.sock) or via a TCP port.

Continue to the next lesson: Working with Docker Images.