Find Previous-Generation EC2 Instances to Upgrade

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadInstancesAndTypes",
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeInstances",
        "ec2:DescribeInstanceTypes"
      ],
      "Resource": "*"
    },
    {
      "Sid": "ReadPriceList",
      "Effect": "Allow",
      "Action": "pricing:GetProducts",
      "Resource": "*"
    }
  ]
}

// find-previous-generation-ec2.ts
// Lists EC2 instances that run on previous-generation instance types (CurrentGeneration = false),
// suggests same-size current-generation types, and optionally compares On-Demand Linux prices.
// Read-only: it never stops, resizes or modifies an instance.
// Usage: npx tsx find-previous-generation-ec2.ts [--regions us-east-1,eu-west-1] [--prices] [--csv prev-gen.csv]
import { writeFileSync } from "node:fs";
import {
  EC2Client,
  paginateDescribeInstances,
  paginateDescribeInstanceTypes,
  type InstanceTypeInfo,
} from "@aws-sdk/client-ec2";
import { PricingClient, GetProductsCommand } from "@aws-sdk/client-pricing";

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 withPrices = args.includes("--prices");
const csvPath = flag("--csv");

// Starting points: previous-generation family -> current-generation families (x86 first, then Graviton).
// Families not listed (G3, P3, P3dn...) are reported with no suggestion. Edit to match your standards.
const UPGRADE: Record<string, string[]> = {
  t1: ["t3", "t4g"],
  m1: ["m7i", "m7g"], m3: ["m7i", "m7g"], m4: ["m7i", "m7g"],
  c1: ["c7i", "c7g"], c3: ["c7i", "c7g"], c4: ["c7i", "c7g"],
  m2: ["r7i", "r7g"], r3: ["r7i", "r7g"], r4: ["r7i", "r7g"],
  a1: ["c7g", "m7g"], i2: ["i4i"],
};

interface Row {
  Region: string;
  Instance: string;
  Name: string;
  State: string;
  Type: string;
  Hypervisor: string;
  Suggested: string;
  Note: string;
  PricePerHour?: string;
  SuggestedPerHour?: string;
}

const gib = (t?: InstanceTypeInfo): number => (t?.MemoryInfo?.SizeInMiB ?? 0) / 1024;
const vcpus = (t?: InstanceTypeInfo): number => t?.VCpuInfo?.DefaultVCpus ?? 0;
const archOf = (t?: InstanceTypeInfo): string => (t?.ProcessorInfo?.SupportedArchitectures ?? []).join("/");

// All instance types offered in the Region, keyed by name, with the current-generation flag.
async function instanceTypes(ec2: EC2Client): Promise<Map<string, InstanceTypeInfo>> {
  const types = new Map<string, InstanceTypeInfo>();
  for await (const page of paginateDescribeInstanceTypes({ client: ec2 }, { MaxResults: 100 })) {
    for (const t of page.InstanceTypes ?? []) if (t.InstanceType) types.set(t.InstanceType, t);
  }
  return types;
}

function suggest(type: string, types: Map<string, InstanceTypeInfo>): { suggested: string[]; note: string } {
  const [family = "", size = ""] = type.split(".");
  const current = types.get(type);
  const candidates = (UPGRADE[family] ?? [])
    .map((f) => types.get(`${f}.${size}`))
    .filter((t): t is InstanceTypeInfo => t !== undefined && t.CurrentGeneration === true);
  if (!candidates.length) return { suggested: [], note: "no same-size suggestion: pick a type manually" };
  const notes: string[] = [];
  for (const c of candidates) {
    const name = c.InstanceType ?? "";
    if (archOf(c) !== archOf(current)) notes.push(`${name} is ${archOf(c)}: needs an ${archOf(c)} AMI`);
    if (gib(c) < gib(current) || vcpus(c) < vcpus(current)) notes.push(`${name} has fewer vCPUs or less memory`);
  }
  if (current?.Hypervisor === "xen") notes.push("Xen to Nitro: check ENA and NVMe drivers first");
  return { suggested: candidates.map((c) => c.InstanceType ?? ""), note: notes.join("; ") };
}

