What Is Kubernetes?
Kubernetes (often abbreviated K8s) is an open-source container orchestration system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery. Originally designed by Google and now maintained by the Cloud Native Computing Foundation (CNCF), Kubernetes has become the de-facto standard for running containers at scale.
The Problem Kubernetes Solves
Before container orchestration, scaling a web application meant manually provisioning servers, SSH-ing in, installing dependencies, starting processes, and crossing your fingers nothing crashed. When it did crash, someone got paged at 2am.
Containers (popularised by Docker in 2013) solved the "it works on my machine" problem by packaging an application with its runtime, libraries, and config into an immutable image. But containers don't manage themselves. When you have hundreds or thousands of containers across dozens of hosts, you need something to answer questions like:
- Which host has enough CPU and memory to run this container?
- What happens when a container crashes — who restarts it?
- How do I roll out a new version with zero downtime?
- How do containers on different hosts talk to each other?
- How do I scale out during a traffic spike and scale back in afterward?
Kubernetes answers all of these questions.
History & Origins
Kubernetes was born from over a decade of Google's internal experience running containerised workloads. Google had been running Borg, its internal cluster management system, since around 2004. Borg ran Google's production workloads — Search, Gmail, Maps — at massive scale. A redesign of Borg's lessons led to Omega, a more flexible scheduler.
In 2013, three Googlers — Joe Beda, Brendan Burns, and Craig McLuckie — started a new project to bring Borg-style orchestration to the outside world. The project was announced publicly in June 2014 and released as open source. Google donated it to the newly-formed Cloud Native Computing Foundation (CNCF) in 2016.
The name "Kubernetes" comes from the Greek word for helmsman or pilot. The "K8s" abbreviation replaces the eight middle letters with the number 8.
| Year | Milestone |
|---|---|
| 2004 | Google internally starts Borg cluster manager |
| 2013 | Docker released publicly; container adoption explodes |
| 2014 | Kubernetes announced and open-sourced by Google |
| 2016 | Kubernetes donated to CNCF; v1.0 released |
| 2018 | CNCF graduates Kubernetes (first ever graduation) |
| 2020+ | Kubernetes becomes the default for cloud-native workloads |
What Kubernetes Does
Kubernetes provides a framework to run distributed systems resiliently. It handles scaling and failover for your application, provides deployment patterns, and more. Specifically, Kubernetes provides:
- Service discovery and load balancing — K8s can expose a container via DNS or its own IP. If traffic to a container is high, K8s can load-balance and distribute the network traffic so the deployment is stable.
- Storage orchestration — K8s allows you to automatically mount a storage system of your choice (local storage, public cloud providers, and more).
- Automated rollouts and rollbacks — You can describe the desired state for your deployed containers; K8s can change the actual state to the desired state at a controlled rate. For example, you can automate K8s to create new containers, remove existing containers, and adopt all their resources to the new container.
- Automatic bin packing — You tell K8s how much CPU and memory (RAM) each container needs. K8s can fit containers onto your nodes to make the best use of your resources.
- Self-healing — K8s restarts containers that fail, replaces containers, kills containers that don't respond to your user-defined health check, and doesn't advertise them to clients until they are ready to serve.
- Secret and configuration management — K8s lets you store and manage sensitive information (passwords, OAuth tokens, SSH keys). You can deploy and update secrets and application configuration without rebuilding your container images.
- Horizontal scaling — Scale your application up and down with a command, a UI, or automatically based on CPU usage.
What Kubernetes Is Not
It's equally important to know what Kubernetes deliberately does not do:
- Kubernetes does not deploy source code or build your application. CI/CD workflows (GitHub Actions, Jenkins, Argo CD) are separate concerns.
- Kubernetes does not provide application-level services like databases or message queues. It runs containers; what's inside them is up to you.
- Kubernetes does not dictate logging, monitoring, or alerting solutions. It provides mechanisms to export them (stdout/stderr logs, metrics endpoints) but leaves the choice to you.
- Kubernetes is not a PaaS like Heroku. It operates at the container level, not the application level.
Kubernetes' power comes with operational complexity. For a simple web app with a single service, a PaaS like Heroku, Railway, or Render is probably the right choice. Kubernetes shines when you have many microservices, multiple teams, need fine-grained resource control, or are running stateful workloads at scale.
Use Cases
Kubernetes is appropriate when you need:
- Microservices at scale — Dozens of independent services each with their own deploy cadence, resource requirements, and scaling characteristics.
- Multi-team platforms — Multiple teams sharing infrastructure with namespace-level isolation and RBAC controls.
- Stateful workloads — Databases, queues, and caches that need persistent storage, ordered scaling, and stable network identities (StatefulSets).
- Batch and ML workloads — Jobs and CronJobs for batch processing; GPU scheduling for machine learning training.
- Hybrid and multi-cloud — Running workloads consistently across on-prem, AWS, GCP, and Azure using the same Kubernetes APIs.
Declarative vs Imperative
Kubernetes is fundamentally a declarative system. You describe the state you want the cluster to be in, and Kubernetes continuously reconciles actual state to match it. This is different from the imperative approach of issuing step-by-step commands.
| Approach | How it works | K8s example |
|---|---|---|
| Imperative | Issue commands one at a time. If the system drifts, nothing corrects it automatically. | kubectl run nginx --image=nginx:1.27 |
| Declarative | Write a manifest describing desired state. Kubernetes watches and reconciles continuously. | kubectl apply -f deployment.yaml |
In practice, you write YAML manifests and commit them to Git. kubectl apply sends the manifest to the API server, which computes the difference between current and desired state and makes the necessary changes. This is the foundation of GitOps — your Git repository becomes the source of truth for cluster state.
Quick one-offs like kubectl scale deployment myapp --replicas=5 or kubectl rollout undo deployment myapp are fine during incident response or local development. But anything that must be reproducible across environments, or survive beyond a single session, belongs in a manifest.
kubectl apply
cluster state
vs actual state
to reconcile gap
Kubernetes controllers run continuous reconciliation loops: they watch for drift between desired and actual state and correct it. This is why crashed pods get restarted, failed nodes have their workloads rescheduled, and scaled deployments converge — all without human intervention.