Find RDS and Aurora Databases on Extended Support

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadRdsLifecycleAndInstances",
      "Effect": "Allow",
      "Action": [
        "rds:DescribeDBMajorEngineVersions",
        "rds:DescribeDBEngineVersions",
        "rds:DescribeDBInstances",
        "rds:DescribeDBClusters",
        "ec2:DescribeInstanceTypes"
      ],
      "Resource": "*"
    }
  ]
}

// find-rds-databases-on-extended-support.ts
// Report only. Lists RDS for MySQL / PostgreSQL instances and Aurora cluster instances whose major engine
// version is in RDS Extended Support (or reaches it within --days), with lifecycle dates, enrollment setting,
// vCPUs and an estimated monthly Extended Support charge. Nothing is modified.
// Usage:
//   npx tsx find-rds-databases-on-extended-support.ts [--regions us-east-1,eu-west-1] [--days 180]
//     [--rate-y1 0.100] [--rate-y3 0.200]
import {
  RDSClient,
  DescribeDBEngineVersionsCommand,
  paginateDescribeDBClusters,
  paginateDescribeDBInstances,
  paginateDescribeDBMajorEngineVersions,
} from "@aws-sdk/client-rds";
import { EC2Client, DescribeInstanceTypesCommand, type _InstanceType } from "@aws-sdk/client-ec2";

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") ?? "180");
// Per vCPU-hour, US East (N. Virginia), from the AWS Price List API (September 2026). Other Regions differ.
const rateYear1And2 = Number(flag("--rate-y1") ?? "0.100");
const rateYear3 = Number(flag("--rate-y3") ?? "0.200");
const HOURS_PER_MONTH = 730;
const DAY_MS = 86_400_000;
const ENGINES = new Set(["mysql", "postgres", "aurora-mysql", "aurora-postgresql"]);
let estimatedTotal = 0;

interface Lifecycle {
  standardEnd?: Date;
  extendedStart?: Date;
  extendedEnd?: Date;
}

interface Row {
  Region: string;
  Instance: string;
  Engine: string;
  Major: string;
  Status: string;
  StandardEnds: string;
  ExtendedEnds: string;
  Enrollment: string;
  vCPUs: string;
  EstPerMonth: 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));

// Lifecycle dates per engine and major version, e.g. "postgres|13".
async function lifecycles(rds: RDSClient): Promise<Map<string, Lifecycle>> {
  const map = new Map<string, Lifecycle>();
  for await (const page of paginateDescribeDBMajorEngineVersions({ client: rds }, {})) {
    for (const v of page.DBMajorEngineVersions ?? []) {
      const entry: Lifecycle = {};
      for (const l of v.SupportedEngineLifecycles ?? []) {
        if (l.LifecycleSupportName === "open-source-rds-standard-support") entry.standardEnd = l.LifecycleSupportEndDate;
        if (l.LifecycleSupportName === "open-source-rds-extended-support") {
          entry.extendedStart = l.LifecycleSupportStartDate;
          entry.extendedEnd = l.LifecycleSupportEndDate;
        }
      }
      map.set(`${v.Engine}|${v.MajorEngineVersion}`, entry);
    }
  }
  return map;
}

// Asks RDS which major version an engine version belongs to instead of parsing version strings.
async function majorVersion(rds: RDSClient, cache: Map<string, string>, engine: string, version: string) {
  const key = `${engine}|${version}`;
  if (!cache.has(key)) {
    const out = await rds.send(
      new DescribeDBEngineVersionsCommand({ Engine: engine, EngineVersion: version, IncludeAll: true }),
    );
    cache.set(key, out.DBEngineVersions?.[0]?.MajorEngineVersion ?? "?");
  }
  return cache.get(key) ?? "?";
}

// vCPUs of a DB instance class, taken from the matching EC2 instance type (db.r6g.large -> r6g.large).
async function vcpus(ec2: EC2Client, cache: Map<string, number | undefined>, dbClass: string) {
  if (!cache.has(dbClass)) {
    let count: number | undefined;
    try {
      const out = await ec2.send(
        new DescribeInstanceTypesCommand({ InstanceTypes: [dbClass.replace(/^db\./, "") as _InstanceType] }),
      );
      count = out.InstanceTypes?.[0]?.VCpuInfo?.DefaultVCpus;
    } catch {
      count = undefined; // RDS-only classes have no EC2 equivalent
    }
    cache.set(dbClass, count);
  }
  return cache.get(dbClass);
}

