12 Stages of Kubernetes Cluster Lifecycle
The 12 stages of the Kubernetes cluster lifecycle as a runbook: provisioning, HA, RBAC, etcd backup, version skew, kubeadm upgrades, drain and retirement.
A Kubernetes cluster has twelve stages from first plan to final shutdown: plan, choose a provisioning method, bootstrap the control plane, join nodes, set up networking, control access, harden, deploy workloads, observe and scale, back up, upgrade, and retire. The stages that cause most outages are the last three, because they are repeated on a schedule.
This page treats the lifecycle as a runbook rather than a concept list. Each stage names the decision to make, a command or setting that matters, and the failure it prevents. Version and command details were checked against the Kubernetes documentation in November 2026. At that date the project maintains release branches for 1.37, 1.36 and 1.35, and 1.34 reached end of life on 27 October 2026.
Key takeaways
- Kubernetes supports the three most recent minor releases, with roughly one year of patch support for each. A cluster left alone falls out of support within a year.
- You cannot skip minor versions during an upgrade. Plan one minor step at a time: control plane first, then nodes.
- All Kubernetes objects live in etcd, so an etcd snapshot is the backbone of any recovery plan.
- kubeadm client certificates expire after one year by default, though a kubeadm upgrade renews them automatically.
- Managed services (EKS, AKS, GKE) take over stages 3 and 4, and parts of 10 and 11. Stages 1, 2, 6 to 9 and 12 stay with you.
- Draining nodes respects PodDisruptionBudgets, so a missing budget is a missing safety net.
The 12 stages at a glance
| # | Stage | Main question | Typical tools |
|---|---|---|---|
| 1 | Plan and size | Which workloads, how much failure tolerance? | Capacity notes, topology diagram |
| 2 | Choose provisioning | Managed or self-managed? | EKS, AKS, GKE, kubeadm, Cluster API |
| 3 | Bootstrap control plane | How many control plane nodes, where is etcd? | kubeadm, Terraform |
| 4 | Join nodes | Which node pools and sizes? | kubeadm join, autoscaler |
| 5 | Networking and DNS | Which CNI, which CIDRs? | CNI plugin, CoreDNS |
| 6 | Access control | Who can do what? | RBAC, OIDC |
| 7 | Hardening | What is the secure baseline? | Pod Security Standards, network policies |
| 8 | Deploy workloads | How do changes reach the cluster? | Helm, GitOps controllers |
| 9 | Observe and scale | How do you know it is healthy? | Metrics, logs, HPA |
| 10 | Back up and recover | Can you rebuild from nothing? | etcd snapshots, manifests in Git |
| 11 | Upgrade and patch | How do you stay supported? | kubeadm upgrade, drain |
| 12 | Retire | What must be removed and kept? | Data export, DNS and cost cleanup |
Stage 1: Plan and size
Write down what will run, what failure it must survive, and who owns the cluster. A development cluster can be a single control plane node. A production cluster needs a control plane that survives the loss of a machine or a zone. For kubeadm-built high availability the documentation calls for three or more control plane machines, an odd number to help leader selection, and three or more workers. It also describes two etcd layouts: stacked, with etcd on the control plane nodes, which needs less infrastructure, and external, with separate etcd machines, which needs more. Decide this now, because changing topology later is a migration.
Also decide the number of clusters. One shared cluster is cheaper, while one cluster per environment or per team gives a smaller blast radius. Ownership matters as much as size, and the question of who should own cluster maintenance in a platform team is worth settling before the first node exists.
Stage 2: Choose how to provision
Managed services run the control plane for you. You still own node pools, networking choices, access, workloads and upgrades of your side. Self-managed clusters give full control with full responsibility. Whichever you pick, define the cluster in code (Terraform, Cluster API or a vendor template) so that rebuilding it is a pipeline run, not a memory exercise. A walkthrough of the managed route on AWS is in deploying and managing clusters with EKS.
Stage 3: Bootstrap the control plane
With kubeadm, an HA cluster starts with a load balancer in front of the API servers: a TCP forwarder with a DNS name that health-checks port 6443 on every control plane node, whose address matches the cluster's ControlPlaneEndpoint. The first node is then initialised against that endpoint.
sudo kubeadm init --control-plane-endpoint "k8s-api.example.internal:6443" --upload-certs
The command prints join commands for further control plane nodes and workers. Machines also need access to registry.k8s.io or preloaded images. Disable swap on every node before you start, since kubeadm expects it off. Check the control plane afterwards:
kubectl get nodes
kubectl get pods -n kube-system
To read how the control plane components fit together, see 12 must-know Kubernetes architecture components.
Stage 4: Join nodes
Workers join with the token and CA hash printed at init time, using kubeadm join against the same endpoint. Group nodes into pools by purpose (general, memory-heavy, GPU, spot) and label or taint them so workloads land where intended. On a managed service, node pools are an API object, and the cluster autoscaler or the provider's equivalent adds and removes nodes. Keep kubelet versions within the supported skew from the start, which stage 11 explains.
Stage 5: Networking and DNS
A fresh cluster has no pod network until you install a CNI plugin, and nodes stay NotReady until you do. Choose pod and Service CIDRs that do not overlap with your VPC, your on-premises ranges or other clusters you may peer with, because these ranges are painful to change. CoreDNS provides in-cluster DNS. Check it early:
kubectl run dns-test --rm -it --image=busybox:1.36 --restart=Never -- nslookup kubernetes.default
The wider cloud networking background (subnets, routing, load balancers) is in 18 cloud networking concepts DevOps engineers must know.
Stage 6: Access control
Decide how humans and machines authenticate, then restrict what they can do with RBAC. Give each team a namespace and a RoleBinding to a group from your identity provider, give each workload its own ServiceAccount, and keep cluster-admin for a very small group. Members of system:masters bypass RBAC entirely, so keep that credential for bootstrap and break-glass use only. The rules in detail are in 10 Kubernetes RBAC rules.
Stage 7: Harden the baseline
Turn on the controls that stop common mistakes before any application arrives: Pod Security Standards at namespace level, default-deny network policies, restricted access to the API server, and encrypted traffic between components. Hardening is easier on an empty cluster, because enforcing a policy later means fixing every workload that breaks. The checklist is in Kubernetes cluster hardening steps, and network policies are covered separately.
Stage 8: Deploy workloads
Decide how changes reach the cluster before people start using kubectl apply by hand. A pull-based GitOps controller or a CI pipeline that applies versioned manifests gives you history and rollback. Package repeated deployments with Helm, and set resource requests and limits, readiness probes and PodDisruptionBudgets on every production workload. The budgets matter at stage 11, because drain operations respect them. The deployment patterns are in 12 Kubernetes rollout strategies, and the Git-driven approach in GitOps deployment best practices.
Stage 9: Observe and scale
Collect node and pod metrics, control plane metrics, logs and events from day one, and alert on symptoms users feel (error rate, latency) as well as saturation signals (node pressure, pending pods). Scale pods with the Horizontal Pod Autoscaler and nodes with a cluster autoscaler once you have usage data to base limits on. Health probes tell Kubernetes when a container is alive and ready, which is why Kubernetes health checks belong in every pod spec. For right-sizing and waste, see Kubernetes resource optimization techniques.
Stage 10: Back up and recover
All Kubernetes objects are stored in etcd, and the documentation advises periodic backups and encrypted snapshot files, since the snapshot contains all cluster state, including Secrets. Take a snapshot from a live member without affecting its performance:
ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
--cacert=<trusted-ca-file> --cert=<cert-file> --key=<key-file> \
snapshot save /backup/snapshot.db
etcdutl --write-out=table snapshot status /backup/snapshot.db
The certificate paths come from the etcd pod description. Use etcdutl to verify, since etcdctl snapshot status has been deprecated since etcd v3.5. To restore, point etcdutl at a new data directory:
etcdutl --data-dir /var/lib/etcd-restored snapshot restore /backup/snapshot.db
The documentation's warning is worth repeating: if API servers are running, do not restore etcd instances. Stop all API server instances, restore state in all etcd instances, then restart the API servers. A snapshot protects cluster objects only. Persistent volume data needs its own backup, and your manifests in Git are the second half of recovery. Rehearse a restore on a throwaway cluster at least twice a year, because an untested backup is only a hope. On managed services the provider handles etcd, so your backups cover volumes and manifests.
Stage 11: Upgrade and patch
Because only three minor versions are maintained, a cluster must move forward roughly every few months. Never skip a minor version, even on a single-node test cluster. The version skew policy defines the order and limits:
| Component | Supported relative to kube-apiserver |
|---|---|
| kube-apiserver (HA) | Newest and oldest instances within one minor version |
| kubelet | Not newer than the API server, up to three minor versions older |
| kube-proxy | Not newer than the API server, up to three minor versions older |
| kube-controller-manager, kube-scheduler | Not newer than the API server, up to one minor version older |
| kubectl | Within one minor version, newer or older |
Upgrade the API server first, then the controller manager and scheduler, then the kubelets and kube-proxy. Admission webhooks must handle the new API versions before you start. For a kubeadm cluster, upgrade the first control plane node like this (replace the version with the one you chose):
sudo kubeadm upgrade plan
sudo kubeadm upgrade apply v1.37.x
On the other control plane nodes run sudo kubeadm upgrade node. Then for each node in turn, drain it, upgrade the kubelet and kubectl packages, restart the kubelet and bring the node back:
kubectl drain <node-to-drain> --ignore-daemonsets
sudo systemctl daemon-reload
sudo systemctl restart kubelet
kubectl uncordon <node-to-uncordon>
Drain refuses to evict pods that would break a PodDisruptionBudget, which is the protection you set up in stage 8. In-place minor-version kubelet upgrades are not supported, so always drain first. A kubeadm upgrade also renews the certificates kubeadm manages on that node, unless you pass --certificate-renewal=false. kubeadm client certificates last one year by default, so a cluster upgraded at least yearly never meets an expired certificate. Check with sudo kubeadm certs check-expiration. Take an etcd snapshot before you begin, and read the release notes for removed APIs. The step-by-step node routine is in Kubernetes node maintenance tips.
Stage 12: Retire the cluster
Decommissioning is the stage teams forget. Move or export what must survive (persistent data, audit logs, backups), drain traffic through DNS or load balancer changes, and keep the old cluster read-only for a short agreed period. Then delete in order: workloads, load balancers and volumes created by controllers, node pools, the control plane, and finally the network and IAM resources the cluster used. Orphaned load balancers and disks keep billing after the nodes are gone, so check your cloud bill and tags for leftovers. Update inventories, certificates, DNS records and monitoring so that nothing still points at the retired cluster.
What to automate first
If you can only automate three things, pick these: cluster creation from code (stages 2 to 5), etcd snapshots with a restore test (stage 10), and the node upgrade loop (stage 11). Tools that help with day-two operations are compared in 12 Kubernetes tools to simplify cluster management.
Practise the full lifecycle
Building, securing, backing up and upgrading a cluster is the core of the CKA exam. The Certified Kubernetes Administrator course runs these stages hands-on with classroom batches in Kharadi, Pune and live online batches across India.
Official references
- Kubernetes releases and support periods
- Version skew policy
- Upgrading kubeadm clusters
- Creating Highly Available clusters with kubeadm
- Operating etcd clusters for Kubernetes
- Certificate management with kubeadm
- Safely drain a node
FAQs
What are the main stages of the Kubernetes cluster lifecycle?
Plan, choose provisioning, bootstrap the control plane, join nodes, set up networking, configure access control, harden, deploy workloads, observe and scale, back up, upgrade, and retire. Each stage has its own decisions, and the last three repeat for the life of the cluster.
Which Kubernetes versions are supported right now?
As of November 2026 the project maintains release branches for 1.37, 1.36 and 1.35. Version 1.34 reached end of life on 27 October 2026. Check the releases page before you plan, because the supported set changes with every minor release.
Can I skip a minor version when upgrading Kubernetes?
No. Skipping minor versions is unsupported, even on a single-instance cluster. Upgrade one minor version at a time, for example 1.35 to 1.36 and then 1.36 to 1.37, starting with the control plane.
In what order do I upgrade the components?
Upgrade kube-apiserver first, then kube-controller-manager, kube-scheduler and cloud-controller-manager, then the kubelets and kube-proxy. Drain each node before a minor-version kubelet upgrade, because in-place minor upgrades of the kubelet are not supported.
How do I back up a Kubernetes cluster?
Take regular etcd snapshots with etcdctl snapshot save, verify them with etcdutl snapshot status, encrypt and store them off the cluster, and keep manifests in Git. Persistent volumes need a separate backup, and you should test restores.
How long do kubeadm certificates last?
Leaf certificates generated by kubeadm are valid for one year by default, and CA certificates for ten years. A kubeadm upgrade renews the certificates it manages on that node, and kubeadm certs check-expiration shows the dates.
What does a managed Kubernetes service handle for me?
The provider runs the control plane, including etcd and its upgrades, and usually offers managed node pools. You still own access control, networking choices, hardening, workloads, observability, volume backups and your side of upgrades.
What should I check before deleting a cluster?
Export persistent data and logs you must keep, confirm traffic has moved, then remove load balancers, volumes, node pools and the control plane in order. Check cloud billing and tags for orphaned resources, and clean up DNS records and monitoring targets.
What's Your Reaction?
Like
0
Dislike
0
Love
0
Funny
0
Angry
0
Sad
0
Wow
0