Find EKS Clusters on Extended Support

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadEksVersionsAndClusters",
      "Effect": "Allow",
      "Action": [
        "eks:DescribeClusterVersions",
        "eks:ListClusters",
        "eks:DescribeCluster",
        "eks:ListInsights"
      ],
      "Resource": "*"
    }
  ]
}

// find-eks-clusters-on-extended-support.ts
// Report only. For every EKS cluster in the chosen Regions: its Kubernetes version, the version's support
// status and dates, the cluster's upgrade policy, the extra monthly cost of extended support, and how many
// upgrade-readiness insights are failing. Nothing is modified.
// Usage:
//   npx tsx find-eks-clusters-on-extended-support.ts [--regions us-east-1,eu-west-1] [--days 90] [--extra-rate 0.50]
import {
  EKSClient,
  DescribeClusterCommand,
  paginateDescribeClusterVersions,
  paginateListClusters,
  paginateListInsights,
  type ClusterVersionInformation,
} from "@aws-sdk/client-eks";

const args = process.argv.slice(2);
const flag = (name: string): string | undefined => {
  const i = args.indexOf(name);
  return i >= 0 ? args[i + 1] : undefined;
};
const regions = (flag("--regions") ?? process.env.AWS_REGION ?? "us-east-1")
  .split(",")
  .map((r) => r.trim())
  .filter(Boolean);
const warnDays = Number(flag("--days") ?? "90");
// Extended support surcharge per cluster-hour on top of standard support (US East, N. Virginia, Sep 2026).
const extraRate = Number(flag("--extra-rate") ?? "0.50");
const HOURS_PER_MONTH = 730;
const DAY_MS = 86_400_000;

interface Row {
  Region: string;
  Cluster: string;
  Version: string;
  Support: string;
  StandardEnds: string;
  ExtendedEnds: string;
  Policy: string;
  ExtraPerMonth: string;
  UpgradeInsights: string;
  Action: string;
}

const day = (d: Date | undefined): string => (d ? d.toISOString().slice(0, 10) : "?");
const errText = (err: unknown): string => (err instanceof Error ? `${err.name}: ${err.message}` : String(err));

async function versionTable(eks: EKSClient): Promise<Map<string, ClusterVersionInformation>> {
  const map = new Map<string, ClusterVersionInformation>();
  for await (const page of paginateDescribeClusterVersions({ client: eks }, { includeAll: true })) {
    for (const v of page.clusterVersions ?? []) {
      if (v.clusterVersion) map.set(v.clusterVersion, v);
    }
  }
  return map;
}

// Counts UPGRADE_READINESS insights in ERROR or WARNING for the cluster's next upgrade.
async function upgradeInsights(eks: EKSClient, clusterName: string): Promise<string> {
  let error = 0;
  let warning = 0;
  try {
    const pages = paginateListInsights(
      { client: eks },
      { clusterName, filter: { categories: ["UPGRADE_READINESS"], statuses: ["ERROR", "WARNING"] } },
    );
    for await (const page of pages) {
      for (const insight of page.insights ?? []) {
        if (insight.insightStatus?.status === "ERROR") error++;
        else warning++;
      }
    }
  } catch (err) {
    return `unavailable (${err instanceof Error ? err.name : "error"})`;
  }
  return error + warning === 0 ? "none failing" : `${error} error, ${warning} warning`;
}

