Docker and Containerization

Docker is an open-source platform for packaging and running applications in isolated environments called containers. A container bundles the application and all its dependencies—libraries, configuration, runtime—into a single unit that behaves identically regardless of the host environment.

Before containers, the gap between a developer's machine and a production server was a persistent source of failures. "It works on my machine" was not just a running joke—it was a real problem caused by differing OS versions, library versions, and configurations. Docker closes that gap.

Containers vs. Virtual Machines#

Containers and virtual machines both provide isolation, but through different mechanisms.

A virtual machine emulates an entire computer, including its own OS kernel. This makes VMs heavyweight—they consume significant CPU, memory, and disk to run.

A container shares the host operating system's kernel. It isolates the application's filesystem, network, and processes, but without duplicating the OS. This makes containers lightweight, fast to start, and efficient with resources.

Key Concepts#

Docker Image: A read-only template describing how to build a container. Defined in a Dockerfile. Images are layered—each instruction in the Dockerfile adds a layer, and unchanged layers are cached.

Docker Container: A running instance of an image. Containers are ephemeral by default; when they stop, any data written inside them is gone unless it is stored on a mounted volume.

Dockerfile: A plain-text file containing the instructions for building an image.

FROM openjdk:17-jdk-slim
WORKDIR /app
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

Docker Hub: A public registry where images are stored and distributed. You pull base images from here and push your own built images for deployment.

Core Benefits#

Portability: A container built on a developer's laptop runs identically in CI, staging, and production. The environment travels with the application.

Isolation: Containers share the host kernel but are otherwise isolated. A crash or misconfiguration in one container does not affect others.

Reproducibility: Images are versioned and immutable. Rolling back to a previous version is a matter of pulling a specific image tag.

Efficiency: Containers start in milliseconds. Running ten services on a single machine that would have required ten VMs now requires a fraction of the resources.

Getting Started#

Install Docker: Docker provides installers for Linux, macOS, and Windows. After installation, docker version confirms the setup.

Build an image:

docker build -t my-app:1.0 .

Run a container:

docker run -p 8080:8080 my-app:1.0

List running containers:

docker ps

Stop a container:

docker stop <container-id>

Container Orchestration#

Running a single container manually is straightforward. Running dozens of containers across multiple machines—with networking, load balancing, health checks, and restarts—requires an orchestration layer.

Docker Compose handles multi-container setups on a single host. A docker-compose.yml file defines services, networks, and volumes:

services:
  app:
    image: my-app:1.0
    ports:
      - "8080:8080"
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret

Kubernetes handles orchestration at scale across clusters of machines. It manages deployment, scaling, rolling updates, and self-healing. Most production container deployments of any size end up on Kubernetes or a managed equivalent.

Conclusion#

Docker removes the environment variable from software deployment. Once an application is containerized, the question of whether it will run correctly in a given environment has a deterministic answer: yes, because the environment is part of the artifact.

Understanding Docker is a prerequisite for working in most modern backend and DevOps roles. The concepts—images, containers, registries, orchestration—compose into a deployment model that has become the default in the industry.