// On-Demand Linux price per hour from the Price List Query API (its endpoint used here is us-east-1).
const pricing = new PricingClient({ region: "us-east-1" });
const priceCache = new Map<string, number | undefined>();
async function linuxOnDemand(region: string, type: string): Promise<number | undefined> {
  const key = `${region}/${type}`;
  if (priceCache.has(key)) return priceCache.get(key);
  const term = (Field: string, Value: string) => ({ Type: "TERM_MATCH" as const, Field, Value });
  const res = await pricing.send(new GetProductsCommand({
    ServiceCode: "AmazonEC2",
    Filters: [
      term("regionCode", region), term("instanceType", type), term("operatingSystem", "Linux"),
      term("tenancy", "Shared"), term("preInstalledSw", "NA"), term("capacitystatus", "Used"),
      term("marketoption", "OnDemand"),
    ],
    MaxResults: 10,
  }));
  let price: number | undefined;
  const list: unknown = res.PriceList;
  for (const item of Array.isArray(list) ? list : []) {
    const product = JSON.parse(String(item)) as {
      terms?: { OnDemand?: Record<string, { priceDimensions?: Record<string, { pricePerUnit?: { USD?: string } }> }> };
    };
    for (const offer of Object.values(product.terms?.OnDemand ?? {})) {
      for (const dim of Object.values(offer.priceDimensions ?? {})) {
        const usd = Number(dim.pricePerUnit?.USD);
        if (usd > 0) price = usd;
      }
    }
  }
  priceCache.set(key, price);
  return price;
}

async function scanRegion(region: string): Promise<Row[]> {
  const ec2 = new EC2Client({ region });
  const types = await instanceTypes(ec2);
  const rows: Row[] = [];
  const pages = paginateDescribeInstances(
    { client: ec2 },
    { Filters: [{ Name: "instance-state-name", Values: ["pending", "running", "stopping", "stopped"] }] },
  );
  for await (const page of pages) {
    for (const res of page.Reservations ?? []) {
      for (const inst of res.Instances ?? []) {
        const type = inst.InstanceType ?? "";
        const info = types.get(type);
        if (!info || info.CurrentGeneration !== false) continue; // current generation, or not offered any more
        const { suggested, note } = suggest(type, types);
        const row: Row = {
          Region: region,
          Instance: inst.InstanceId ?? "",
          Name: inst.Tags?.find((t) => t.Key === "Name")?.Value ?? "",
          State: inst.State?.Name ?? "",
          Type: type,
          Hypervisor: info.Hypervisor ?? "",
          Suggested: suggested.join(" / "),
          Note: note,
        };
        if (withPrices) {
          const now = await linuxOnDemand(region, type);
          const next = await Promise.all(suggested.map((s) => linuxOnDemand(region, s)));
          row.PricePerHour = now === undefined ? "n/a" : `$${now.toFixed(4)}`;
          row.SuggestedPerHour = next.map((p) => (p === undefined ? "n/a" : `$${p.toFixed(4)}`)).join(" / ");
        }
        rows.push(row);
      }
    }
  }
  return rows;
}

function toCsv(rows: Row[]): string {
  const cols: (keyof Row)[] = ["Region", "Instance", "Name", "State", "Type", "Hypervisor", "Suggested", "Note", "PricePerHour", "SuggestedPerHour"];
  const cell = (v: string | undefined) => `"${(v ?? "").replace(/"/g, '""')}"`;
  return [cols.join(","), ...rows.map((r) => cols.map((c) => cell(r[c])).join(","))].join("\n") + "\n";
}

