supraj.dev

Cloud and DevOps · Playbook

Your EKS cluster is leaving standard supportA zero-downtime upgrade playbook.

Your cluster's version is about to cost six times as much per hour. You're several versions behind, and EKS won't let you jump. Here's how to climb one step at a time without dropping traffic.

Supraj Maripeddi · · 16 min read

Cover: a staircase of Kubernetes versions from 1.34 to 1.37. The control plane climbs one step at a time, and the hourly price for a cluster on an old version rises from 0.10 to 0.60 US dollars.
Start hereYou run a production EKS cluster with kubectl and the AWS CLI, and you know what a node, a Pod and a Deployment are.
Leave knowingWhat extended support costs, why you climb one version at a time, and a hop-by-hop playbook for control plane, add-ons and nodes.
Keep in mindDates and prices were read on 20 November 2026 and will change. "Zero downtime" also needs your apps to have spare replicas and clients that reconnect.

Here's the situation. A production cluster runs Kubernetes 1.34 on EKS. Standard support for 1.34 ends on 2 December 2026, twelve days from the day this was written. The newest version on EKS is 1.37. [1] Nobody upgraded for a year, and now the bill is about to change.

We'll use one picture all the way through: a city bus company. The depot office writes the rulebook every driver follows. That's the control plane. The buses are your nodes, and the passengers are your Pods. The ticket machines and radios fitted to every bus are the add-ons. An upgrade means a new edition of the rulebook, then a fleet of buses that can follow it, with no passenger left at a stop.

01 / The deadline

What does leaving standard support actually cost?

EKS gives each Kubernetes minor version 14 months of standard support from the day it's released on EKS. After that comes 12 months of extended support, at an extra cost per cluster hour. That's 26 months in all. [1]

The price, from the EKS pricing page on 20 November 2026: standard support is $0.10 per cluster per hour. Extended support is $0.60 per cluster per hour, which is the $0.10 plus $0.50. [2] So each cluster that slips over the line costs an extra $12 a day, or $4,380 over a year. Billing for extended support starts at the beginning of the end-of-standard-support day, in UTC. [1]

Here's the EKS calendar for the versions on offer that day. [1]

EKS release calendar, read on 20 November 2026 (dates in UTC).
Version On EKS since Standard support ends Extended support ends
1.371 Oct 20261 Dec 20271 Dec 2028
1.362 Jun 20262 Aug 20272 Aug 2028
1.3527 Jan 202627 Mar 202727 Mar 2028
1.342 Oct 20252 Dec 20262 Dec 2027
1.3329 May 202529 Jul 202629 Jul 2027
1.3223 Jan 202523 Mar 202623 Mar 2027
1.3126 Sep 202426 Nov 202526 Nov 2026

Two settings decide what happens at the line. Each cluster has an upgrade policy. With EXTENDED, the default for new and existing clusters, the cluster stays on its version and starts paying the extended price. With STANDARD, AWS upgrades the cluster for you when standard support ends. [7] Once a cluster is in extended support, you can't switch the policy off. To change it, the cluster must be on a version in standard support. [7]

Check yours:

aws eks describe-cluster \
  --name <cluster-name> \
  --query "cluster.upgradePolicy.supportType"

Don't treat the automatic upgrade as a safety net. At the end of extended support, AWS upgrades only the control plane. Managed node groups and self-managed nodes stay on the old version, and you won't get a notice before it happens. [1]

Figure 1 · Where is your cluster today?

Pick your control plane version

  • Your version
  • Standard support
  • Standard support ends within 30 days
  • Extended support
  • Versions still to climb

1.34 is in standard support until 2 December 2026, 12 days away. One control plane hop, to 1.35, keeps it at $0.10 an hour until 27 March 2027. Three hops reach 1.37.

Counted from 20 November 2026, the day the calendar was read. The extra cost is $0.50 per cluster hour, so $12 a day for each cluster. Each hop moves one minor version.
In the bus depot
The city licenses each rulebook edition for 14 months. After that you can keep using it for a year, but the licence fee goes up sixfold.
In the cluster
Standard support lasts 14 months at $0.10 an hour. Extended support adds 12 months at $0.60 an hour.

02 / The rule

Why can't you jump straight to the newest version?

