Docker architecture (client, daemon, registry) - Step-by-Step Execution

Process Flow - Docker architecture (client, daemon, registry)

User runs Docker Client

↓

Docker Client sends commands

↓

Docker Daemon receives commands

↓

Daemon builds, runs containers

↓

Daemon pulls/pushes images

↓

Docker Registry stores images

User uses Docker Client to send commands to Docker Daemon, which manages containers and interacts with Docker Registry to store or retrieve images.

Execution Sample

Docker

docker pull nginx
# Client sends pull command
# Daemon contacts Registry
# Image downloaded locally

Shows how Docker Client requests an image pull, Daemon fetches it from Registry, and stores it locally.

Process Table

Step	Component	Action	Result	Next Step
1	User	Runs 'docker pull nginx'	Command sent to Docker Client	Docker Client sends command to Daemon
2	Docker Client	Receives user command	Sends API request to Docker Daemon	Docker Daemon processes request
3	Docker Daemon	Receives pull request	Contacts Docker Registry for 'nginx' image	Registry responds with image data
4	Docker Registry	Receives request	Sends image layers to Daemon	Daemon downloads image layers
5	Docker Daemon	Downloads image layers	Stores image locally	Pull complete, ready to run container
6	Docker Client	Notifies user	'nginx' image pulled successfully	User can run container now

💡 Image 'nginx' fully downloaded and stored locally; pull command completed

Status Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
Command	None	'docker pull nginx'	'docker pull nginx' sent	'nginx' image layers downloading	'nginx' image stored locally
Image Local Storage	Empty	Empty	Empty	Partial layers stored	Complete 'nginx' image stored

Key Moments - 3 Insights

Why does the Docker Client not download the image directly?

Docker Client only sends commands; the Docker Daemon handles downloading and storing images, as shown in steps 2 and 3 of the execution table.

What role does the Docker Registry play in the pull process?

The Registry stores images and sends image data to the Daemon when requested, as seen in step 4 where the Registry sends image layers.

When is the image available locally to run containers?

After the Daemon downloads and stores all image layers locally, shown in step 5, the image is ready to use.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the Docker Daemon contact the Registry?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Check the 'Action' column for when the Daemon contacts the Registry (Step 3).

According to the variable tracker, what is the state of 'Image Local Storage' after Step 4?

A Empty

B Complete 'nginx' image stored

C Partial layers stored

D 'docker pull nginx' sent

💡 Hint

Look at the 'Image Local Storage' row under 'After Step 4' in the variable tracker.

If the Docker Client failed to send the command, which step would not occur?

A Step 1

B Step 2

C Step 3

D Step 6

💡 Hint

Step 2 depends on the Client sending the command; if it fails, Daemon never receives it.

Concept Snapshot

Docker architecture has three main parts:
- Docker Client: User interface sending commands
- Docker Daemon: Background service managing containers and images
- Docker Registry: Remote storage for images
Client sends commands to Daemon, which pulls/pushes images from/to Registry and runs containers.

Full Transcript

Docker architecture consists of three parts: the Client, Daemon, and Registry. The user runs commands on the Docker Client, which sends these commands to the Docker Daemon. The Daemon manages container lifecycle and image storage. When pulling an image, the Daemon contacts the Docker Registry to download image layers and stores them locally. Once the image is fully downloaded, the user can run containers from it. This flow separates user commands from container management and image storage, making Docker efficient and modular.

Practice

1. Which component of Docker architecture is responsible for sending commands to manage containers?

easy

A. Docker Registry

B. Docker Daemon

C. Docker Client

D. Docker Image

Solution

1. Step 1: Understand the role of Docker Client

   The Docker Client is the tool users interact with to send commands like docker run or docker build.

2. Step 2: Differentiate from Daemon and Registry

   The Daemon executes commands, and the Registry stores images, but only the Client sends commands.

3. Final Answer:

   Docker Client -> Option C

4. Quick Check:

   Client sends commands = C [OK]

