What is Docker

Understand what Docker actually is, how containers work, and why Docker changed modern infrastructure.

Docker is a platform for running applications inside isolated environments called containers.

Instead of installing applications directly onto a server or operating system, Docker packages the application together with everything it needs to run.

This usually includes:

  • application code
  • libraries
  • dependencies
  • runtimes
  • configuration files

The result is a portable environment that behaves consistently across different systems.

A Docker container can run on:

  • a developer laptop
  • a testing server
  • a cloud virtual machine
  • a Kubernetes cluster

without changing the application itself.

This consistency is one of the main reasons Docker became so important.

The Problem Before Docker

To understand Docker properly, you first need to understand the problem it solved.

Before containers became popular, deploying applications was often difficult and unreliable.

A typical deployment workflow looked like this:

Developer Machine
        ↓
Testing Server
        ↓
Production Server

The application might work perfectly on the developer’s machine but fail completely in production.

This usually happened because environments were different.

For example:

  • the developer used Node.js 22
  • the production server used Node.js 18
  • required libraries were missing
  • package versions behaved differently
  • system configurations did not match

This created the famous problem:

"It works on my machine."

For infrastructure teams, these inconsistencies created endless troubleshooting and deployment problems.

Docker Solution

Docker solves this by packaging the application together with its environment.

Instead of relying on the host system to already contain the correct dependencies, the container already includes everything the application needs.

For example, imagine a Node.js API that requires:

  • Node.js runtime
  • npm packages
  • OpenSSL libraries
  • environment configuration

Docker bundles these components together into a container.

+---------------------------+
| Docker Container          |
|---------------------------|
| Node.js Application       |
| npm Packages              |
| Libraries                 |
| Runtime                   |
| Configuration             |
+---------------------------+

This means the container behaves consistently everywhere.

Whether the container runs on:

  • Ubuntu
  • Debian
  • a cloud VM
  • a homelab server
  • Kubernetes

the internal application environment remains the same.

This dramatically simplifies deployment.

What is a Container?

A container is an isolated environment for running an application.

You can think of it like:

a lightweight mini-computer
focused on a single application

For example:

  • one container might run Nginx
  • another might run PostgreSQL
  • another might run Redis

Each container has its own:

  • filesystem
  • processes
  • networking
  • environment variables

This isolation prevents applications from interfering with each other.

For example:

  • one container can use Python 3.10
  • another can use Python 3.12

without conflicts.

This is extremely useful in real-world environments where many services run on the same server.

Containers Are Usually Temporary

One important beginner concept is that containers are usually designed to be replaceable.

You can:

  • stop them
  • delete them
  • recreate them

very easily.

For example, updating a web application often means:

Delete old container
        ↓
Start new container

This works well because containers are intended to be disposable.

However, this creates an important challenge for databases and persistent data.

For example:

docker rm postgres

If the PostgreSQL container stores its database internally without a volume, the data may disappear when the container is removed.

This is why Docker volumes are extremely important.

We will explore this later in the storage section.

Containers vs Virtual Machines

One of the most common beginner misunderstandings is thinking:

Container = Virtual Machine

Containers and virtual machines both provide isolation, but internally they work very differently.

Understanding this difference is extremely important.

Virtual Machine Model

A virtual machine runs a complete operating system.

+----------------------+
| Application          |
+----------------------+
| Guest Operating Sys  |
+----------------------+
| Hypervisor           |
+----------------------+
| Physical Hardware    |
+----------------------+

Each virtual machine contains:

  • its own kernel
  • system services
  • drivers
  • background processes

This makes virtual machines:

  • heavier
  • slower to start
  • more resource intensive

A server running many virtual machines may require large amounts of RAM and storage.

Container Model

Containers are much lighter.

+----------------------+
| Application          |
+----------------------+
| Docker Engine        |
+----------------------+
| Host Linux Kernel    |
+----------------------+
| Physical Hardware    |
+----------------------+

Containers do not run a full operating system internally.

Instead, they share the Linux kernel of the host machine.

This is one of the most important Docker concepts.

Because containers share the host kernel, they are:

  • lightweight
  • fast
  • efficient
  • easy to scale

A container can often start in seconds or less.

This efficiency helped containers become dominant in cloud infrastructure and DevOps workflows.

Real-World Example

Imagine a modern web application stack:

Frontend
    ↓
Backend API
    ↓
Redis Cache
    ↓
PostgreSQL Database

With Docker, each service can run inside its own container.

+------------------+
| Frontend         |
+------------------+

+------------------+
| Backend API      |
+------------------+

+------------------+
| Redis            |
+------------------+

+------------------+
| PostgreSQL       |
+------------------+

This makes infrastructure easier to:

  • deploy
  • update
  • scale
  • isolate
  • automate

For example:

  • restart only the API
  • scale only the frontend
  • upgrade PostgreSQL separately
  • move workloads between servers

This flexibility is one reason containers became so popular in modern infrastructure.

Docker simplified many infrastructure problems that previously required significant manual work.

It became widely adopted because it improved:

  • deployment consistency
  • portability
  • scalability
  • automation
  • reproducibility

Today Docker concepts are deeply connected to:

  • Kubernetes
  • cloud platforms
  • CI/CD systems
  • self-hosting
  • DevOps workflows
  • platform engineering

Even platforms that do not expose Docker directly often still rely on container technologies internally.

Docker Internals

Although Docker looks simple from the outside, internally it relies heavily on Linux kernel technologies.

Important concepts include:

  • namespaces
  • cgroups
  • layered filesystems
  • overlayfs
  • bridge networking

These technologies allow Docker to:

  • isolate processes
  • limit resource usage
  • create lightweight filesystems
  • manage container networking

You do not need to fully understand these concepts immediately.

But knowing that containers are deeply connected to Linux helps explain why Docker behaves the way it does.

Common Beginner Mistake

Many beginners think containers are small virtual machines.

They are not.

Containers share the host Linux kernel and work very differently internally.

This is one reason containers are significantly lighter and faster than traditional virtual machines.

Why This Matters

Understanding what Docker actually is makes every later Docker topic easier.

For example:

  • networking
  • volumes
  • Compose
  • orchestration
  • Kubernetes
  • container scaling

Without understanding containers properly, Docker commands often feel random.

With the correct mental model, Docker becomes much easier to reason about.

Summary

Docker is fundamentally a system for running isolated applications consistently across different environments.

The core idea is simple:

Package the application together
with everything it needs to run.

Once this idea becomes clear, the rest of Docker becomes much easier to understand.

Key Takeaways

  • Docker runs applications inside containers
  • Containers package applications together with dependencies
  • Containers are lightweight compared to virtual machines
  • Containers provide environment consistency
  • Containers are usually disposable and replaceable
  • Docker simplified modern application deployment
  • Understanding containers is foundational for modern infrastructure