Because EKS runs a highly available control plane, "you can update only one minor version at a time". To go from 1.34 to 1.37 you go 1.34 to 1.35, then 1.35 to 1.36, then 1.36 to 1.37. [3]

The reason comes from Kubernetes itself. In a highly available cluster, the newest and oldest API servers "must be within one minor version". During a rolling update, old and new API servers run side by side, so a two-version jump would break that rule. Kubernetes policy also says the API server must not skip minor versions when upgrading, even in a single-server cluster. [17]

The nodes have more room. A kubelet must never be newer than the API server, but it may be up to three minor versions older. [17] EKS uses this: with nodes on 1.25 or newer, you can move the control plane up to three versions ahead without touching the kubelet. [3] The same page also says nodes must match the control plane's version before you update it. Read the two together as: the skew is allowed, but the clean path is to bring nodes level before each next hop. [3]

kubectl has the tightest rule. It's supported within one minor version, older or newer, of the API server. [17] Update it as you climb.

In the bus depot
Office staff work from adjacent editions while the new one is phased in. Buses can run on a rulebook up to three editions old, but never a newer one.
In the cluster
API servers stay within one minor version of each other. Kubelets may lag the API server by up to three minor versions, never lead it.

03 / The risk

What will break when you move up a version?

Start with removed APIs. A beta API is deprecated and later stops being served, so any manifest, Helm chart or controller still asking for it fails after the upgrade. [19] The Kubernetes Deprecated API Migration Guide lists every removal by release. On 20 November 2026 its newest entry was v1.32, which stopped serving flowcontrol.apiserver.k8s.io/v1beta3. [18] So the guide lists nothing removed in 1.35, 1.36 or 1.37.

That doesn't mean this climb is safe. EKS's own release notes list breaking changes that aren't API removals: [8]

  • 1.35: the kubelet refuses to start by default on nodes using cgroup v1. It's also the last release supporting containerd 1.x, so you must be on containerd 2.0 or later before the next version.
  • 1.36: the gitRepo volume type is permanently disabled, and the kubelet refuses to run Pods that use it. Strict IP and CIDR validation is on, so creating or updating built-in objects with values like 010.000.000.005 fails.
  • 1.37: SELinux mount labelling is on by default. On SELinux-enabled nodes, Pods that share a volume with different SELinux settings can stay stuck in ContainerCreating.

Read every version's notes between where you are and where you're going. Each one has an "Action required" line. [8]

Let EKS look for you

EKS upgrade insights scan every cluster for upgrade problems, such as deprecated API use, kubelet skew, kube-proxy skew and add-on compatibility. [5] [6] An ERROR usually means a problem for the next version (N+1). A WARNING means one for N+2 or later. [6]

aws eks start-insights-refresh --region <region-code> --cluster-name <cluster-name>
aws eks list-insights --region <region-code> --cluster-name <cluster-name>
aws eks describe-insight --region <region-code> --cluster-name <cluster-name> --id <insight-id>

Know their limits. Insights refresh every 24 hours. The deprecated API check looks at a rolling 30-day window, so after you fix a client it can take up to 30 days for the insight to clear. [3] And EKS has temporarily rolled back a feature that required --force when insights found issues, so for now a failing insight doesn't stop the upgrade. [3] You have to read them.

For a second signal, every request to a deprecated API makes the API server return a warning header and set the apiserver_requested_deprecated_apis metric, with a removed_release label. [19]

In the bus depot
Before printing a new edition, the office checks who still uses the old forms. Some changes aren't forms at all, like a new rule about which fuel the engines take.
In the cluster
Removed APIs are one risk. Behaviour changes like cgroup v1, containerd 1.x and gitRepo volumes are another, and they're in the EKS release notes.

04 / The fittings

Which add-ons do you have to move yourself?

All three defaults. The Amazon VPC CNI, CoreDNS and kube-proxy come with every cluster, and AWS lists them in its upgrade steps. [3] It "doesn't automatically update an add-on" after you update your cluster to a new minor version. You start each update. [9]

  • VPC CNI gives each Pod an IP address from your VPC. [10] On 20 November 2026 the latest EKS add-on version was the same for 1.31 through 1.37. To get to v1.12.0 or later you must pass through v1.7.0 first, and AWS recommends one minor version at a time. [10] If you're coming from a version older than v1.13.2, you must replace all nodes after the update. [26]
  • CoreDNS answers every Pod's DNS lookups. Its latest version changed between 1.34 and 1.35. [11] Recent versions ship their own PodDisruptionBudget. If you created your own, the update might fail. The fix is to remove yours, or to choose overwrite as the conflict option. [11]
  • kube-proxy runs on every node, and its latest version is different for each Kubernetes minor version. [12] It must not be newer than the API server, and may be up to three minor versions older. [17]