async function main(): Promise<void> {
  const rows: Row[] = [];
  for (const region of regions) rows.push(...(await scanRegion(region)));
  console.table(rows.map(({ Note, ...shown }) => shown));
  for (const r of rows.filter((r) => r.Note)) console.log(`${r.Instance} (${r.Type}): ${r.Note}`);
  const byType = new Map<string, number>();
  for (const r of rows) byType.set(r.Type, (byType.get(r.Type) ?? 0) + 1);
  console.log(`${rows.length} instances on previous-generation types in ${regions.join(", ")}`);
  console.log("By type:", Object.fromEntries([...byType].sort((a, b) => b[1] - a[1])));
  if (withPrices) console.log("Prices: On-Demand Linux list price per hour, for comparison only.");
  if (csvPath) {
    writeFileSync(csvPath, toCsv(rows));
    console.log(`Wrote ${rows.length} rows to ${csvPath}`);
  }
  console.log("Report only: no instance was stopped or changed.");
}

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

npm install @aws-sdk/client-ec2 @aws-sdk/client-pricing
npm install --save-dev tsx typescript

# Instances on previous-generation types in two Regions
AWS_PROFILE=readonly npx tsx find-previous-generation-ec2.ts --regions us-east-1,eu-west-1

# Add On-Demand Linux prices and export a CSV
AWS_PROFILE=readonly npx tsx find-previous-generation-ec2.ts --regions us-east-1 --prices --csv prev-gen.csv

┌─────────┬─────────────┬───────────────────────┬──────────────┬───────────┬──────────────┬────────────┬───────────────────────────┬──────────────┬─────────────────────┐
│ (index) │ Region      │ Instance              │ Name         │ State     │ Type         │ Hypervisor │ Suggested                 │ PricePerHour │ SuggestedPerHour    │
├─────────┼─────────────┼───────────────────────┼──────────────┼───────────┼──────────────┼────────────┼───────────────────────────┼──────────────┼─────────────────────┤
│ 0       │ 'us-east-1' │ 'i-0a1b2c3d4e5f60718' │ 'legacy-api' │ 'running' │ 'm4.large'   │ 'xen'      │ 'm7i.large / m7g.large'   │ '$0.1000'    │ '$0.1008 / $0.0816' │
│ 1       │ 'us-east-1' │ 'i-0b2c3d4e5f6071829' │ 'batch-etl'  │ 'running' │ 'c4.xlarge'  │ 'xen'      │ 'c7i.xlarge / c7g.xlarge' │ '$0.1990'    │ '$0.1785 / $0.1450' │
│ 2       │ 'us-east-1' │ 'i-0c3d4e5f607182930' │ 'cache-old'  │ 'stopped' │ 'r4.large'   │ 'xen'      │ 'r7i.large / r7g.large'   │ '$0.1330'    │ '$0.1323 / $0.1071' │
│ 3       │ 'us-east-1' │ 'i-0d4e5f60718293a41' │ 'ml-train'   │ 'stopped' │ 'p3.2xlarge' │ 'xen'      │ ''                        │ '$3.0600'    │ ''                  │
└─────────┴─────────────┴───────────────────────┴──────────────┴───────────┴──────────────┴────────────┴───────────────────────────┴──────────────┴─────────────────────┘
i-0a1b2c3d4e5f60718 (m4.large): m7g.large is arm64: needs an arm64 AMI; Xen to Nitro: check ENA and NVMe drivers first
i-0b2c3d4e5f6071829 (c4.xlarge): c7g.xlarge is arm64: needs an arm64 AMI; Xen to Nitro: check ENA and NVMe drivers first
i-0c3d4e5f607182930 (r4.large): r7g.large is arm64: needs an arm64 AMI; Xen to Nitro: check ENA and NVMe drivers first
i-0d4e5f60718293a41 (p3.2xlarge): no same-size suggestion: pick a type manually; Xen to Nitro: check ENA and NVMe drivers first
4 instances on previous-generation types in us-east-1
By type: { 'm4.large': 1, 'c4.xlarge': 1, 'r4.large': 1, 'p3.2xlarge': 1 }
Prices: On-Demand Linux list price per hour, for comparison only.
Wrote 4 rows to prev-gen.csv
Report only: no instance was stopped or changed.