TL;DR
The author reframes Kubernetes as a runtime for declarative infrastructure with a built-in type system, not merely a container orchestrator. Manifests declare desired state, the API stores that intent, and controllers continuously reconcile actual state toward the spec — a pattern that shapes how GitOps and CRDs fit into operations.
What happened
The essay reframes common mental models of Kubernetes by describing it as a runtime that enforces declarations rather than a tool that executes scripts. Using a simple Pod manifest as an example, the author shows how Kubernetes exposes a vocabulary of resource kinds — Pod, ReplicaSet, Deployment, Service, Ingress — that act like types with defined semantics and valid fields. When you apply a manifest, the API server validates and persists the object as durable cluster state. Controllers observe those objects and loop: they compare desired state (spec) with observed reality (status), then take actions (scheduling, kubelet execution) to reduce differences. This continuous reconciliation explains why manual edits often revert and why deleting resources doesn’t necessarily remove workloads if the spec still demands them. The piece also connects this runtime model to GitOps: Git holds the canonical desired state, the cluster holds the runtime state, and GitOps controllers reconcile Git→cluster while Kubernetes reconciles API objects→actual resources.
Why it matters
- Seeing Kubernetes as a declarative runtime changes how you make and troubleshoot changes: edit desired state, not runtime symptoms.
- The resource kinds act like a type system, encouraging use of built-in abstractions rather than ad hoc conventions.
- Continuous reconciliation means manual fixes can be transient; ownership and intent must be explicit, especially under GitOps.
- CRDs let teams extend the API with new resource types and associated controllers, integrating custom semantics into the runtime.
Key facts
- Kubernetes resources (Pod, Deployment, Service, etc.) behave like typed objects with specific fields and semantics.
- A manifest submitted via kubectl apply is treated as a declaration of desired state, not an imperative command.
- The API server validates and stores objects, making the declared intent durable in cluster state.
- Controllers watch relevant objects and continuously reconcile desired state (spec) with observed state (status).
- The scheduler selects nodes for Pods and the kubelet on each node carries out execution to realize workloads.
- Manual changes to live objects can be reverted when controllers or GitOps flows own that intent.
- Custom Resource Definitions (CRDs) create new API kinds that extend Kubernetes’ type system and are backed by operators/controllers.
- GitOps places the canonical desired state in Git; a GitOps controller keeps the cluster aligned with that source of truth.
What to watch next
- How GitOps workflows interact with on-cluster edits and how teams treat kubectl as a debugging tool rather than the source of truth.
- not confirmed in the source: whether adoption of CRDs and operators will accelerate specific operational patterns across organizations.
- Use of spec and status as primary debugging inputs and how tooling surfaces these fields for operators.
Quick glossary
- Pod: The smallest scheduling unit in Kubernetes, typically representing one or more containers that share resources and a network namespace.
- Controller: A control loop that watches Kubernetes objects and takes actions to reconcile actual state with desired state.
- Custom Resource Definition (CRD): An extension mechanism that lets you define new API resource kinds and add custom behavior via controllers or operators.
- Spec: The part of a Kubernetes object that declares the desired state or configuration the user wants.
- Status: The part of a Kubernetes object that records observations and runtime-computed information about the current state.
- GitOps: A pattern where Git is the source of truth for desired system state and controllers synchronize cluster state to match Git.
Reader FAQ
Is Kubernetes just a container orchestrator?
No. The author argues it is more usefully viewed as a runtime for declarative infrastructure with a type system rather than only an orchestrator.
What is the difference between spec and status?
Spec expresses what you want; status records what the runtime observed and computed. Comparing them is central to debugging reconciliation issues.
Should I edit live resources when using GitOps?
Treat kubectl edits as debugging actions, not the authoritative way to change state; Git is the canonical source of desired state under GitOps.
Do CRDs let me invent new kinds of resources?
Yes. CRDs extend the API so teams can define custom resource kinds, backed by controllers that implement their behavior.
How I think about Kubernetes More than a container orchastrator December 26, 2025 Kubernetes is most often described as a container orchestration tool, but after you’ve spent some time with…
Sources
- How I think about Kubernetes
- Why is Kubernetes more than a Container Orchestration …
- Why Kubernetes is more than container orchestration
- More Than Just Kubernetes, Container Orchestration Tools …
Related posts
- Rethinking Kubernetes as a declarative runtime with a type system
- Experts Explore New Mushroom Which Causes Fairytale-Like Hallucinations
- A Proclamation on Restoring the Em—Dash: Reclaiming the Writer’s Mark