Ask EKS which versions fit the version you're moving to, then update:

aws eks describe-addon-versions --kubernetes-version 1.35 --addon-name coredns \
  --query 'addons[].addonVersions[].{Version: addonVersion, Defaultversion: compatibilities[0].defaultVersion}' \
  --output table

aws eks update-addon --cluster-name <cluster-name> --addon-name coredns \
  --addon-version <version-number> --resolve-conflicts PRESERVE

PRESERVE keeps your custom settings. Without it, EKS overwrites them with its defaults. [9] Before each update, save the current object, for example kubectl get daemonset aws-node -n kube-system -o yaml > aws-k8s-cni-old.yaml for the VPC CNI. [26] Then don't forget the rest: the Cluster Autoscaler should match your new minor version, and GPU clusters need the NVIDIA device plugin updated. [3]

In the bus depot
A new rulebook doesn't refit the ticket machines and radios. Someone has to swap each one for a model that understands the new rules.
In the cluster
VPC CNI, CoreDNS and kube-proxy stay on their old versions until you call update-addon with a version compatible with the new minor version.

05 / The fleet

How do you replace the nodes without dropping traffic?

Nodes don't follow the control plane on their own. Managed node groups create EC2 instances in your account, and they "aren't automatically upgraded" when the control plane is. [1] You have three main ways to replace them.

A. Managed node group rolling update

You ask EKS to update the node group, and it does this for you: it raises the Auto Scaling group's size, waits for new nodes to be Ready, cordons and drains the old ones, waits 60 seconds after evicting each Pod, then terminates them. [14] The default strategy creates new nodes before terminating old ones, so you keep capacity. The minimal strategy terminates first, for cases like GPUs where you can't afford extra instances. [14]

aws eks update-nodegroup-config --cluster-name <cluster-name> \
  --nodegroup-name <nodegroup-name> --update-config maxUnavailable=2

aws eks update-nodegroup-version --cluster-name <cluster-name> \
  --nodegroup-name <nodegroup-name> --kubernetes-version 1.35

maxUnavailable sets how many nodes update at once. The default is one, and the most is 100. [14] [16] The node group version can't be newer than the control plane's. [13]

B. Blue/green node groups

You create a new node group on the new version next to the old one. Then you taint the old nodes so nothing new lands there, drain them one at a time, and delete the old group once it's empty. [15] It's slower and costs double capacity for a while. In return, you can watch the new nodes carry real traffic before the old ones go. Until you delete the old group, you can move work back by removing the taint and running kubectl uncordon on its nodes. [23]

kubectl taint nodes <node-name> key=value:NoSchedule
kubectl drain <node-name> --ignore-daemonsets --delete-emptydir-data

C. Karpenter drift

If Karpenter runs your nodes, it replaces them itself. A NodeClaim counts as drifted when it no longer matches its NodePool or EC2NodeClass, for example when amiSelectorTerms now resolve to a newer AMI. [24] Karpenter normally starts the replacement before it terminates the old node, evicts Pods through the Eviction API so PDBs hold, and limits the pace with NodePool disruption budgets. [24] Karpenter warns that the @latest AMI alias isn't recommended in production, because every new AMI release drifts all out-of-date nodes. Pin a version and move it on purpose. [25]

spec:
  disruption:
    budgets:
    - nodes: "0"
      reasons:
      - "Drifted"

A budget like that one stops new drift disruptions, which is your brake if a rollout goes wrong. It doesn't stop drains already in progress. [24]

What I'd pick

For most stateless fleets on managed node groups, the rolling update with the default strategy. For node groups running stateful or hard-to-move work, blue/green, because you choose the moment each node goes. On Karpenter, drift with a small Drifted budget and a pinned AMI.

