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.

Dec 23, 2025 - 17:43
Nov 11, 2026 - 05:33
 0  55
12 Stages of Kubernetes Cluster Lifecycle

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

#StageMain questionTypical tools
1Plan and sizeWhich workloads, how much failure tolerance?Capacity notes, topology diagram
2Choose provisioningManaged or self-managed?EKS, AKS, GKE, kubeadm, Cluster API
3Bootstrap control planeHow many control plane nodes, where is etcd?kubeadm, Terraform
4Join nodesWhich node pools and sizes?kubeadm join, autoscaler
5Networking and DNSWhich CNI, which CIDRs?CNI plugin, CoreDNS
6Access controlWho can do what?RBAC, OIDC
7HardeningWhat is the secure baseline?Pod Security Standards, network policies
8Deploy workloadsHow do changes reach the cluster?Helm, GitOps controllers
9Observe and scaleHow do you know it is healthy?Metrics, logs, HPA
10Back up and recoverCan you rebuild from nothing?etcd snapshots, manifests in Git
11Upgrade and patchHow do you stay supported?kubeadm upgrade, drain
12RetireWhat 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:

ComponentSupported relative to kube-apiserver
kube-apiserver (HA)Newest and oldest instances within one minor version
kubeletNot newer than the API server, up to three minor versions older
kube-proxyNot newer than the API server, up to three minor versions older
kube-controller-manager, kube-schedulerNot newer than the API server, up to one minor version older
kubectlWithin 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

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 Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.