Container Orchestration Basics: API Server, Controllers, and Scheduler
Orchestration is a loop of reconciliations. We start with the primitives — the API server as the system of record, etcd behind it, the controller manager running reconciliation loops, and the scheduler deciding placement — then wire them together into a working cluster. We watch a real deployment unfold: create a Deployment, and follow the watch events as controllers converge it toward desired state, replica sets fan out, and Pods get scheduled and admitted. The video answers the questions under the jargon: what "declarative" actually means, and why every controller re-reads state instead of trusting a message.
Topics covered:
- Control plane components and their jobs
- etcd, the API server, and the watch mechanism
- Reconciliation loops and desired-state convergence
- The deployment → replicaset → pod chain
Related articles
Kubernetes Scheduling Is a Packing Problem
How kube-scheduler bin-packs pods onto nodes with filter and score passes, why requests versus limits drive overcommit, and what QoS classes mean for eviction.
Autoscaling Is a Latency Decision
Reaction time versus provisioning time, HPA sync intervals, cooldowns, and hysteresis — why autoscaling is a latency engineering problem before it is a capacity problem.
Containers Aren't Lightweight VMs
Namespaces, cgroups, seccomp, and the real isolation boundaries — what containers actually isolate and what they don't.
More in Cloud & Infrastructure
Edge Computing Explained: Where Compute Actually Sits
What edge computing actually is — the compute tiers from device to far edge to cloud, latency and bandwidth budgets, and which workloads genuinely benefit.
DetailsThe Cost of Distributed Systems: Coordination, Consistency, and Failure
What distributed systems actually cost — coordination, consistency, and failure taxes — quantified with quorum math, tail latency, and retry-storm dynamics.
DetailsDNS and Traffic Routing in the Cloud: From Resolver to Anycast
How DNS actually routes traffic in the cloud — record resolution, CDN anycast, geo routing, load balancer handoffs, and how TTLs shape your failover story.
DetailsMulti-Region Architecture: Active-Active, Failover, and Replication
The real mechanics of multi-region deployments — where writes land, how replication propagates, what failover flips, and the latency math that constrains every design.
DetailsObject Storage Under the Hood: PUT, GET, and Erasure Coding
What happens inside an object store — the PUT and GET paths, metadata partitions, erasure coding, and why object storage is eventually consistent.
DetailsAutoscaling Explained: The Controller Loop Behind Horizontal Scaling
How autoscaling actually works — the metrics window, desired-replica calculation, stabilization, and why naive CPU-based scaling oscillates under real load.
DetailsServerless Cold Starts, Measured: Where the Latency Actually Goes
Measured cold-start latency across Lambda, Cloud Functions, and container runtimes — what actually takes time and which optimizations genuinely reduce it.
DetailsKubernetes Scheduling Visualized: The Filter-Score Pipeline
What the Kubernetes scheduler actually does — how pending Pods become assigned to Nodes, the filter-then-score pipeline, and how taints and affinity shape placement.
DetailsContainer Images Explained: Layers, Manifests, and Digests
How container images are actually built and run — layers, manifests, content digests, and what the runtime does at pull and run time.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.