In the bus depot
Swap buses a few at a time on each route, or park a whole new fleet beside the old one and move passengers over before retiring it.
In the cluster
Rolling update replaces nodes in place, a few at a time. Blue/green runs two node groups and drains the old one. Karpenter drift replaces nodes that no longer match.

06 / The usual failure

Why do drains stall, and what do PodDisruptionBudgets have to do with it?

A PodDisruptionBudget (PDB) limits how many Pods of an application can be down at once from voluntary disruptions, and draining a node for an upgrade is one. [20] kubectl drain and the managed node group update both evict Pods through the Eviction API, which checks the PDB. [20] If the eviction would break the budget, the API answers 429 Too Many Requests, and the drain retries. [22]

That's the safety. Here's how it turns into a stall:

  • A budget of zero. maxUnavailable: 0, or minAvailable equal to the replica count, means zero voluntary evictions. Then "the drain never completes". [21] A one-replica Deployment with minAvailable: 1 is the common case.
  • Pods that never get Ready. If new Pods don't become Ready, the Eviction API can keep answering 429 until you step in. [22] By default, the PDB waits for unhealthy Pods to become healthy before allowing evictions. [21]
  • Two budgets on one Pod. If several PDBs select the same Pod, eviction fails with a 500 error. [22]

On a managed node group, a stall has a clock. If Pods don't leave a node within 15 minutes, the update fails with PodEvictionFailure. EKS names an "aggressive PDB", or several PDBs on one Pod, as known causes. [14] You can retry with --force, which ignores PDBs and terminates the node anyway. [13] That isn't zero downtime. Fix the budget instead.

Find the problem budgets before you start:

kubectl get poddisruptionbudgets -A

-A lists every namespace. [27] Any row with ALLOWED DISRUPTIONS at 0 will block a drain at that moment. [21] Give those apps a second replica, or use maxUnavailable: 1, which Kubernetes recommends because it adapts as the replica count changes. [21] Kubernetes also recommends unhealthyPodEvictionPolicy: AlwaysAllow, so a crash-looping Pod can't hold a drain hostage. [23]

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: checkout-pdb
spec:
  maxUnavailable: 1
  unhealthyPodEvictionPolicy: AlwaysAllow
  selector:
    matchLabels:
      app: checkout

One trap from the EKS docs: lowering a managed node group's desiredSize doesn't respect PDBs at all. Nodes are terminated straight away. [13] Don't shrink the group during an upgrade.

In the bus depot
The rule says at least three buses on route 9. If route 9 only has three, no bus can ever leave for its refit.
In the cluster
A PDB that allows zero disruptions blocks every eviction, and the drain waits forever, or fails after 15 minutes on a managed node group.

07 / The rehearsal

What should a staging rehearsal prove?

AWS recommends testing your applications against a new Kubernetes version before you update production, ideally with a continuous integration workflow. [3] A rehearsal is only useful if staging looks like production in the ways that break: the same add-ons, the same node image family, the same PDBs, the same admission webhooks and controllers.

Run each hop there first, with the same commands, and check four things:

  1. Your manifests and charts apply cleanly on the new version.
  2. Every node group drains without a PodEvictionFailure.
  3. Each add-on update keeps your custom settings.
  4. Your app's error rate and latency hold while nodes roll.

If you need stronger insurance for stateful data, AWS points to AWS Backup for EKS, to restore cluster state and persistent storage if an upgrade fails. [3]

In the bus depot
Run the new rulebook on a quiet night route with the same buses first. Find out there which ticket machines jam.
In the cluster
A staging cluster with production's add-ons, node images and PDBs runs every hop before production does.

08 / The playbook

How do you run one hop from start to finish?

AWS's order is: check readiness, update the control plane, update the nodes, update other cluster apps, update the add-ons, then update clients such as kubectl. [3] Step through one hop below, from 1.34 to 1.35.

Figure 2 · One hop, 1.34 to 1.35

All 6 steps
  1. The whole hop: control plane first, then nodes, then add-ons. Verify, wait, then start the next hop to 1.36 the same way.
Order from the EKS update guide. The rollback row comes from the EKS rollback guide: nodes that match the control plane must be rolled back before it.

The commands, in order

# 0. Where are we?
kubectl version
kubectl get nodes
aws eks describe-cluster-versions

