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.