What is Docker? The Container Platform

Think about smartphones before and after the iPhone.

Before the iPhone, smartphones existed. BlackBerry, Palm, Windows Mobile. They could browse the web, send email, run apps.

But they were complicated. Different devices had different interfaces. Apps were hard to install. Developers had to target multiple platforms.

Then Apple came along and said: “Here’s a simple interface. Here’s one app store. Here’s a consistent experience.” They didn’t invent the smartphone. They made it accessible.

Docker is the iPhone of containers.

Docker didn’t invent containers. Docker made containers usable. Docker gave us:

• A simple command-line interface (docker run)
• A standard image format (everyone packages containers the same way)
• A registry (Docker Hub — share containers like apps in an app store)
• A build system (Dockerfiles — recipes for creating images)
• An ecosystem (tools, orchestration, community)

Before Docker, you needed to be a Linux kernel expert to use containers. After Docker, the same task became docker run.

Docker is a platform with several components:

Docker Engine The core of Docker. It includes:

• The Docker daemon (dockerd) — a background process that manages containers
• The Docker CLI (docker) — the command-line tool you interact with
• The REST API — how the CLI talks to the daemon (and how other tools can too)

Docker Image Format A standardized way to package applications. Images are composed of layers (we’ll cover this in Module 6). The format became an industry standard called OCI (Open Container Initiative).

Docker Hub A public registry where anyone can push and pull images. Like GitHub for code, but for containers. You can find official images for almost any software (nginx, postgres, python, node, etc.).

Dockerfile A text file that specifies how to build an image. A recipe that Docker follows to create your portable kitchen.

When you type docker run nginx, here’s what happens:

┌─────────────────────────────────────────────────────────────┐
│  Your Terminal                                               │
│  $ docker run nginx                                          │
└───────────────┬─────────────────────────────────────────────┘
                │ (1) CLI sends command
                ▼
┌─────────────────────────────────────────────────────────────┐
│  Docker CLI (docker)                                         │
│  Parses command, sends to daemon via REST API               │
└───────────────┬─────────────────────────────────────────────┘
                │ (2) API request to daemon
                ▼
┌─────────────────────────────────────────────────────────────┐
│  Docker Daemon (dockerd)                                     │
│  - Checks if image exists locally                            │
│  - Pulls from registry if needed                             │
│  - Creates container from image                              │
│  - Manages container lifecycle                               │
└───────────────┬─────────────────────────────────────────────┘
                │ (3) Creates container via containerd
                ▼
┌─────────────────────────────────────────────────────────────┐
│  containerd                                                  │
│  Industry-standard container runtime                         │
└───────────────┬─────────────────────────────────────────────┘
                │ (4) Uses runc to create isolated process
                ▼
┌─────────────────────────────────────────────────────────────┐
│  runc                                                        │
│  Low-level runtime that actually creates the container       │
│  Sets up namespaces, cgroups, mounts filesystem              │
└───────────────┬─────────────────────────────────────────────┘
                │ (5) Container process starts
                ▼
┌─────────────────────────────────────────────────────────────┐
│  Your Container                                              │
│  Nginx running in isolated environment                       │
└─────────────────────────────────────────────────────────────┘

You see one command. Behind the scenes, multiple components coordinate to make it happen.

Docker the company has had a complicated history. In 2017, they donated the core container runtime (containerd) to the Cloud Native Computing Foundation (CNCF). This was a big deal — it meant the fundamental container technology wasn’t controlled by one company.

Today’s container ecosystem:

• OCI (Open Container Initiative): Defines standards for container formats and runtimes
• containerd: The industry-standard container runtime (used by Docker, Kubernetes, etc.)
• runc: The reference implementation for running containers
• Docker: The developer-friendly platform that wraps all of this

You might hear about alternatives to Docker like Podman, but they all use the same underlying standards. An image built with Docker runs in Podman and vice versa. Docker made containers accessible, and the standards it pioneered are now widely adopted.

---