# 1. Control plane, one minor version
aws eks update-cluster-version --name <cluster-name> \
  --kubernetes-version 1.35 --region <region-code>
aws eks describe-update --name <cluster-name> \
  --region <region-code> --update-id <update-id>

# 2. Nodes (managed node group)
aws eks update-nodegroup-version --cluster-name <cluster-name> \
  --nodegroup-name <nodegroup-name> --kubernetes-version 1.35

# 3. Add-ons: repeat for vpc-cni, coredns and kube-proxy
aws eks update-addon --cluster-name <cluster-name> --addon-name kube-proxy \
  --addon-version <version-for-1.35> --resolve-conflicts PRESERVE

The control plane update takes several minutes, and once it starts you can't pause or stop it. If EKS's health checks fail, it reverts and the cluster stays on the old version. [3] It also needs up to five free IP addresses in the cluster's subnets, or it can fail. [3]

API server addresses change during the update, so your clients must reconnect cleanly. Recent kubectl and the official client libraries do this for you. [3] Old in-cluster controllers with home-made clients are the ones to check.

09 / The safety net

How do you know it worked, and what can you undo?

Check the hop landed:

aws eks describe-update --name <cluster-name> --region <region-code> --update-id <update-id>
kubectl version
kubectl get nodes -L eks.amazonaws.com/nodegroup
aws eks describe-addon --cluster-name <cluster-name> --addon-name coredns
aws eks list-insights --region <region-code> --cluster-name <cluster-name>

You want the update Successful, every node on the new version, each add-on ACTIVE with no health issues, and no insight in ERROR for the next version. [3] [26] [6] Then check the things your users feel: error rates, latency and DNS failures.

The control plane can be rolled back, for a week

The old rule was that an EKS control plane can never be downgraded. That changed. EKS now lets you roll a cluster back to the previous minor version within 7 days of an in-place upgrade. After 7 days, you can't. Your option then is a new cluster on the older version and a workload migration. [3] [4]

The limits matter more than the feature: [4]

  • Only one step back. After 1.34 to 1.35 to 1.36, you can only go back to 1.35.
  • Not after the automatic upgrade at the end of extended support. Rolling back into an extended-support version needs the EXTENDED policy, and its charges resume.
  • Add-ons, managed node groups and self-managed nodes aren't rolled back. Nodes can't be newer than the control plane, so you roll them back first.
  • etcd data is kept as it is. Resources created with APIs that the older version doesn't know can cause trouble. Rollback readiness insights check for this.

The rollback uses the same command with the previous version. Read the ROLLBACK_READINESS insights first, because ERROR or UNKNOWN ones block it. [4]

aws eks list-insights --cluster-name <cluster-name> --region <region-code> \
  --filter '{"categories": ["ROLLBACK_READINESS"]}'
aws eks update-cluster-version --name <cluster-name> \
  --kubernetes-version 1.34 --region <region-code>

--force skips the insight checks, and EKS then "can't guarantee the safety of the rollback". [4] Treat rollback as an emergency brake for the first week, not a reason to skip staging.

In the bus depot
The printer takes back last week's edition, one edition only, and only if the buses and ticket machines go back first.
In the cluster
Control plane rollback to N-1 within 7 days. You roll back nodes and add-ons yourself, and etcd keeps everything written since.

10 / The habit

How do you stop ending up here again?

Kubernetes releases a new minor version about every four months on average. [1] EKS announces the end of standard support for a version at least 60 days in advance, and sends an AWS Health notice about 12 months after the version arrived on EKS. [1] That's plenty of warning, if someone owns it.

So match the cadence: one hop roughly every four months, run through staging first, using this playbook every time. Kubernetes also suggests getting onto the latest patch of your current minor version before you upgrade, then going to the latest patch of the next one. [17]

What I'd do for the 1.34 cluster
  1. This week: rehearse 1.34 to 1.35 in staging, fix every zero-disruption PDB, and check cgroup v1 and containerd versions on custom node images.
  2. Before 2 December: run the one hop in production. That alone avoids the $0.50 per hour extended charge, and 1.35 stays in standard support until 27 March 2027.
  3. Then 1.35 to 1.36 and 1.36 to 1.37, with a few days of soak between hops. Don't try to cram all three hops into the last twelve days.

