EKS Extended Support Pricing: What $0.60 an Hour Means for Your Fleet from 1 April

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.

Gantt chart of EKS versions 1.23 to 1.29 showing standard support in green and extended support in orange, with lines at 24 February 2024 and 1 April 2024 when the $0.60 rate starts
Where every version stood in February 2024.

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:

JSON14 lines
{
  "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:

Python9 lines
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:

Python15 lines
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 store

Pricing 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:

Python18 lines
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 STANDARD

The 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:

Text10 lines
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.00

Three 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:

Text4 lines
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.00

Leaving 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:

Text7 lines
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
Bar chart of one EKS cluster's control-plane cost from April 2024 to March 2025 by version: 1.24 $5,256, 1.25 $4,896, 1.26 $4,524, 1.27 $4,164, 1.28 $2,688, 1.29 $1,248
The saving only arrives from 1.28 upwards.

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:

Text6 lines
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 PriorityLevelConfiguration

The 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.

⚠️
THE APRIL DEADLINE IS ABOUT BILLING, NOT SAFETY

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.py needs only eks:ListClusters, eks:DescribeCluster and eks: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

ClusterRecommendation
1.23 or 1.24 in productionPlan the path to 1.28 or 1.29; start with PodSecurityPolicy and the 1.25 API removals
1.23 or 1.24 sandbox or unusedDelete it before April
1.25 to 1.27Already due to reach extended support this year; upgrade in the same programme
1.28Standard support until November 2024; upgrade to 1.29 when convenient
New clusterCreate it on 1.29; a new cluster on an old version pays extended support from day one
Cannot upgrade in timeBudget $0.60 an hour; the cluster stays patched and supported
📝
HOW THIS WAS CHECKED

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.

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


Discover more from C4: Container, Code, Cloud & Context

Subscribe to get the latest posts sent to your email.

Written by

Nithin Mohan TK

Hello Namaste! 👋🏻 I'm an accomplished Enterprise Solution Architect & Engineering Leader with 20+ years of progressive experience architecting, building, and scaling transformative enterprise solutions. ⚜️ Solution Architect / AI & Cloud 📌 Galway, Ireland

Leave a comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.