On this page
On 16 January 2024 AWS published the price of Amazon EKS extended support. From the April 2024 billing cycle, a cluster whose Kubernetes version has left standard support costs $0.60 per hour for its control plane instead of $0.10. That is $446.40 in a 31-day month instead of $74.40, for every cluster, before a single node.
Extended support itself is not new. EKS opened a public preview on 4 October 2023 that keeps versions 1.23 and later supported for twelve months after standard support ends, and during the preview it cost nothing extra. Version 1.23 has been in extended support since 11 October 2023, and 1.24 joined it at the end of January. Five weeks from now those clusters start paying six times as much. This article works out what that means for a fleet, and why upgrading one version is a much smaller saving than it looks.
How the price works
Each Kubernetes minor version gets 14 months of standard support from the day EKS releases it, then 12 months of extended support, 26 months in all. The price depends only on the control plane’s version on each day: $0.10 per cluster per hour in standard support, $0.60 in extended. Node groups, Fargate and add-ons are billed as before. Creating a new cluster on a version already in extended support pays the higher rate from the first hour.
AWS’s own example averages the two: a cluster that stays on one version for its whole 26 months pays an average of $0.33 an hour. At the end of extended support EKS upgrades the control plane to the next version automatically. A cluster that is simply left alone therefore moves from one extended-support version to the next and keeps paying $0.60.

