AWS Lambda Runtime Deprecation: Verified Dates for Node.js 20, Python 3.10 and .NET 8, and an Audit Script That Doesn't Miss Functions
AWS Lambda functions keep executing indefinitely on deprecated runtimes, but security patching, technical support, and creation/update permissions end on hard schedules. Here are the live, verified November 2026 dates for Node 20, Python 3.10, and .NET 8, six operational traps, and a paginated Python audit script that never misses functions.

TL;DR & Production Status (As of 11 November 2026)
On 11 November 2026, AWS verified updated runtime lifecycle milestones for Lambda Event Functions (AWS's updated terminology for Lambda functions). If your serverless infrastructure relies on Node.js 20, Python 3.10, or .NET 8, here is what engineering leads and platform teams must know immediately:
- Your functions keep executing indefinitely: AWS explicitly confirms that existing Lambda functions continue to invoke on deprecated runtimes without operational termination. However, security patching and AWS technical support terminate immediately upon the deprecation date. Furthermore, unpatched runtimes face eventual failure when internal root certificates expire or downstream AWS endpoints enforce modern TLS handshakes.
- The verified lifecycle dates: Node.js 20 was deprecated on 30 April 2026, and Python 3.10 was deprecated on 31 October 2026. On AWS's live documentation as of 11 November 2026, both runtimes have function creation blocked from 29 July 2027 and function updates blocked from 31 August 2027. Older articles, archived documentation, and third-party EOL tables cite obsolete dates (such as November 2026 or February 2027).
- .NET 8 and .NET 9 deprecation: Both .NET 8 and .NET 9 (container-only) were formally deprecated on 10 November 2026. .NET 8 shares the 29 July 2027 create-block and 31 August 2027 update-block schedule, while .NET 9 has no scheduled block dates.
- The Python 3.11 runway trap: Upgrading Python 3.10 to Python 3.11 only buys approximately eight months. Python 3.11 runs on Amazon Linux 2 (AL2), which reached end of life on 30 June 2026; Python 3.11 itself deprecates on 30 June 2027. Teams must jump directly to Python 3.12, 3.13, or 3.14 on Amazon Linux 2023 (AL2023).
- Container image blindness: Functions packaged as OCI container images receive zero AWS Health Dashboard notifications and zero deprecation warning emails. Platform teams must track base image lifecycles independently.
- AWS's sample audit code truncates at 50 functions: The official AWS documentation sample script extracts
NextMarkerbut never loops through it, silently ignoring all functions past the first 50. Our production-ready audit script below usesbotocorepaginators to guarantee complete multi-region coverage across both$LATESTand published versions.
---
What Runtime Deprecation Actually Means, Phase by Phase
For zip-packaged Lambda event functions, AWS enforces a four-stage deprecation workflow:
| Lifecycle Phase | Minimum Advance Notice | Operational & Security Consequences |
|---|---|---|
| Notice Phase | At least 180 days prior | AWS issues automated warnings via emails to the account's primary contact, creates AWS Health Dashboard events, and populates an entry in AWS Trusted Advisor. |
| Deprecation Date | Day zero | Security patches, CVE fixes, and AWS technical support terminate. The AWS Management Console disables creating or updating functions on this runtime. However, the AWS CLI, AWS SAM, CDK, and CloudFormation remain fully operational. |
| Block Function Create | At least 30 days post-deprecation *(often extended)* | You cannot create new functions on the deprecated runtime via any interface (Console, CLI, API, or CloudFormation). Existing functions can still be modified or redeployed. |
| Block Function Update | At least 60 days post-deprecation *(often extended)* | You cannot update code or runtime configuration on existing functions. You can still migrate the function to a supported runtime, but rolling back to the deprecated runtime is permanently blocked. |
The Silent CI/CD Pipeline Drift Trap
Notice the discrepancy during the initial Deprecation phase: the AWS Console blocks modifications, but programmatic interfaces (AWS CLI, SAM, CloudFormation) continue to function without throwing errors.
Because automated CI/CD pipelines bypass the Console, engineering teams frequently deploy code to deprecated runtimes for months without realizing their production workloads have dropped off active OS and language security patching.
OS-Only Patching During Delayed Deprecation Windows
When customer demand prompts AWS to delay a runtime deprecation beyond the upstream language community's official End of Life (EOL), AWS applies security updates to the underlying Amazon Linux OS packages only.
Upstream language vulnerabilities (such as Brotli memory flaws in older Node runtimes or Python interpreter CVEs) receive no patches once the language community's maintenance branch closes.
---
Authoritative AWS Lambda Runtime Lifecycle Table (Verified 11 November 2026)
The table below reflects the exact data published in AWS's *Supported runtimes* and *Deprecated runtimes* documentation as verified on 11 November 2026.
Note that Amazon Linux 2 (AL2) officially reached end of life on 30 June 2026. AWS maintains limited security patches for critical and selected important AL2 vulnerabilities on active AL2-based Lambda runtimes only until each runtime's respective deprecation date:
| Runtime Identifier | Base OS | Deprecation Date | Block Function Create | Block Function Update |
|---|---|---|---|---|
nodejs24.x | AL2023 | 30 Apr 2028 | 01 Jun 2028 | 01 Jul 2028 |
nodejs22.x | AL2023 | 30 Apr 2027 | 29 Jul 2027 | 31 Aug 2027 |
nodejs20.x | AL2023 | 30 Apr 2026 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
nodejs18.x | AL2 | 01 Sep 2025 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
nodejs16.x | AL2 | 12 Jun 2024 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
python3.14 | AL2023 | 30 Jun 2029 | 31 Jul 2029 | 31 Aug 2029 |
python3.13 | AL2023 | 30 Jun 2029 | 31 Jul 2029 | 31 Aug 2029 |
python3.12 | AL2023 | 31 Oct 2028 | 30 Nov 2028 | 10 Jan 2029 |
python3.11 | AL2 | 30 Jun 2027 | 29 Jul 2027 | 31 Aug 2027 |
python3.10 | AL2 | 31 Oct 2026 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
python3.9 | AL2 | 15 Dec 2025 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
python3.8 | AL2 | 14 Oct 2024 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
java8.al2, java11, java17 | AL2 | 30 Jun 2027 | 29 Jul 2027 | 31 Aug 2027 |
java8.al2023, java11.al2023, java17.al2023, java21, java25 | AL2023 | 30 Jun 2029 | 31 Jul 2029 | 31 Aug 2029 |
dotnet10 | AL2023 | 14 Nov 2028 | 14 Dec 2028 | 15 Jan 2029 |
dotnet9 *(Container only)* | AL2023 | 10 Nov 2026 (Deprecated) | *Not scheduled* | *Not scheduled* |
dotnet8 | AL2023 | 10 Nov 2026 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
dotnet6 | AL2 | 20 Dec 2024 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
ruby4.0 | AL2023 | 31 Mar 2029 | 30 Apr 2029 | 31 May 2029 |
ruby3.4 | AL2023 | 31 Mar 2028 | 30 Apr 2028 | 31 May 2028 |
ruby3.3 | AL2023 | 31 Mar 2027 | 29 Jul 2027 | 31 Aug 2027 |
ruby3.2 | AL2 | 31 Mar 2026 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
provided.al2023 | AL2023 | 30 Jun 2029 | 31 Jul 2029 | 31 Aug 2029 |
provided.al2 | AL2 | 31 Jul 2026 (Deprecated) | 29 Jul 2027 | 31 Aug 2027 |
nodejs26.x and python3.15 with an indicative target launch window of November 2026. AWS explicitly notes that preview runtimes carry no SLA, provide no commercial support, and must never be deployed for production workloads.---
Why Conflicting Deprecation Dates Circulate Online
If you search for Lambda runtime block dates, you will find different timelines across tech blogs, Reddit discussions, and historical documentation copies:
| Documentation Snapshot / Source | Python 3.10 Block Create / Update | Node.js 20 Block Create / Update |
|---|---|---|
| Archived AWS Documentation (Early 2026) | 30 Nov 2026 / 15 Jan 2027 | 31 Aug 2026 / 30 Sep 2026 |
| Mid-2026 AWS Documentation Revisions | 01 Feb 2027 / 03 Mar 2027 | *Not specified in snippet* |
| Third-Party AWS EOL References (e.g. Hidekazu Konishi) | *Not listed* | 01 Feb 2027 / 03 Mar 2027 |
| Live AWS Documentation (11 Nov 2026) | 29 Jul 2027 / 31 Aug 2027 | 29 Jul 2027 / 31 Aug 2027 |
Why Did the Dates Shift?
AWS formally announced that in response to enterprise feedback regarding container transition friction and migration cycles, they intentionally pushed out creation- and update-block deadlines.
However, remember this critical distinction: AWS treats deprecation dates as formal forecasts, not irrevocable guarantees. While AWS promises not to block runtimes *earlier* than the dates listed in its live tables, dates remain subject to modification. Always verify against the live documentation before establishing compliance deadlines.
---
The 6 Critical Operational Traps
Trap 1: Picking a Runtime on an Expiring Clock (The AL2 Runway Trap)
When teams discover python3.10 is deprecated, the intuitive reaction is to increment one minor version to python3.11.
This is an architectural trap. python3.11 is built on Amazon Linux 2 (AL2). Its scheduled deprecation is 30 June 2027—granting your team barely eight months of operational runway before facing another mandatory migration.
MIGRATION RUNWAY COMPARISON:
-----------------------------------------------------------------------------------------
python3.10 (AL2) [DEPRECATED Oct 2026] ──────> Upgrades to:
├── python3.11 [AL2] ──────> Deprecates 30 Jun 2027 (⚠️ ~8 months runway)
├── python3.12 [AL2023] ──────> Deprecates 31 Oct 2028 (✅ ~2 years runway)
└── python3.13/14 [AL2023] ──────> Deprecates 30 Jun 2029 (🌟 ~2.5+ years runway)
-----------------------------------------------------------------------------------------The exact same hazard applies to Java: java8.al2, java11, and java17 (on AL2) deprecate on 30 June 2027, whereas the *.al2023 variants run cleanly through 30 June 2029.
python3.12+, nodejs22.x+, java17.al2023+, dotnet10).---
Trap 2: Notifications Are Far Narrower Than They Appear
Relying on AWS alerts to tell you when Lambda functions are in danger is fraught with failure points:
- Email alerts target primary contacts only: Deprecation notices are emailed exclusively to the account's registered administrative contact—frequently an unmonitored distribution alias (
aws-admins@company.com) rather than active application developers. - Health Dashboard notifications expire: AWS Health Dashboard event notices automatically clear and vanish 90 days after the runtime reaches deprecation, leaving no persistent dashboard indicator.
- Container-image functions receive zero notifications: AWS Lambda provides zero deprecation alerts for functions deployed via OCI container images. If you run containerized Python 3.10 or Node.js 20 microservices, AWS will never email you or flag your dashboard. You must audit base container layers independently.
- Email and Health Dashboard check `$LATEST` only: Automated alerts completely omit older published function versions that may still be serving critical production traffic via aliases.
---
Trap 3: Published Function Versions and Aliases Retain Old Runtimes
In AWS Lambda, updating the runtime of a function updates the $LATEST configuration only:
Function: PaymentProcessor
├── $LATEST ──> Runtime: nodejs22.x (Updated)
├── Version 4 ──> Runtime: nodejs20.x (DEPRECATED!)
└── Alias: "live" ──> Points to Version 4 (RUNNING DEPRECATED RUNTIME!)If your API Gateway or EventBridge rules invoke an alias (e.g. arn:aws:lambda:...:function:PaymentProcessor:live), and that alias points to an immutable numbered version, your production traffic is still executing on the deprecated runtime.
To audit real risk, you must query Lambda with FunctionVersion="ALL".
---
Trap 4: Rolling Back After Update-Block Is Forbidden
AWS allows updating a function's code and runtime right up until the Block Function Update milestone.
Once the update-block date passes:
- You can migrate a function from a deprecated runtime to a supported runtime.
- You cannot revert back to the deprecated runtime if the new version encounters runtime errors or dependency crashes.
If you edit $LATEST in place, you forfeit your safety net. You must adopt immutable published versions and pointer-based aliases so rolling back consists of repointing the alias, not modifying runtime configurations.
---
Trap 5: AWS's Documented Sample Code Silently Misses Functions
In AWS's official guide, *Retrieve data about Lambda functions that use a deprecated runtime*, the sample Python script contains a severe flaw:
# FLAW IN AWS OFFICIAL SAMPLE CODE:
response = client.list_functions(
FunctionVersion='ALL',
MaxItems=50
)
# AWS sample reads NextMarker, but does NOT loop!
# Result: If your account has > 50 functions,
# functions 51 through N are never audited!AWS sets MaxItems=50, checks for NextMarker, but provides no pagination loop. In our verification tests against a mock catalog of 131 functions, AWS's exact sample code stopped at function 50 and exited clean.
Furthermore, the sample script filters by PackageType == 'Zip'. While technically accurate for native runtimes, it causes container-image functions to vanish completely from the audit report.
---
Trap 6: Node.js 24 on Lambda Is Not Upstream Node.js 24
Upstream Node.js 24 introduced several automated module resolution features. On AWS Lambda, these features are deliberately disabled by default:
- Importing CommonJS with `require()` inside ES Modules: Disabled on Lambda (
nodejs20.x,nodejs22.x,nodejs24.x) via--no-experimental-require-module. - Automatic detection of ES vs CommonJS modules: Disabled on Lambda (
nodejs22.x,nodejs24.x) via--no-experimental-detect-module.
If developer workstations run vanilla Node 24, code utilizing these modern resolution features will pass local unit tests and fail immediately in Lambda with module loader exceptions.
# To force Lambda to emulate upstream behavior (⚠️ Forfeits AWS SLA & Support):
NODE_OPTIONS="--experimental-require-module --experimental-detect-module"NODE_OPTIONS voids eligibility for the AWS Lambda SLA and AWS Enterprise Technical Support. Always transpile code cleanly (e.g., via esbuild or tsx) instead of relying on runtime experimental flags.Additional Node.js Migration Gotchas:
- Root CA Certificates (Node 18 vs Node 20+): Node 18 and earlier automatically bundled Amazon internal CA certificates. Starting with
nodejs20.x, this auto-load was removed. If your Lambda function queries Amazon RDS over SSL using default certificates, you must supplyNODE_EXTRA_CA_CERTS=/var/runtime/ca-cert.pem. - Bundled AWS SDK for JavaScript v3: The specific minor version of the AWS SDK pre-installed in
/var/runtime/node_modules/@aws-sdkvaries between AWS regions and runtime patch levels. Never rely on the ambient runtime SDK; bundle your own pinned@aws-sdkdependencies in your application build artifact.
---
The Production-Ready Audit Script (`lambda_runtime_audit.py`)
Below is the production-grade, paginated audit script built to address AWS's sample limitations. It:
- Paginates cleanly using
botocore.client.get_paginatoracross 100% of functions. - Audits all published versions (
FunctionVersion="ALL"). - Flags container images (
IMAGE) and unlisted runtimes (UNKNOWN). - Supports multi-region scans, JSON output, and
--todaydate simulation. - Returns exit code
1if any deprecated or blocked functions exist (ideal for CI/CD gates).
#!/usr/bin/env python3
"""lambda_runtime_audit.py - List Lambda functions by runtime lifecycle status.
Read-only audit tool. Requires IAM permission: lambda:ListFunctions.
Paginates through every specified AWS region and inspects all published versions.
Lifecycle dates reflect AWS's Supported & Deprecated runtimes tables as of 2026-11-11.
Re-verify dates against:
https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
"""
import argparse
import datetime as dt
import json
import sys
D = dt.date.fromisoformat
# Map of runtime identifier -> (deprecation_date, block_create_date, block_update_date)
# None indicates public preview or unscheduled block dates.
RUNTIME_LIFECYCLE = {
# Public Preview (Not for production)
"nodejs26.x": None,
"python3.15": None,
# Active & Supported Runtimes (AL2023)
"nodejs24.x": ("2028-04-30", "2028-06-01", "2028-07-01"),
"nodejs22.x": ("2027-04-30", "2027-07-29", "2027-08-31"),
"python3.14": ("2029-06-30", "2029-07-31", "2029-08-31"),
"python3.13": ("2029-06-30", "2029-07-31", "2029-08-31"),
"python3.12": ("2028-10-31", "2028-11-30", "2029-01-10"),
"java25": ("2029-06-30", "2029-07-31", "2029-08-31"),
"java21": ("2029-06-30", "2029-07-31", "2029-08-31"),
"java17.al2023": ("2029-06-30", "2029-07-31", "2029-08-31"),
"java11.al2023": ("2029-06-30", "2029-07-31", "2029-08-31"),
"java8.al2023": ("2029-06-30", "2029-07-31", "2029-08-31"),
"dotnet10": ("2028-11-14", "2028-12-14", "2029-01-15"),
"ruby4.0": ("2029-03-31", "2029-04-30", "2029-05-31"),
"ruby3.4": ("2028-03-31", "2028-04-30", "2028-05-31"),
"ruby3.3": ("2027-03-31", "2027-07-29", "2027-08-31"),
"provided.al2023": ("2029-06-30", "2029-07-31", "2029-08-31"),
# Deprecated & Pending Block Runtimes
"nodejs20.x": ("2026-04-30", "2027-07-29", "2027-08-31"),
"nodejs18.x": ("2025-09-01", "2027-07-29", "2027-08-31"),
"nodejs16.x": ("2024-06-12", "2027-07-29", "2027-08-31"),
"python3.11": ("2027-06-30", "2027-07-29", "2027-08-31"),
"python3.10": ("2026-10-31", "2027-07-29", "2027-08-31"),
"python3.9": ("2025-12-15", "2027-07-29", "2027-08-31"),
"python3.8": ("2024-10-14", "2027-07-29", "2027-08-31"),
"java17": ("2027-06-30", "2027-07-29", "2027-08-31"),
"java11": ("2027-06-30", "2027-07-29", "2027-08-31"),
"java8.al2": ("2027-06-30", "2027-07-29", "2027-08-31"),
"dotnet9": ("2026-11-10", None, None),
"dotnet8": ("2026-11-10", "2027-07-29", "2027-08-31"),
"dotnet6": ("2024-12-20", "2027-07-29", "2027-08-31"),
"ruby3.2": ("2026-03-31", "2027-07-29", "2027-08-31"),
"provided.al2": ("2026-07-31", "2027-07-29", "2027-08-31"),
# Historical End-Of-Life Runtimes
"nodejs14.x": ("2023-12-04", "2024-01-09", "2027-08-31"),
"nodejs12.x": ("2023-03-31", "2023-03-31", "2023-04-30"),
"python3.7": ("2023-12-04", "2024-01-09", "2027-08-31"),
"python3.6": ("2022-07-18", "2022-07-18", "2022-08-29"),
"python2.7": ("2021-07-15", "2021-07-15", "2022-05-30"),
"java8": ("2024-01-08", "2024-02-08", "2027-08-31"),
"go1.x": ("2024-01-08", "2024-02-08", "2027-08-31"),
"provided": ("2024-01-08", "2024-02-08", "2027-08-31"),
"ruby2.7": ("2023-12-07", "2024-01-09", "2027-08-31"),
"dotnetcore3.1": ("2023-04-03", "2023-04-03", "2023-05-03"),
}
def evaluate_runtime_status(runtime: str | None, today: dt.date) -> tuple[str, str]:
"""Calculate operational status based on runtime table and evaluation date."""
if runtime is None:
return "IMAGE", "Container image: zero AWS alerts, manually inspect base Dockerfile"
if runtime not in RUNTIME_LIFECYCLE:
return "UNKNOWN", "Runtime identifier not recognized, verify against live AWS docs"
lifecycle = RUNTIME_LIFECYCLE[runtime]
if lifecycle is None:
return "PREVIEW", "Public preview runtime: no SLA, strictly not for production"
dep_s, block_c_s, block_u_s = lifecycle
dep_date = D(dep_s) if dep_s else None
block_c_date = D(block_c_s) if block_c_s else None
block_u_date = D(block_u_s) if block_u_s else None
if block_u_date and today >= block_u_date:
return "UPDATE-BLOCKED", f"Updates blocked since {block_u_date}"
if block_c_date and today >= block_c_date:
return "CREATE-BLOCKED", f"Creation blocked since {block_c_date}; updates blocked from {block_u_date}"
if dep_date and today >= dep_date:
next_note = f"; creation blocked from {block_c_date}" if block_c_date else ""
return "DEPRECATED", f"Deprecated since {dep_date}, continues running, zero patches{next_note}"
days_until_dep = (dep_date - today).days
if days_until_dep <= 180:
return "SOON", f"Deprecates {dep_date} (in {days_until_dep} days)"
return "OK", f"Supported, deprecates {dep_date}"
def audit_region(lambda_client, region: str, today: dt.date) -> list[dict]:
"""Audit all functions and versions across a single AWS region."""
results = []
paginator = lambda_client.get_paginator("list_functions")
# FunctionVersion='ALL' ensures both $LATEST and immutable versions are scanned
for page in paginator.paginate(FunctionVersion="ALL"):
for fn in page.get("Functions", []):
is_zip = fn.get("PackageType", "Zip") == "Zip"
runtime = fn.get("Runtime") if is_zip else None
status, note = evaluate_runtime_status(runtime, today)
results.append({
"region": region,
"function": fn["FunctionName"],
"version": fn.get("Version", "$LATEST"),
"runtime": runtime or "(container-image)",
"status": status,
"note": note,
})
return results
def main():
parser = argparse.ArgumentParser(description="AWS Lambda multi-region runtime lifecycle auditor.")
parser.add_argument("--regions", help="Comma-delimited regions (e.g. us-east-1,us-west-2,eu-west-1)")
parser.add_argument("--profile", help="AWS credentials profile name")
parser.add_argument("--today", help="Override today's date (YYYY-MM-DD) for what-if simulation")
parser.add_argument("--json", action="store_true", help="Output machine-readable JSON")
args = parser.parse_args()
today = D(args.today) if args.today else dt.date.today()
try:
import boto3
except ImportError:
print("Error: boto3 is required. Run: pip install boto3", file=sys.stderr)
sys.exit(2)
session = boto3.Session(profile_name=args.profile)
target_regions = (
[r.strip() for r in args.regions.split(",") if r.strip()]
if args.regions
else [session.region_name or "us-east-1"]
)
all_rows = []
for reg in target_regions:
try:
client = session.client("lambda", region_name=reg)
all_rows.extend(audit_region(client, reg, today))
except Exception as exc:
# Prevent a failure in one region (e.g. permission or network) from halting audit
print(f"WARNING: Skipping region {reg} due to error: {exc}", file=sys.stderr)
if args.json:
print(json.dumps(all_rows, indent=2))
else:
# Formatted console table sorted by risk severity
status_priority = {
"UPDATE-BLOCKED": 0,
"CREATE-BLOCKED": 1,
"DEPRECATED": 2,
"SOON": 3,
"PREVIEW": 4,
"IMAGE": 5,
"UNKNOWN": 6,
"OK": 7,
}
sorted_rows = sorted(
all_rows,
key=lambda x: (status_priority.get(x["status"], 99), x["region"], x["function"])
)
header = f"{'STATUS':<16} {'REGION':<14} {'FUNCTION:VERSION':<32} {'RUNTIME':<18} {'LIFECYCLE DETAILS'}"
print(header)
print("-" * len(header))
for row in sorted_rows:
fn_ver = f"{row['function']}:{row['version']}"
print(f"{row['status']:<16} {row['region']:<14} {fn_ver:<32} {row['runtime']:<18} {row['note']}")
# Exit code gate: return 1 if actionable deprecated or blocked functions exist
critical_statuses = {"DEPRECATED", "CREATE-BLOCKED", "UPDATE-BLOCKED"}
has_actionable_risk = any(r["status"] in critical_statuses for r in all_rows)
sys.exit(1 if has_actionable_risk else 0)
if __name__ == "__main__":
main()Running the Audit Script
# 1. Install AWS SDK dependencies
pip install boto3
# 2. Run a standard multi-region scan against your AWS profile
python3 lambda_runtime_audit.py --regions us-east-1,us-west-2,eu-west-1 --profile production
# 3. Perform a 'What-If' dry run simulating future block dates
python3 lambda_runtime_audit.py --regions us-east-1 --today 2027-08-31
# 4. Export machine-readable JSON for automated compliance reporting
python3 lambda_runtime_audit.py --regions us-east-1 --json > lambda-inventory.jsonSample Audit Output
STATUS REGION FUNCTION:VERSION RUNTIME LIFECYCLE DETAILS
-------------------------------------------------------------------------------------------------------------------------
DEPRECATED us-east-1 auth-token-issuer:$LATEST nodejs20.x Deprecated since 2026-04-30, continues running, zero patches; creation blocked from 2027-07-29
DEPRECATED us-east-1 user-data-processor:$LATEST python3.10 Deprecated since 2026-10-31, continues running, zero patches; creation blocked from 2027-07-29
DEPRECATED us-east-1 legacy-billing-hook:14 dotnet8 Deprecated since 2026-11-10, continues running, zero patches; creation blocked from 2027-07-29
SOON us-east-1 notification-dispatcher:$LATEST nodejs22.x Deprecates 2027-04-30 (in 170 days)
IMAGE us-east-1 ai-inference-worker:$LATEST (container-image) Container image: zero AWS alerts, manually inspect base Dockerfile
UNKNOWN us-east-1 custom-sandbox-runner:$LATEST nodejs99.x Runtime identifier not recognized, verify against live AWS docs
OK us-east-1 order-router:$LATEST nodejs24.x Supported, deprecates 2028-04-30
OK us-east-1 telemetry-aggregator:$LATEST python3.12 Supported, deprecates 2028-10-31Key Operational Boundaries of the Script
- Single Account Scope: The script inspects the authenticated AWS session. For enterprise AWS Organizations, run the script across profiles in a loop or leverage AWS Organizations AssumeRole automation.
- Lambda Layers: The script identifies function runtime specifications, but does not deconstruct
.ziplayer dependencies. Ensure custom layers are compiled against the target AL2023 glibc version. - Container Images: Marked with status
IMAGE. The script extracts containerized functions rather than dropping them, prompting teams to audit the underlying DockerfileFROMdirective.
---
The Production Serverless Migration Runbook
Follow this battle-tested 7-step engineering runbook to migrate deprecated Lambda runtimes safely without production downtime:
┌─────────────────┐ ┌──────────────────────┐ ┌────────────────────────┐
│ 1. Multi-Reg │ ──> │ 2. CloudWatch Metric │ ──> │ 3. Target Selection │
│ Inventory Scan │ │ Prioritization │ │ (AL2023 Long Runway)│
└─────────────────┘ └──────────────────────┘ └────────────────────────┘
│
▼
┌─────────────────┐ ┌──────────────────────┐ ┌────────────────────────┐
│ 6. Alias Cut │ <── │ 5. Node/OS Divergence│ <── │ 4. Version & Alias │
│ & Verify Logs │ │ Sandbox Testing │ │ Deployment (No $LAT)│
└─────────────────┘ └──────────────────────┘ └────────────────────────┘Step 1: Execute Full Cross-Region Inventory
Run lambda_runtime_audit.py across all production and staging AWS accounts. Correlate findings with AWS Trusted Advisor's *AWS Lambda Functions Using Deprecated Runtimes* check to capture any legacy endpoints.
Step 2: Prioritize Functions by Real CloudWatch Invocations
Do not migrate hundreds of microservices alphabetically. Query CloudWatch Metrics across the last 14 days:
- Active Services (`Invocations > 0`): Group into tiers based on error tolerance and RPS.
- Zero Invocation Functions (`Invocations == 0`): Cross-reference CloudWatch Log Group
LastEventTime. If a function has seen zero invocations for 90 days, consider decommissioning rather than migrating.
Step 3: Enforce AL2023 Modern Runway
Select runtimes with maximum operational runway:
- Moving from
python3.10? Do not targetpython3.11. Targetpython3.12(supported to October 2028) orpython3.13/python3.14(supported to June 2029). - Moving from
nodejs20.x? Selectnodejs24.x(supported to April 2028) ornodejs22.x(supported to April 2027).
Step 4: Publish Immutable Versions Instead of Editing `$LATEST`
Never change runtime identifiers directly on $LATEST in production.
- Build and test your code locally on the target runtime.
- Deploy the updated package to Lambda as a new numbered version (e.g.
Version 12). - Keep your production alias (
live) pointing toVersion 11.
Step 5: Test Lambda-Specific Runtime Behaviors
Test for runtime divergence in staging environments:
- Node.js: Ensure CommonJS and ESM module syntax does not rely on
--experimental-require-module. Verify RDS database connections includeNODE_EXTRA_CA_CERTS=/var/runtime/ca-cert.pemif transitioning from Node 18. - AWS SDK: Ensure all
@aws-sdk/*orboto3dependencies are explicitly packaged into your deployment archive rather than relying on Lambda's runtime defaults. - Native Binaries: Any binary dependencies compiled against Amazon Linux 2 glibc (
glibc 2.26) must be recompiled against Amazon Linux 2023 (glibc 2.34).
Step 6: Route Traffic via Weighted Aliases
Using Lambda Function Aliases, route 10% of production traffic to the new version using AWS Lambda Weighted Aliases. Monitor error rates, invocation duration, and cold start metrics in CloudWatch before shifting 100% of traffic.
Step 7: Embed the Audit Gate in CI/CD
Incorporate lambda_runtime_audit.py into your centralized GitHub Actions or GitLab CI deployment pipelines. Because the script exits with code 1 when deprecated runtimes are detected, pipelines will reject builds introducing or retaining unpatched runtimes.
---
Test Methodology & Verification Scope
To validate the reliability of this lifecycle runbook and audit tooling, the following test scenarios were executed:
- Mock Client Response Stubbing: Using
botocore.stub.Stubberon a liveboto3.client('lambda'), we streamed 131 distinct function configurations across three consecutive paginated batches (50, 50, and 31 functions). The mocked catalog contained container-image functions withoutRuntimekeys, unrecognized future runtime identifiers, preview runtimes, and multiple published versions of a single function. The audit script parsed all 131 functions with zero dropouts, while AWS's documented sample script stopped at item 50. - Temporal What-If Simulation: Using
--today 2027-07-29, the script accurately transitioned Node 20, Python 3.10, Python 3.11, Node 22, and .NET 8 fromDEPRECATEDtoCREATE-BLOCKED. Simulating--today 2027-08-31correctly transitioned them toUPDATE-BLOCKED. - Multi-Region Fault Tolerance: When tested across two target regions where one region threw simulated IAM authorization exceptions (
AccessDeniedException), the script logged a clear warning, completed the audit of the remaining region, and cleanly returned exit code1due to detected deprecated workloads. - What Was Not Tested: Testing did not execute against a live multi-million invocation production account (executed via mocked responses); IAM requirements beyond
lambda:ListFunctionswere not evaluated; internal base image contents of containerized functions were not scanned. - Date Authority: All lifecycle dates originate directly from AWS's documentation as verified on 11 November 2026. Because AWS treats deprecation dates as forward-looking forecasts, check the official documentation before committing to contractual compliance deadlines.
---
Official Sources & Documentation References
- AWS Lambda Developer Guide: Lambda Event Function Runtimes
- AWS Lambda Developer Guide: Retrieve Data About Functions Using a Deprecated Runtime
- AWS Lambda Developer Guide: Building Lambda Event Functions with Node.js
- AWS Compute Blog: Managing AWS Lambda Runtime Upgrades
- AWS Compute Blog: Public Preview Runtimes for Node.js 26 and Python 3.15
- Hidekazu Konishi AWS End-of-Support and EOL Reference
Frequently Asked Questions
No. AWS officially guarantees that existing Lambda functions continue to invoke indefinitely on deprecated runtimes. However, AWS ceases all technical support and security patches. Over time, deprecated runtimes face operational degradation due to TLS certificate expiration, upstream API protocol deprecation, or underlying library incompatibility.
As of the verified November 11, 2026 AWS documentation: Node.js 20 was deprecated on April 30, 2026, and Python 3.10 was deprecated on October 31, 2026. For both runtimes, AWS has scheduled Function Creation Blocking from July 29, 2027, and Function Update Blocking from August 31, 2027.
AWS periodically adjusts and extends creation- and update-block deadlines in response to enterprise customer feedback. Earlier published documentation cited dates such as November 30, 2026 or February 1, 2027. The authoritative dates on AWS's live documentation as of November 11, 2026 reflect extended windows (e.g., July 29, 2027 and August 31, 2027).
Python 3.11 on AWS Lambda runs on Amazon Linux 2 (AL2), which reached end of life on June 30, 2026. Because Python 3.11 deprecates on June 30, 2027, upgrading from 3.10 to 3.11 buys only around eight months of runway. AWS strongly recommends upgrading directly to Amazon Linux 2023 (AL2023) runtimes such as Python 3.12, 3.13, or 3.14.
AWS's documented sample code calls ListFunctions with MaxItems=50 and extracts the NextMarker token, but omits the paging while-loop required to fetch subsequent pages. As a result, accounts with more than 50 functions only audit the first 50. Additionally, the Python sample filters by PackageType == 'Zip', entirely hiding container-image functions.
AWS Lambda deliberately disables upstream experimental features by default: --no-experimental-require-module (requiring ES modules with require) and --no-experimental-detect-module (automatic detection of ESM vs CommonJS). Re-enabling these via NODE_OPTIONS forfeits eligibility for the Lambda SLA and AWS Support.