Put the next deadline in a calendar the moment you finish. On 1.37, standard support ends on 1 December 2027. [1]

Keep these names

A small glossary

Control plane
The API servers and controllers EKS runs for you. The bus depot's office.
Standard and extended support
14 months at the normal price, then 12 more at a higher hourly price.
Upgrade policy
Per-cluster setting: EXTENDED stays and pays, STANDARD is upgraded automatically.
Version skew
How far apart component versions may be. Kubelets may trail the API server by three minor versions.
Upgrade insights
EKS checks that flag upgrade problems, refreshed every 24 hours.
Managed node group
EC2 nodes that EKS creates and can update for you with a rolling replacement.
Drain
Marking a node unschedulable and evicting its Pods so it can be removed.
PodDisruptionBudget (PDB)
A limit on how many of an app's Pods voluntary disruptions may take down at once.
Drift (Karpenter)
A node that no longer matches its NodePool or EC2NodeClass, so Karpenter replaces it.
Version rollback
Returning the control plane to N-1 within 7 days of an in-place upgrade.

Check the concept

Can you explain it back?

1. Your cluster is on 1.34 and must reach 1.37. How many control plane updates is that?

Three: 1.34 to 1.35, 1.35 to 1.36, 1.36 to 1.37. EKS updates the control plane one minor version at a time.

2. The upgrade policy is EXTENDED and standard support ends tomorrow. What changes?

Nothing runs differently, but the cluster price goes from $0.10 to $0.60 an hour from the start of that day in UTC, and you can't disable extended support until you're back on a standard-support version.

3. A managed node group update fails with PodEvictionFailure. What's the first thing to check?

PodDisruptionBudgets that allow zero disruptions, or several PDBs selecting the same Pod. Pods must leave a node within 15 minutes.

4. The deprecation guide shows no removals after 1.32. Is a 1.34 to 1.37 climb safe?

Not by itself. The EKS release notes list other breaking changes on the way, such as cgroup v1, containerd 1.x, gitRepo volumes and SELinux mount labelling.

5. You upgraded to 1.35 nine days ago and found a bug. Can you roll back?

Not in place. Rollback is only open for 7 days. Now you'd fix forward, or build a new cluster on 1.34 and migrate.

Continue the thread

More on running clusters

Read further

Sources

All read on 20 November 2026. AWS and Kubernetes docs are living pages; versions, dates and prices here are as served that day.

  1. Amazon EKS User Guide: Understand the Kubernetes version lifecycle on EKS
  2. Amazon EKS pricing
  3. Amazon EKS User Guide: Update existing cluster to new Kubernetes version
  4. Amazon EKS User Guide: Roll back a cluster to a previous Kubernetes version
  5. Amazon EKS User Guide: Prepare for Kubernetes version upgrades with cluster insights
  6. Amazon EKS User Guide: View cluster insights
  7. Amazon EKS User Guide: View current cluster upgrade policy
  8. Amazon EKS User Guide: Release notes for Kubernetes versions on standard support
  9. Amazon EKS User Guide: Update an Amazon EKS add-on
  10. Amazon EKS User Guide: Assign IPs to Pods with the Amazon VPC CNI
  11. Amazon EKS User Guide: Manage CoreDNS for DNS in Amazon EKS clusters
  12. Amazon EKS User Guide: Manage kube-proxy in Amazon EKS clusters
  13. Amazon EKS User Guide: Update a managed node group for your cluster
  14. Amazon EKS User Guide: Understand each phase of node updates
  15. Amazon EKS User Guide: Migrate applications to a new node group
  16. AWS CLI Command Reference: eks update-nodegroup-config
  17. Kubernetes: Version Skew Policy
  18. Kubernetes: Deprecated API Migration Guide
  19. Kubernetes: Kubernetes Deprecation Policy
  20. Kubernetes: Disruptions
  21. Kubernetes: Specifying a Disruption Budget for your Application
  22. Kubernetes: API-initiated Eviction
  23. Kubernetes: Safely Drain a Node
  24. Karpenter docs: Disruption
  25. Karpenter docs: NodeClasses
  26. Amazon EKS User Guide: Update the Amazon VPC CNI (Amazon EKS add-on)
  27. Kubernetes: kubectl get reference

Written with AI assistance. Every technical claim was checked against the original sources listed above.