# Kubernetes Support Radar: EKS, AKS, GKE & OpenShift EOL Costs (`cobalt_relay/kubernetes-support-radar`) Actor

Check EKS, AKS, GKE, OpenShift, Rancher and on-prem Kubernetes versions against official support dates. See days left, upgrade targets and the extra cost of paid extended support, with Slack or webhook alerts.

- **URL**: https://apify.com/cobalt_relay/kubernetes-support-radar.md
- **Developed by:** [Cobalt Relay](https://apify.com/cobalt_relay) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 cluster checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kubernetes Support Radar: EKS, AKS, GKE & OpenShift EOL Costs

**Know which Kubernetes clusters are running out of support, what you should upgrade to, and what it will cost if you don't. Covers Amazon EKS, Azure AKS, Google GKE, Red Hat OpenShift, SUSE Rancher and upstream / on-prem Kubernetes (kubeadm, k3s, RKE2, Talos).**

Managed Kubernetes versions get about 14 months of standard support. After that, the clouds either upgrade you automatically or charge for extended support, and that fee is easy to miss until the bill arrives:

| Platform | Standard support | Extended support | Extra cost |
|---|---|---|---|
| Amazon EKS | $0.10 / cluster-hour | Starts automatically, up to 12 more months | **$0.60 / cluster-hour**, about **+$365/month per cluster** |
| Azure AKS | Standard tier $0.10 / cluster-hour | Long-Term Support needs the Premium tier | Premium **$0.60 / cluster-hour**, about **+$365/month per cluster** |
| Google GKE | $0.10 / cluster-hour | Extended release channel only, up to 24 months from release | **+$0.50 / cluster-hour**, about **+$365/month per cluster** (included in GKE Enterprise) |

*List prices as of October 2026. Check each provider's pricing page for your agreement.*

### What you get

Enter your clusters, for example:

```
prod: eks 1.33 x3
staging: aks 1.33
analytics: gke 1.34
onprem: k3s 1.31
openshift 4.20
```

and get, for each one:

- **Status:** `standard`, `maintenance` (OpenShift), `extended`, `end_of_life`
- **Dates:** when standard and extended support end, and days left
- **Cost:** the extra monthly and yearly cost of extended support for that many clusters
- **Upgrade target:** the newest version, and the oldest still-supported one
- **A plain-English summary**, for example:
  > Amazon EKS 1.33 (3 clusters) is in extended support (about $1,095/month extra) until 2027-07-29 (285 days), then AWS upgrades it automatically. Upgrade to 1.37 (newest) or at least 1.34.

No clusters to enter? Leave the list empty to get every current version and its support dates for the platforms you choose.

### Alerts

Run it on a weekly schedule and add a **Slack webhook** or **webhook URL** (Zapier, Make, n8n, Teams, PagerDuty, Jira automation). You're alerted when a cluster crosses one of your thresholds (default 90, 30 and 7 days before support ends) or moves into extended support or end of life, not on every run.

### Who it's for

- **Platform and SRE teams** planning upgrades across many clusters and clouds
- **FinOps teams** finding surprise extended-support charges before they appear on the bill
- **Security and compliance teams** proving clusters run supported versions
- **Consultants and MSPs** reporting on client environments

### Input tips

- Platform names: `eks`, `aks`, `gke`, `kubernetes` (or `kubeadm`, `k3s`, `rke2`, `talos`, `on-prem`), `openshift`, `rancher`.
- Versions like `1.31`, `v1.31.4` or `1.31.4-eks-123` all work; only the minor version matters.
- `x N` counts N clusters on the same version, so the cost estimate is right.

### Output fields

`cluster`, `platform`, `version`, `clusterCount`, `status`, `attention`, `summary`, `releaseDate`, `fullSupportEnds` (OpenShift), `standardSupportEnds`, `extendedSupportEnds`, `daysUntilStandardSupportEnds`, `daysUntilExtendedSupportEnds`, `extendedSupportExtraPerMonthUsd`, `extendedSupportExtraPerYearUsd`, `latestVersion`, `oldestSupportedVersion`, `minorVersionsBehind`, `latestPatch`, `note`, `checkedAt`.

### Pricing

**$0.02 per cluster line checked** (a line like `prod: eks 1.33 x3` counts once). A weekly check of 10 lines costs under $1 a month.

### Good to know

- Lifecycle dates come from [endoflife.date](https://endoflife.date), which tracks the providers' official calendars. Providers occasionally move dates; confirm before a major decision.
- **AKS and GKE extended costs apply only if you opt in** (Premium tier with LTS, or the GKE Extended channel). Otherwise those clusters are unsupported or upgraded automatically, which the summary explains.
- **Opting out on EKS:** extended support is on by default. Setting a cluster's upgrade policy to `STANDARD` avoids the fee; AWS then auto-upgrades the control plane at the end of standard support. EKS can roll back the control plane one minor version within 7 days of an in-place upgrade.
- **Upgrade one minor version at a time.** EKS and AKS don't skip minor versions, so going from 1.31 to 1.34 means three upgrades.
- Self-managed distributions (k3s, RKE2, kubeadm, Talos) follow upstream Kubernetes versions; your vendor may offer longer support.

### Related

- [Cloud AI Change Radar](https://apify.com/cobalt_relay/cloud-ai-change-radar): alerts when AI models change on Bedrock, Azure and Vertex
- [Cloud VM Price Comparison](https://apify.com/cobalt_relay/cloud-vm-price-comparison): compare VM prices across AWS, Azure and Google Cloud

# Actor input Schema

## `clusters` (type: `array`):

One per line: optional name, platform and version, optionally 'x N' for N clusters on the same version. Examples: 'prod: eks 1.33 x3', 'aks 1.32', 'analytics: gke 1.34', 'onprem: k3s 1.31', 'openshift 4.16'. Platforms: eks, aks, gke, kubernetes (also kubeadm, k3s, rke2, talos, on-prem), openshift, rancher. Leave empty to list every supported version instead.

## `alertDays` (type: `array`):

Flag clusters when the end of their current support phase is this close. Alerts fire again as each threshold is crossed.

## `onlyNeedingAttention` (type: `boolean`):

Hide clusters that are comfortably supported.

## `platforms` (type: `array`):

With no clusters entered, list every current version of these platforms with their support dates.

## `includeEndOfLife` (type: `boolean`):

When listing versions (no clusters entered), also include versions that are already past end of support.

## `slackWebhookUrl` (type: `string`):

Optional. Post a summary when a cluster needs attention. You're notified when something changes (a new threshold is crossed or a phase changes), not on every run.

## `webhookUrl` (type: `string`):

Optional. POST the clusters needing attention as JSON (Zapier, Make, n8n, Teams workflows, PagerDuty, Jira automation).

## `notifyEveryRun` (type: `boolean`):

Send the alert every run while clusters need attention, not only when something changes.

## Actor input object example

```json
{
  "clusters": [
    "prod: eks 1.33 x3",
    "staging: aks 1.33",
    "analytics: gke 1.34",
    "onprem: k3s 1.31",
    "openshift 4.20"
  ],
  "alertDays": [
    "90",
    "30",
    "7"
  ],
  "onlyNeedingAttention": false,
  "platforms": [
    "eks",
    "aks",
    "gke"
  ],
  "includeEndOfLife": false,
  "notifyEveryRun": false
}
```

# Actor output Schema

## `clusters` (type: `string`):

Support phase, end dates, days left, upgrade targets and extended-support cost for each cluster version.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "clusters": [
        "prod: eks 1.33 x3",
        "staging: aks 1.33",
        "analytics: gke 1.34",
        "onprem: k3s 1.31",
        "openshift 4.20"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cobalt_relay/kubernetes-support-radar").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "clusters": [
        "prod: eks 1.33 x3",
        "staging: aks 1.33",
        "analytics: gke 1.34",
        "onprem: k3s 1.31",
        "openshift 4.20",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cobalt_relay/kubernetes-support-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "clusters": [
    "prod: eks 1.33 x3",
    "staging: aks 1.33",
    "analytics: gke 1.34",
    "onprem: k3s 1.31",
    "openshift 4.20"
  ]
}' |
apify call cobalt_relay/kubernetes-support-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cobalt_relay/kubernetes-support-radar"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/glKLcxmHuyrLL8iiu/builds/WJvaLQfXvd9ztcmxT/openapi.json