What the EKS API tells you
The obvious first step is to ask EKS which clusters are in extended support. In February 2024 it cannot tell you. This is what the SDK’s service model offered, printed by the sample’s tools/api_check.py with botocore 1.34.49:
{
"botocore": "1.34.49",
"Cluster fields mentioning support or upgrade": [],
"operations with Version or Insight in the name": [
"DescribeAddonVersions",
"DescribeInsight",
"ListInsights",
"UpdateClusterVersion",
"UpdateNodegroupVersion"
],
"InsightCategory": [
"UPGRADE_READINESS"
]
}DescribeCluster returns the version, the platform version, creation time and tags, but no support status and no end-of-support date. So an audit has to carry the calendar itself. The sample encodes it as AWS published it, with exact days for 1.23 and 1.24 and months only for the later versions:
CALENDAR = {v.version: v for v in (
VersionDates("1.23", date(2022, 8, 11), date(2023, 10, 11), date(2024, 10, 11)),
VersionDates("1.24", date(2022, 11, 15), date(2024, 1, 31), date(2025, 1, 31)),
VersionDates("1.25", date(2023, 2, 21), date(2024, 5, 1), date(2025, 5, 1), month_only=True),
VersionDates("1.26", date(2023, 4, 11), date(2024, 6, 1), date(2025, 6, 1), month_only=True),
VersionDates("1.27", date(2023, 5, 24), date(2024, 7, 1), date(2025, 7, 1), month_only=True),
VersionDates("1.28", date(2023, 9, 26), date(2024, 11, 1), date(2025, 11, 1), month_only=True),
VersionDates("1.29", date(2024, 1, 23), date(2025, 3, 1), date(2026, 3, 1), month_only=True),
)}For 1.25 to 1.29 AWS gave months, not days, so the table uses the first of the month and marks those rows. Treat them as “no later than” and check the calendar again before you plan an upgrade weekend around one.
What the API does have is upgrade insights, generally available since 20 December 2023. Once a day EKS reads the cluster’s audit logs and reports deprecated API calls that would break the next upgrade. The audit keeps only the checks that are not passing:
def upgrade_insights(eks, name: str) -> list[dict]:
"""Upgrade-readiness insights that are not passing (EKS upgrade insights, GA 20 December 2023)."""
found = []
try:
pages = eks.get_paginator("list_insights").paginate(
clusterName=name, filter={"categories": ["UPGRADE_READINESS"]})
for page in pages:
for item in page.get("insights", []):
status = (item.get("insightStatus") or {}).get("status")
if status != "PASSING":
found.append({"name": item.get("name"), "kubernetesVersion": item.get("kubernetesVersion"),
"status": status})
except (ClientError, NotImplementedError) as err: # older SDK mocks, missing permission
found.append({"name": "insights unavailable", "status": str(err).split(":")[-1].strip()[:80]})
return found%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#FFF3E0', 'primaryTextColor': '#232F3E', 'primaryBorderColor': '#FF9900', 'lineColor': '#232F3E', 'clusterBkg': '#F8FAFC', 'clusterBorder': '#CBD5E1', 'edgeLabelBackground': '#FFFFFF', 'nodeTextColor': '#232F3E'}}}%%
flowchart TD
A["Every Region<br/>eks:ListClusters, DescribeCluster"] --> B["Version from the API<br/>no support status field"]
B --> C["Support calendar<br/>as AWS published it"]
C --> D["Rate per day<br/>$0.10 or $0.60 from 1 April 2024"]
D --> E["12-month outlook per cluster<br/>auto-upgrade at end of extended"]
B --> F["Upgrade insights<br/>eks:ListInsights, not passing"]
E --> G["Fleet plans priced"]
F --> G
classDef compute fill:#FFF3E0,stroke:#FF9900,stroke-width:2px,color:#232F3E
classDef data fill:#EBF8FF,stroke:#0073BB,stroke-width:2px,color:#004C74
classDef store fill:#F0FFF4,stroke:#1D8102,stroke-width:2px,color:#145202
classDef alert fill:#FEF2F2,stroke:#D13212,stroke-width:2px,color:#991B1B
class A,B,C data
class D,E,F compute
class G storePricing a cluster day by day
A monthly estimate needs two details that are easy to get wrong. A version can leave standard support in the middle of a month, so the rate is worked out per day. And a cluster at the end of extended support does not stop costing money; it is upgraded to the next version, which may itself be in extended support:
def effective_version(version: str, on: date) -> str:
"""At the end of extended support EKS upgrades the control plane to the next version.
Follow that chain, so a cluster left alone is priced on the version it will actually run.
"""
while support_status(version, on) == "ended":
nxt = f"1.{int(version.split('.')[1]) + 1}"
if nxt not in CALENDAR:
break
version = nxt
return version
def hourly_rate(version: str, on: date) -> Decimal:
version = effective_version(version, on)
if support_status(version, on) == "extended" and on >= EXTENDED_PRICE_FROM:
return EXTENDED
return STANDARDThe tests pin the arithmetic: 744 hours of 1.24 in March 2024 cost $74.40 because the new price has not started; April costs $432.00. A 1.23 cluster in October 2024 spends ten days on 1.23 and the rest on 1.24 after the automatic upgrade, and pays $446.40 for the month either way. Over the twelve months from February 2024 a 1.29 cluster costs $878.40, not $876, because 2024 is a leap year.
Test setup
The demo is a made-up fleet of eight clusters in two Regions, created in moto 5.0.2 and audited with boto3 1.34.49, the versions available on 23 February 2024. moto does not implement ListInsights, so the insights code is tested with botocore’s Stubber against the real response shape, and the audit records “insights unavailable” rather than failing when a Region or a mock cannot answer. All 14 tests passed in GitHub Actions on Python 3.12.
Test results
The audit on 24 February 2024. The last column is each cluster’s control-plane cost from April 2024 to March 2025 if nobody upgrades it:
Audit on 2024-02-24
cluster region ver status extended from steps Apr 24-Mar 25
sandbox us-east-1 1.23 extended 2024-02-24 6 5256.00
payments-prod eu-west-1 1.24 extended 2024-02-24 5 5256.00
payments-staging eu-west-1 1.24 extended 2024-02-24 5 5256.00
data-prod eu-west-1 1.25 standard 2024-05-01 4 4896.00
platform-tools eu-west-1 1.26 standard 2024-06-01 3 4524.00
web-prod us-east-1 1.27 standard 2024-07-01 2 4164.00
web-dev us-east-1 1.28 standard 2024-11-01 1 2688.00
new-svc us-east-1 1.29 standard 2025-03-01 0 1248.00Three clusters are already in extended support and will pay $0.60 from 1 April. Four more cross over during the year. Only the 1.29 cluster stays in standard support for most of it. Three plans for the fleet:
Plans, control plane only, April 2024 to March 2025
Leave every cluster where it is $ 33288.00
Upgrade 1.23 and 1.24 to 1.25 by 31 March $ 32208.00
Every cluster on 1.29 by 31 March $ 9984.00Leaving everything alone costs $33,288 for the year. Moving the 1.23 and 1.24 clusters up to 1.25, the smallest step that gets them out of extended support today, saves only $1,080. Moving everything to 1.29 by the end of March costs $9,984, a saving of $23,304. The reason is in the next table.
Why one step up is not enough
This is one cluster’s cost over the same twelve months, by the version it runs from 1 April 2024:
One cluster, April 2024 to March 2025, by the version it runs from 1 April
1.24 $ 5256.00 months with extended support charges: 12
1.25 $ 4896.00 months with extended support charges: 11
1.26 $ 4524.00 months with extended support charges: 10
1.27 $ 4164.00 months with extended support charges: 9
1.28 $ 2688.00 months with extended support charges: 5
1.29 $ 1248.00 months with extended support charges: 1
Moving a 1.24 cluster to 1.25 saves $360 a year, because 1.25 leaves standard support in May 2024 and the cluster is paying $0.60 again a month later. Every version up to 1.27 is in extended support for most of the year. The saving starts at 1.28 and is close to complete at 1.29, which is still billed at the higher rate in its last month, March 2025. A full year in standard support would be $876.
The 1 April date is not a cliff either. A 1.24 cluster that reaches 1.29 at the end of May instead of the end of March pays the higher rate for those two extra months only: $360 more for April and $372 for May, the gap between $0.60 and $0.10 an hour. Finishing the programme properly in June costs a few hundred dollars per cluster; stopping at 1.25 in March costs most of the year’s saving. When a deadline and a sound upgrade conflict, the arithmetic favours the sound upgrade.
Budget conversations tend to treat an upgrade as one piece of work with one saving. Here the saving depends on how far the cluster goes. Teams that upgrade one version at a time, a quarter apart, will pay extended support on almost every cluster almost all the time.
How the cost scales
One cluster in extended support for a whole year costs $5,256 against $876 in standard support, a difference of $4,380: 8,760 hours at the $0.50 difference in rate. That is small next to the nodes behind a production cluster, which is why it is easy to wave through. It grows with the habits most organisations have. A service with development, staging and production clusters pays it three times. An organisation that gives each team its own account, and each account its own cluster per Region, pays it per team and per Region. Twenty forgotten 1.24 clusters cost $105,120 over the year, where the same twenty on a version in standard support would cost $17,520.
Those forgotten clusters matter more than the busy ones. A busy production cluster will be upgraded because someone owns it. The proof of concept from 2022, the load-test cluster nobody deleted, and the copy of production made for an audit are the clusters still on 1.23 and 1.24, and nobody is watching their bill.
Running the audit across an organisation
The audit is read-only and needs three permissions: eks:ListClusters, eks:DescribeCluster and eks:ListInsights. In an AWS Organization, put them in a role that every member account trusts from a central audit account, assume it per account, and run the audit for each Region you use. A Region where the role is denied or EKS is not available is logged and skipped rather than ending the run, so check the log for gaps before trusting the totals. The JSON output has one record per cluster with its version, support status, the date it enters extended support, the number of upgrade steps to 1.29, and twelve months of cost, ready to join to your account and tag data so each team sees its own clusters.
The upgrade path
EKS upgrades a control plane one minor version per update, so 1.24 to 1.29 is five upgrades, each followed by node groups and add-ons. These are the API versions Kubernetes stopped serving along the way, from the Kubernetes deprecation guide, as the sample prints them:
Upgrade steps from 1.24 to 1.29
-> 1.25: policy/v1beta1 PodSecurityPolicy (no replacement API; use Pod Security Admission); batch/v1beta1 CronJob; discovery.k8s.io/v1beta1 EndpointSlice; events.k8s.io/v1beta1 Event; autoscaling/v2beta1 HorizontalPodAutoscaler; policy/v1beta1 PodDisruptionBudget; node.k8s.io/v1beta1 RuntimeClass
-> 1.26: flowcontrol.apiserver.k8s.io/v1beta1 FlowSchema and PriorityLevelConfiguration; autoscaling/v2beta2 HorizontalPodAutoscaler
-> 1.27: storage.k8s.io/v1beta1 CSIStorageCapacity
-> 1.28: no API removals
-> 1.29: flowcontrol.apiserver.k8s.io/v1beta2 FlowSchema and PriorityLevelConfigurationThe 1.25 step is the hard one. PodSecurityPolicy has no replacement API, so clusters that still rely on it need Pod Security Admission or a policy engine in place first, and several beta APIs that older Helm charts still use disappear at once. After that, 1.26 to 1.29 remove only flow control and storage capacity versions that few applications call directly. Upgrade insights will show which of these a cluster still uses, from its last 30 days of audit logs.
Nothing breaks on 1 April. Clusters in extended support keep receiving security patches for the control plane. The date only changes the price. Do not rush a 1.24 to 1.25 upgrade past a PodSecurityPolicy dependency to save $30 a month; plan the jump to 1.28 or 1.29 properly instead.
What to do before 1 April
- List every cluster and its version in every Region. The sample’s
tools/audit_account.pyneeds onlyeks:ListClusters,eks:DescribeClusterandeks:ListInsights. - Look for clusters nobody owns. Sandboxes and proofs of concept on old versions are the easiest saving: delete them.
- Plan to 1.28 or 1.29, not to the next version. Each step is a change window; a plan that ends on 1.25 pays for most of them and saves little.
- Read upgrade insights first. Fix deprecated API use before the 1.25 step, and remember the insight reads 30 days of audit logs, so a fixed client can still show as an error for a while.
- Upgrade node groups and add-ons after each control-plane step. The control plane decides the price, but CoreDNS, kube-proxy and the VPC CNI each have version requirements.
- Tag and report the cost. From April, extended support will appear as its own usage type on the bill; put the per-cluster number in front of the team that owns the cluster.
Decision framework
| Cluster | Recommendation |
|---|---|
| 1.23 or 1.24 in production | Plan the path to 1.28 or 1.29; start with PodSecurityPolicy and the 1.25 API removals |
| 1.23 or 1.24 sandbox or unused | Delete it before April |
| 1.25 to 1.27 | Already due to reach extended support this year; upgrade in the same programme |
| 1.28 | Standard support until November 2024; upgrade to 1.29 when convenient |
| New cluster | Create it on 1.29; a new cluster on an old version pays extended support from day one |
| Cannot upgrade in time | Budget $0.60 an hour; the cluster stays patched and supported |
The sample ran in GitHub Actions (run) on Python 3.12 with boto3 and botocore 1.34.49, moto 5.0.2 and pytest 8.0.1, the versions available on 23 February 2024. All 14 tests passed, and the audit, plan, per-version and upgrade-step outputs above are copied from that run. The fleet is made up and no real account was used. Prices, dates and the calendar come from the AWS pricing post of 16 January 2024 and the EKS release calendar; dates given only as months are drawn from the first of the month. Control-plane cost only: nodes, Fargate and data transfer are not included.
Key takeaways
- From the April 2024 billing cycle an EKS cluster on a version in extended support pays $0.60 per hour for its control plane, six times the standard $0.10.
- In February 2024 the EKS API does not say whether a cluster is in extended support; an audit needs its own copy of the calendar.
- Upgrading a 1.24 cluster to 1.25 saves only $360 over the next twelve months, because 1.25 reaches extended support in May.
- The real saving starts at 1.28 and is nearly complete at 1.29; plan the whole path, not the next step.
- Nothing stops working on 1 April; extended support is still supported, it just costs more.
If your fleet looks different, run the audit against it and let me know in the comments below what it found.
The complete sample for this article is on GitHub: nithinmohantk/blog-samples-working-repo/eks-extended-support-cost. Clone it with git clone https://github.com/nithinmohantk/blog-samples-working-repo.git and open the eks-extended-support-cost folder. Its README says how to run it and what has been verified.
Glossary
- Amazon EKS
- AWS’s managed Kubernetes service; AWS runs the control plane and charges per cluster-hour for it.
- Control plane
- The Kubernetes API server, etcd and controllers; on EKS its version sets the hourly price.
- Standard support
- The first 14 months after EKS releases a Kubernetes minor version; $0.10 per cluster-hour.
- Extended support
- The 12 months after standard support ends; $0.60 per cluster-hour from April 2024.
- Minor version
- The second number in a Kubernetes version, such as 1.24; EKS upgrades one minor version at a time.
- Platform version
- EKS’s own revision of a cluster’s control plane within a Kubernetes minor version.
- Upgrade insights
- EKS checks, from the cluster’s audit logs, for issues that would affect the next upgrade, such as deprecated API use.
- PodSecurityPolicy
- A Kubernetes admission API removed in 1.25; Pod Security Admission replaces its built-in use.
- Pod Security Admission
- The built-in admission controller that enforces Pod Security Standards from namespace labels.
- moto
- A Python library that mocks AWS APIs for tests.
References & Further Reading
- → Amazon EKS extended support for Kubernetes versions pricing— AWS Containers blog, 16 January 2024: prices, scenarios and calendar
- → Amazon EKS Kubernetes versions— The release calendar and version lifecycle
- → Amazon EKS now supports Kubernetes version 1.29— AWS Containers blog, 23 January 2024
- → Amazon EKS upgrade insights— What's New, 20 December 2023
- → Accelerate the testing and verification of Amazon EKS upgrades with upgrade insights— AWS Containers blog
- → Deprecated API Migration Guide— Kubernetes API versions removed in each release
- → Sample code for this article— Calendar, cost model, fleet audit, demo and tests
Discover more from C4: Container, Code, Cloud & Context
Subscribe to get the latest posts sent to your email.