
AWS service end-of-support dates: open dataset
Open JSON dataset of AWS service lifecycle dates for nine services: end-of-support and Extended Support timelines, post-deprecation behavior, sources.
AWS service end-of-support dates: open dataset
Updated 2026-10-21 - fully revised for v2.0. AWS has since made the AWS Health Version Catalog API (DescribeServiceLifecycle) generally available, a first-party source for service version lifecycle dates. We rebuilt this dataset on that API so the dates are now first-party and authoritative, and enriched it with a normalizedserviceCode, a parsedengine/versionNumber, a computedstatus, and a per-eventbehaviorblock for what actually happens when support ends. This is a breaking change (the data is now a flatentries[]array). If you pinned to a v1.x release tag you are unaffected; v2 is the recommended path. See the CHANGELOG and the migration guide . Coming next: operational and security metadata, a release change log, and monthly update automation, see the roadmap .
Today we are releasing a major update to aws-service-eol-data , a machine-readable JSON dataset that consolidates AWS service version lifecycle dates into a single file. Version 2.0 is rebuilt on the structure of the GA AWS Health Version Catalog API (
DescribeServiceLifecycle ) and enriches it with a normalized serviceCode , a parsed engine and versionNumber , a computed status , and per-event behavior , so you can integrate lifecycle intelligence programmatically into your FinOps platforms, ITSM systems, compliance dashboards, CI/CD pipelines, and upgrade-planning workflows.What's in the dataset
data/eol.json contains a flat array of per-version entries , 313 versions across 11 AWS services. 289 come straight from the API; 24 versions the API does not return yet (13 deprecated Lambda runtimes, Aurora PostgreSQL 18, Aurora MySQL 8.4, and 9 Amazon MQ versions) come from AWS documentation and are marked DOCS_CRAWLED with the page they came from:- Amazon EKS (Kubernetes versions)
- Amazon RDS (MySQL, PostgreSQL, MariaDB)
- Amazon Aurora (MySQL, PostgreSQL)
- AWS Lambda (Python, Node.js, Java, .NET, Ruby, Go, and OS-only runtimes)
- Amazon ElastiCache (Redis OSS, Valkey)
- Amazon OpenSearch Service (OpenSearch and Elasticsearch legacy)
- Amazon MSK (Apache Kafka)
- Amazon DocumentDB
- Amazon EMR (release series)
- Amazon MQ (ActiveMQ, RabbitMQ)
- Amazon Bedrock (foundation models)
For each version you get:
-
service,serviceCode(normalized, e.g.rdsvsrds-aurora),engine,version(the raw API id), andversionNumber(the parsed bare version)
- a computed
status(STANDARD_SUPPORT,EXTENDED_SUPPORT,DEPRECATED,END_OF_LIFE)
- the full
lifecycleEventslist (standard/extended support end, end of life, resource-create/update blocks) with per-event dates, regions, and impact risks
- a per-event
behaviorblock: what actually happens at that milestone (CHARGES_APPLY,AUTO_UPGRADE,DOMAIN_ISOLATED,RUNS_UNPATCHED,CREATE_BLOCKED, and more), including conditional outcomes that depend on a per-resource setting
-
provenance(source, confidence, sourceUrl, lastVerified)
The headline change from v1: the dataset now mirrors the native API's event structure and adds the one thing the API cannot express, what happens to your resources when support ends, service by service.
Examples of use cases
- Upgrade planning and roadmaps - see which versions are approaching or past end of standard support and schedule upgrades before they hit Extended Support.
- Dashboards and reports - power reporting in any BI tool on lifecycle exposure across the fleet, each date traceable to the AWS Health Version Catalog or a cited AWS page.
- CI/CD gates - warn or block a pipeline that deploys a runtime or engine version that is end of life or nearing end of support.
- Change management - feed structured lifecycle dates into approval processes so upgrades are planned ahead of the deadline.
- Security and compliance - audit the fleet against a "no unsupported versions" policy with citable dates.
- ITSM integration - auto-raise tickets when a version enters Extended Support or reaches end of life.
- Fleet and account audits - join your running versions against the lifecycle dates to find exposure.
- Agents and chatbots - answer "when does X lose support, and what happens if I don't upgrade?" from a structured source with a citation.
- Pair with aws-service-extended-support-pricing to answer "when does my version lose support, and what will it cost if I stay on it?"
Quick start
git clone https://github.com/awslabs/aws-service-eol-data.gitcd aws-service-eol-dataDates live in events; recompute status at read time
Dates are inside
lifecycleEvents , and status is a build-time snapshot. For automated decisions, recompute status from the events:def status_from_events(events, today): d = {e["lifecycleEventType"]: e["date"] for e in events if e.get("date")} se = d.get("STANDARD_SUPPORT_END") or d.get("END_OF_SUPPORT") ee = d.get("EXTENDED_SUPPORT_END") eol = d.get("END_OF_LIFE") if eol and today >= eol: return "END_OF_LIFE" if ee: if today >= ee: return "END_OF_LIFE" if se and today >= se: return "EXTENDED_SUPPORT" return "STANDARD_SUPPORT" if se and today >= se: return "DEPRECATED" return "STANDARD_SUPPORT"Example 1: RDS instances approaching end of support
import json, boto3from datetime import datetime
with open("data/eol.json") as f: data = json.load(f)today = datetime.now().strftime("%Y-%m-%d")lookup = {(e["serviceCode"], e.get("engine"), e["versionNumber"]): e for e in data["entries"]}
rds = boto3.client("rds")for page in rds.get_paginator("describe_db_instances").paginate(): for db in page["DBInstances"]: engine = "postgresql" if "postgres" in db["Engine"] else "mysql" if "mysql" in db["Engine"] else db["Engine"] service_code = "rds-aurora" if db["Engine"].startswith("aurora") else "rds" major = db["EngineVersion"].split(".")[0] if engine == "postgresql" else ".".join(db["EngineVersion"].split(".")[:2]) info = lookup.get((service_code, engine, major)) if info: st = status_from_events(info["lifecycleEvents"], today) if st != "STANDARD_SUPPORT": print(f"{db['DBInstanceIdentifier']}: {service_code} {engine} {major} is {st}")Example 2: scan EKS clusters across all regions
import boto3, jsonwith open("data/eol.json") as f: data = json.load(f)eks_versions = {e["versionNumber"]: e for e in data["entries"] if e["serviceCode"] == "eks"}
ec2 = boto3.client("ec2")for region in [r["RegionName"] for r in ec2.describe_regions()["Regions"]]: eks = boto3.client("eks", region_name=region) try: for name in eks.list_clusters()["clusters"]: v = eks.describe_cluster(name=name)["cluster"]["version"] info = eks_versions.get(v, {}) print(name, region, v, info.get("status", "UNKNOWN")) except Exception: continueExample 3: Lambda runtime deprecation check in CI/CD
The Lambda runtime identifier is the raw
version field:RUNTIME="$1" # e.g. python3.9STATUS=$(jq -r --arg rt "$RUNTIME" \ '.entries[] | select(.serviceCode=="lambda" and .version==$rt) | .status' data/eol.json)
if [ -z "$STATUS" ] || [ "$STATUS" = "null" ]; then echo "BLOCKED: runtime $RUNTIME not found. Cannot verify support."; exit 1elif [ "$STATUS" = "DEPRECATED" ] || [ "$STATUS" = "END_OF_LIFE" ]; then echo "BLOCKED: runtime $RUNTIME is $STATUS."; exit 1else echo "OK: runtime $RUNTIME is $STATUS."fiExample 4: what happens if you don't upgrade
The
behavior block on each support-end event tells you the real outcome:for e in data["entries"]: for ev in e["lifecycleEvents"]: b = ev.get("behavior") if b: outcome = b.get("outcome") or f"{b['default']} (default; depends on {b['conditionalOn']})" print(f"{e['serviceCode']} {e['versionNumber']} @ {ev['lifecycleEventType']}: {outcome} [{b['sourceUrl']}]")For example, an OpenSearch version at end of extended support reports
DOMAIN_ISOLATED (the domain becomes unreachable until you migrate), while RDS and Aurora report AUTO_UPGRADE , and a deprecated Lambda runtime reports RUNS_UNPATCHED (it keeps running indefinitely). The API's generic "no longer available" signal hides those differences; the behavior block makes them explicit, each with a documentation link.Understanding the schema
Each entry answers three questions: when support ends (the
lifecycleEvents dates), what happens when it ends (the per-event behavior ), and how we know (the provenance and per-behavior sourceUrl ).Some behaviors are conditional on a per-resource setting. RDS and Aurora, for instance, branch at end of standard support on whether you left
EngineLifecycleSupport enabled (auto-enroll in paid Extended Support) or disabled (auto-upgrade). The dataset encodes both branches plus the default, so you can resolve the outcome for your own configuration.Two things are deliberately not stored, because they are better computed live against first-party sources:
- Cost is a join to the companion pricing dataset : each pricing entry's
matchblock names theserviceCode,engine, and (where rates differ by version)versionNumbersit prices.
- Bedrock model modality and live status are a join to
bedrock:ListFoundationModelsonmodelId(which equals a Bedrock entry'sversion). These are region-scoped, so querying your own region gives the accurate answer.
Freshness and accuracy
Dates come from the AWS Health Version Catalog (first-party) or, for documentation-sourced entries, from official docs cited in
provenance.sourceUrl . The dataset is updated monthly on a best-effort basis, sometimes more often. The top-level generatedAt tells you when it was last checked against the API, and lastUpdated when the data last changed; if generatedAt is more than 30 days old, re-verify before acting. For automated decisions, recompute status from lifecycleEvents , check API entries against the service's AWS documentation and documentation-sourced entries against their provenance.sourceUrl (API entries have none), and pin to a tagged release.This is a community-maintained dataset, not an official AWS API. We welcome reports through GitHub Issues: a wrong date or
behavior outcome, or a version the API does not cover, each with a link to the official AWS documentation.What's next
The companion Extended Support pricing dataset is available at aws-service-extended-support-pricing . Together they answer when a version loses support and what it costs to stay on it.
Get involved
- Repository: https://github.com/awslabs/aws-service-eol-data
- Companion (pricing): https://github.com/awslabs/aws-service-extended-support-pricing
- Contributions welcome: see CONTRIBUTING.md
- Found an error? Open an issue with the correct value and a source URL
We built this because our customers asked for it. If it saves you time, let us know.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article