async function scanRegion(region: string): Promise<Row[]> {
  const rds = new RDSClient({ region });
  const ec2 = new EC2Client({ region });
  const dates = await lifecycles(rds);
  const majors = new Map<string, string>();
  const cpuCache = new Map<string, number | undefined>();
  const clusterEnrollment = new Map<string, string>();
  for await (const page of paginateDescribeDBClusters({ client: rds }, {})) {
    for (const c of page.DBClusters ?? []) {
      if (c.DBClusterIdentifier) clusterEnrollment.set(c.DBClusterIdentifier, c.EngineLifecycleSupport ?? "?");
    }
  }

  const rows: Row[] = [];
  const now = Date.now();
  for await (const page of paginateDescribeDBInstances({ client: rds }, {})) {
    for (const db of page.DBInstances ?? []) {
      const engine = db.Engine ?? "";
      if (!ENGINES.has(engine) || !db.EngineVersion) continue;
      const major = await majorVersion(rds, majors, engine, db.EngineVersion);
      const life = dates.get(`${engine}|${major}`) ?? {};
      const stdEnd = life.standardEnd?.getTime();
      const inExtended = stdEnd !== undefined && now > stdEnd;
      const daysLeft = stdEnd !== undefined ? Math.ceil((stdEnd - now) / DAY_MS) : undefined;
      if (!inExtended && (daysLeft === undefined || daysLeft > warnDays)) continue;

      const enrollment = db.DBClusterIdentifier
        ? clusterEnrollment.get(db.DBClusterIdentifier) ?? "?"
        : db.EngineLifecycleSupport ?? "?";
      const dbClass = db.DBInstanceClass ?? "?";
      let cpuText = "?";
      let estimate = "-";
      if (dbClass === "db.serverless") {
        cpuText = "ACU-based";
        if (inExtended) estimate = "per ACU-hour";
      } else {
        const cpu = await vcpus(ec2, cpuCache, dbClass);
        // Multi-AZ instance deployments pay for the standby too; cluster members are listed one by one.
        const copies = db.MultiAZ && !db.DBClusterIdentifier ? 2 : 1;
        if (cpu !== undefined) {
          cpuText = copies === 2 ? `${cpu} x2 (Multi-AZ)` : String(cpu);
          if (inExtended) {
            // Year 3 pricing starts two years after Extended Support starts.
            const year3Start = life.extendedStart ? new Date(life.extendedStart) : undefined;
            year3Start?.setUTCFullYear(year3Start.getUTCFullYear() + 2);
            const year3 = year3Start ? now >= year3Start.getTime() : false;
            const monthly = cpu * copies * (year3 ? rateYear3 : rateYear1And2) * HOURS_PER_MONTH;
            estimatedTotal += monthly;
            estimate = `$${monthly.toFixed(2)}${year3 ? " (year 3)" : ""}`;
          }
        }
      }

      rows.push({
        Region: region,
        Instance: db.DBInstanceIdentifier ?? "?",
        Engine: `${engine} ${db.EngineVersion}`,
        Major: major,
        Status: inExtended ? "EXTENDED SUPPORT" : `standard ends in ${daysLeft} days`,
        StandardEnds: day(life.standardEnd),
        ExtendedEnds: day(life.extendedEnd),
        Enrollment: enrollment.replace("open-source-rds-", ""),
        vCPUs: cpuText,
        EstPerMonth: estimate,
      });
    }
  }
  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;
    }
  }
  if (rows.length) console.table(rows);
  const charged = rows.filter((r) => r.Status === "EXTENDED SUPPORT").length;
  console.log(`${charged} instances in Extended Support, ${rows.length - charged} reaching it within ${warnDays} days.`);
  console.log(`Estimated Extended Support charge: about $${estimatedTotal.toFixed(2)}/month (vCPU-priced instances only).`);
  console.log("Report only: nothing was modified.");
}

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

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

AWS_PROFILE=readonly npx tsx find-rds-databases-on-extended-support.ts --regions us-east-1,eu-west-1 --days 180

┌─────────┬─────────────┬───────────────┬─────────────────────────────┬───────┬─────────────────────────────┬──────────────┬──────────────┬────────────────────┬───────────────────┬────────────────────┐
│ (index) │ Region      │ Instance      │ Engine                      │ Major │ Status                      │ StandardEnds │ ExtendedEnds │ Enrollment         │ vCPUs             │ EstPerMonth        │
├─────────┼─────────────┼───────────────┼─────────────────────────────┼───────┼─────────────────────────────┼──────────────┼──────────────┼────────────────────┼───────────────────┼────────────────────┤
│ 0       │ 'us-east-1' │ 'orders-db'   │ 'mysql 8.0.46'              │ '8.0' │ 'EXTENDED SUPPORT'          │ '2026-07-31' │ '2029-07-31' │ 'extended-support' │ '4 x2 (Multi-AZ)' │ '$584.00'          │
│ 1       │ 'us-east-1' │ 'legacy-cms'  │ 'mysql 5.7.44-rds.20260902' │ '5.7' │ 'EXTENDED SUPPORT'          │ '2024-02-29' │ '2029-06-30' │ 'extended-support' │ '2'               │ '$292.00 (year 3)' │
│ 2       │ 'us-east-1' │ 'reporting-1' │ 'aurora-postgresql 13.23'   │ '13'  │ 'EXTENDED SUPPORT'          │ '2026-02-28' │ '2029-02-28' │ 'extended-support' │ 'ACU-based'       │ 'per ACU-hour'     │
│ 3       │ 'eu-west-1' │ 'billing-pg'  │ 'postgres 14.24'            │ '14'  │ 'standard ends in 153 days' │ '2027-02-28' │ '2030-02-28' │ 'extended-support' │ '2'               │ '-'                │
└─────────┴─────────────┴───────────────┴─────────────────────────────┴───────┴─────────────────────────────┴──────────────┴──────────────┴────────────────────┴───────────────────┴────────────────────┘
3 instances in Extended Support, 1 reaching it within 180 days.
Estimated Extended Support charge: about $876.00/month (vCPU-priced instances only).
Report only: nothing was modified.