Hint: Client sends commands, Daemon does work, Registry stores images [OK]

Common Mistakes:

• Confusing Daemon with Client
• Thinking Registry sends commands
• Mixing up Image with Client

2. Which of the following commands correctly starts the Docker daemon on a Linux system?

easy

A. systemctl start docker

B. service docker-client start

C. docker daemon run

D. docker start daemon

Solution

1. Step 1: Identify the correct system command to start Docker daemon

   On Linux, the Docker daemon is managed by systemd and started with systemctl start docker.

2. Step 2: Eliminate incorrect commands

   docker start daemon and docker daemon run are invalid Docker commands. service docker-client start is incorrect because the daemon is called 'docker', not 'docker-client'.

3. Final Answer:

   systemctl start docker -> Option A

4. Quick Check:

   Use systemctl to start Docker daemon = D [OK]

Hint: Use systemctl to manage Docker daemon on Linux [OK]

Common Mistakes:

• Using docker commands to start daemon directly
• Confusing client and daemon service names
• Using service command with wrong service name

3. What will happen when you run docker pull nginx if the image is not present locally?

medium

A. The command fails because image is missing

B. Docker Client builds the image locally

C. Docker Registry sends the image to the Client directly

D. Docker Daemon downloads the image from Docker Registry

Solution

1. Step 1: Understand the pull command flow

   When docker pull nginx is run, the Client sends the request to the Daemon.

2. Step 2: Role of Daemon and Registry

   The Daemon downloads the image from the Registry and stores it locally. The Client does not build the image, and the Registry does not send images directly to Client.

3. Final Answer:

   Docker Daemon downloads the image from Docker Registry -> Option D

4. Quick Check:

   Pull downloads image via Daemon from Registry = A [OK]

Hint: Pull triggers daemon to fetch image from registry [OK]

Common Mistakes:

• Thinking Client builds image on pull
• Assuming Registry sends image directly to Client
• Believing pull fails if image missing locally

4. You run docker run hello-world but get an error saying the Docker daemon is not running. What is the most likely fix?

medium

A. Restart the Docker Client

B. Start the Docker Daemon service

C. Pull the image manually from the Registry

D. Reinstall Docker Registry

Solution

1. Step 1: Identify the error cause

   The error indicates the Docker Daemon is not running, so commands cannot be executed.

2. Step 2: Fix by starting the Daemon

   Starting the Docker Daemon service (e.g., systemctl start docker) will fix the issue. Restarting Client or pulling image manually won't help if Daemon is down.

3. Final Answer:

   Start the Docker Daemon service -> Option B

4. Quick Check:

   Daemon must run for commands to work = A [OK]

Hint: Daemon must be running to execute Docker commands [OK]

Common Mistakes:

• Restarting Client instead of Daemon
• Trying to pull image without Daemon running
• Reinstalling Registry unnecessarily

5. You want to push a custom image to a private Docker Registry. Which sequence correctly describes the interaction between Docker components?

hard

A. Client builds image -> Daemon pushes image -> Registry stores image

B. Daemon builds image -> Client pushes image -> Registry stores image

C. Registry builds image -> Client pushes image -> Daemon stores image

D. Client builds image -> Registry pushes image -> Daemon stores image

Solution

1. Step 1: Understand image build and push roles

   The Client sends build commands; the Daemon builds the image locally.

2. Step 2: Understand push process

   The Client commands the Daemon to push the image; the Daemon uploads it to the Registry, which stores it.

3. Step 3: Eliminate incorrect sequences

   Daemon does not push without Client command; Registry does not build or push images; Daemon stores images locally, not pushed images.

4. Final Answer:

   Client builds image -> Daemon pushes image -> Registry stores image -> Option A

5. Quick Check:

   Client commands, Daemon acts, Registry stores = B [OK]

Hint: Client commands, Daemon acts, Registry stores images [OK]

Common Mistakes:

• Thinking Registry builds or pushes images
• Mixing roles of Client and Daemon
• Assuming Daemon stores pushed images