async function scanRegion(region: string): Promise<Row[]> {
  const eks = new EKSClient({ region });
  const versions = await versionTable(eks);
  const rows: Row[] = [];
  const now = Date.now();

  for await (const page of paginateListClusters({ client: eks }, {})) {
    for (const name of page.clusters ?? []) {
      const { cluster } = await eks.send(new DescribeClusterCommand({ name }));
      const version = cluster?.version ?? "?";
      const info = versions.get(version);
      const policy = cluster?.upgradePolicy?.supportType ?? "?";
      const status = info?.versionStatus ?? "UNKNOWN";
      const stdEnd = info?.endOfStandardSupportDate;
      const daysToStdEnd = stdEnd ? Math.ceil((stdEnd.getTime() - now) / DAY_MS) : undefined;

      let extra = "-";
      let action = "ok";
      if (status === "EXTENDED_SUPPORT") {
        extra = `$${(extraRate * HOURS_PER_MONTH).toFixed(2)}`;
        action = `upgrade before ${day(info?.endOfExtendedSupportDate)} (auto-upgrade after)`;
      } else if (status === "STANDARD_SUPPORT" && daysToStdEnd !== undefined && daysToStdEnd <= warnDays) {
        action = policy === "STANDARD"
          ? `auto-upgrade after ${day(stdEnd)} (policy STANDARD)`
          : `enters extended support in ${daysToStdEnd} days`;
      } else if (status === "UNKNOWN") {
        action = "version not in DescribeClusterVersions";
      }

      rows.push({
        Region: region,
        Cluster: name,
        Version: version,
        Support: status,
        StandardEnds: day(stdEnd),
        ExtendedEnds: day(info?.endOfExtendedSupportDate),
        Policy: policy,
        ExtraPerMonth: extra,
        UpgradeInsights: action === "ok" ? "-" : await upgradeInsights(eks, name),
        Action: action,
      });
    }
  }
  return rows;
}

async function main(): Promise<void> {
  const rows: Row[] = [];
  for (const region of regions) {
    try {
      rows.push(...(await scanRegion(region)));
    } catch (err) {
      console.error(`${region}: ${errText(err)}`);
      process.exitCode = 1;
    }
  }
  console.table(rows);
  const extended = rows.filter((r) => r.Support === "EXTENDED_SUPPORT");
  const monthly = extended.length * extraRate * HOURS_PER_MONTH;
  console.log(
    `${rows.length} clusters checked, ${extended.length} on extended support ` +
      `(about $${monthly.toFixed(2)}/month extra at $${extraRate.toFixed(2)} per cluster-hour).`,
  );
  console.log("Report only: nothing was modified.");
}

main().catch((err) => {
  console.error(errText(err));
  process.exit(1);
});

npm install @aws-sdk/client-eks
npm install --save-dev tsx typescript @types/node

AWS_PROFILE=readonly npx tsx find-eks-clusters-on-extended-support.ts --regions us-east-1,eu-west-1 --days 90

┌─────────┬─────────────┬────────────┬─────────┬────────────────────┬──────────────┬──────────────┬────────────┬───────────────┬──────────────────────┬───────────────────────────────────────────────────┐
│ (index) │ Region      │ Cluster    │ Version │ Support            │ StandardEnds │ ExtendedEnds │ Policy     │ ExtraPerMonth │ UpgradeInsights      │ Action                                            │
├─────────┼─────────────┼────────────┼─────────┼────────────────────┼──────────────┼──────────────┼────────────┼───────────────┼──────────────────────┼───────────────────────────────────────────────────┤
│ 0       │ 'us-east-1' │ 'payments' │ '1.32'  │ 'EXTENDED_SUPPORT' │ '2026-03-23' │ '2027-03-23' │ 'EXTENDED' │ '$365.00'     │ '1 error, 1 warning' │ 'upgrade before 2027-03-23 (auto-upgrade after)'  │
│ 1       │ 'us-east-1' │ 'batch'    │ '1.34'  │ 'STANDARD_SUPPORT' │ '2026-12-02' │ '2027-12-02' │ 'STANDARD' │ '-'           │ 'none failing'       │ 'auto-upgrade after 2026-12-02 (policy STANDARD)' │
│ 2       │ 'us-east-1' │ 'web'      │ '1.36'  │ 'STANDARD_SUPPORT' │ '2027-08-02' │ '2028-08-02' │ 'EXTENDED' │ '-'           │ '-'                  │ 'ok'                                              │
│ 3       │ 'eu-west-1' │ 'reports'  │ '1.33'  │ 'EXTENDED_SUPPORT' │ '2026-07-29' │ '2027-07-29' │ 'EXTENDED' │ '$365.00'     │ 'none failing'       │ 'upgrade before 2027-07-29 (auto-upgrade after)'  │
└─────────┴─────────────┴────────────┴─────────┴────────────────────┴──────────────┴──────────────┴────────────┴───────────────┴──────────────────────┴───────────────────────────────────────────────────┘
4 clusters checked, 2 on extended support (about $730.00/month extra at $0.50 per cluster-hour).
Report only: nothing was modified.