mika's open learning notebook

notes on programming, linux, software, and whatever i'm learning


Infrastructure & Deployment · September 27, 2026

September 27, 2026 — Docker & Kubernetes: Containers, Orchestration & When They Matter

A practical mental model for containers, Docker, Kubernetes, pods, deployments, services, ingress, and when orchestration becomes useful.

Why containers exist

A container packages an application together with the runtime pieces it depends on so it can run in a more predictable environment.

That usually includes:

  • the application
  • language/runtime dependencies
  • system libraries
  • configuration supplied at runtime
  • a defined process to start

The useful mental model is:

application
+ runtime dependencies
+ isolated filesystem/process environment
= container

Containers help reduce environment drift between a developer machine, CI, staging, and production.

Docker is the common container workflow

Docker gives developers a practical way to build images and run containers.

An image is the packaged template.

A container is a running instance of that image.

Dockerfile
→ build image
→ run container

That distinction helped me understand why a container can be deleted and recreated while the image stays available.

Containers are still processes

A container can feel like a tiny virtual machine, but its model is closer to an isolated process environment.

It shares the host operating system kernel while keeping its own filesystem view, process namespace, networking rules, and resource boundaries.

That makes containers lighter than full virtual machines for many application workloads.

One container is manageable

A single application can often run perfectly well with Docker or another container runtime.

For example:

web app container
→ exposed port
→ environment variables
→ persistent volume if needed

The complexity changes when there are many containers, many machines, frequent deployments, scaling requirements, health checks, service discovery, and recovery expectations.

That is where orchestration becomes useful.

What Kubernetes does

Kubernetes manages groups of containers across a cluster of machines.

It handles concerns such as:

  • scheduling workloads
  • restarting failed workloads
  • scaling replicas
  • rolling out new versions
  • service discovery
  • networking between services
  • exposing applications
  • configuration and secrets
  • maintaining a desired state

A useful summary is:

I describe the state I want
→ Kubernetes keeps trying to make the cluster match it

Pod

A Pod is the smallest deployable unit in Kubernetes.

A pod usually contains one main application container, although multiple tightly related containers can share a pod.

Containers inside the same pod share networking and some runtime context.

Deployment

A Deployment describes how an application should run over time.

It can define:

  • which container image to use
  • how many replicas should exist
  • how updates should roll out
  • how Kubernetes should replace unhealthy or old instances

This gives Kubernetes a desired state to maintain.

Service

Pods can be replaced, restarted, or moved.

Their individual addresses are therefore unstable.

A Service gives a stable network endpoint for reaching a changing set of pods.

client
→ Service
→ one of several matching Pods

Ingress

Ingress handles HTTP/HTTPS traffic entering a cluster.

It can route requests by hostname or URL path toward the appropriate service.

A simplified path looks like:

internet
→ ingress
→ service
→ pod
→ container

When Kubernetes starts making sense

Kubernetes becomes more useful when the operational problem grows beyond one or two easily managed containers.

Signals include:

  • many services
  • multiple machines
  • frequent deployments
  • automatic scaling
  • high availability requirements
  • self-healing expectations
  • several teams shipping independently
  • standardized deployment across environments

A small personal project usually has simpler deployment options.

Understanding Kubernetes is still useful because many production systems use the same concepts even when I am not responsible for operating the cluster.

Why this matters for technical writing

For infrastructure documentation, I need enough of the system model to understand what a user is configuring.

Terms such as:

  • image
  • container
  • pod
  • deployment
  • service
  • ingress
  • namespace
  • config map
  • secret

describe different layers of the runtime.

If I confuse those layers, installation and troubleshooting instructions become confusing too.

Troubleshooting follows the layers

A deployment problem can exist at several places:

application code
→ container image
→ container runtime
→ pod
→ deployment
→ service
→ ingress
→ cloud/network infrastructure

A good troubleshooting workflow identifies the failing layer before changing unrelated configuration.

Main lesson

Docker helped me understand how software gets packaged into a repeatable runtime environment.

Kubernetes helped me understand how larger systems keep many containerized workloads running, reachable, replaceable, and close to a declared desired state.

The part I want to keep practicing is tracing failures through those layers and learning the vocabulary well enough to document real deployment workflows accurately.