Business Challenge
Yesterday's daily covered customer-managed runtimes, where a platform team owns the runtime image. That raises the prior question: on an ordinary Lambda function, who is responsible for the runtime being patched? The documentation answers it in two sentences, and the second one is the whole post.
“Lambda is responsible for curating and publishing security updates for all supported managed runtimes and container images. Responsibility for updating existing Event Functions to use the latest runtime version varies depending on which runtime update mode you use.”
Publishing and applying are different jobs. AWS does the first unconditionally. The second depends on a per-function setting with three values, and the three divide the work very differently.
“For functions configured with the Function update runtime update mode, you're responsible for regularly updating your function. Lambda is responsible for applying runtime updates when you make those updates. If you don't update your function, then Lambda doesn't update the runtime.”
That is a conditional patching contract, and the condition is deployment activity. It works beautifully for a function under active development, where every release carries the latest runtime and runtime changes are synchronised with code changes you are already testing.
It fails silently for the opposite case, which is extremely common: the function that works. A webhook handler written eighteen months ago, a nightly report, a glue function between two services — nobody deploys them because nothing about them needs changing. On Function update mode those are the functions receiving no security patches at all, and the only way to tell is to compare each function's last modification date against its mode.
AWS states the remedy directly: “If you don't regularly update your function, then we strongly recommend configuring it for automatic runtime updates so that it continues to receive security updates.” The judgement it leaves to you — what counts as regularly — is the part nobody writes down.
FixMake the mode a function of deployment cadence rather than a default: Auto for anything you do not deploy on a known schedule, Function update only where releases are frequent enough to be a patching mechanism. Then measure it — a list of functions whose last modification predates their runtime's current version is a patching backlog, and nothing in Lambda produces that list for you.
Most deprecation mechanics in AWS come with dates. This one does not:
“Lambda doesn't impose a time limit on how long you can use any particular runtime version.”
Read as reassurance, that is a promise your function will keep running. Read as a warning, it means nothing will ever stop you, notify you, or escalate. There is no blocked deployment, no console banner counting down, no API error. The function simply continues on an increasingly old runtime version.
And then the sentence that follows it: “Functions using an earlier runtime version for an extended period might eventually experience degraded performance or issues, such as a certificate expiry, which can cause them to stop working properly.”
A certificate expiry is a precise and unsettling example, because it is a cliff rather than a slope. The function works, works, works, and then every outbound TLS connection fails on a date determined by a trust store nobody in your organisation chose. There is no gradual degradation to notice, and the triggering event is invisible from your side until it happens.
FixTreat runtime version age as a metric you own, because AWS is explicit that it will not enforce one. The INIT_START line in a function's logs carries the runtime version ARN, which makes the current version observable per function without an API call. Anything materially behind is accumulating risk that will present as a sudden failure rather than a warning.
Function versions are “an immutable snapshot of the $LATEST function code and configuration at the time that you created them” — except that the runtime underneath them is not necessarily part of the snapshot. It depends on the mode:
“In Auto mode, Lambda automatically updates the runtime version of published function versions during phase two of the runtime version rollout. In Function update mode, Lambda doesn't update the runtime version of published function versions.”
Hence: “Published function versions using Function update mode therefore create a static snapshot of the function code, configuration, and runtime version.”
That is a genuinely valuable property. A fully reproducible deployment artefact — code, configuration and runtime — is exactly what you want for a rollback you can trust, and the documentation recommends exactly that, integrating it into “continuous integration and continuous delivery (CI/CD) for fully automatic rollback in the rare event of runtime update incompatibility”.
It is also a frozen runtime serving production traffic. The same paragraph carries the condition: “When using this approach, you must update your function regularly and publish new function versions to pick up the latest runtime updates.” Reproducibility and patching are in direct tension here, and the setting that buys you one costs you the other unless you deploy.
One more sharp edge, since the setting is per version — “You can configure runtime management settings separately for each function version” — and Manual mode constrains more than the runtime: “If the $LATEST version of your function is configured to use Manual mode, then you can't change the CPU architecture or runtime version that your function uses.” A temporary rollback left in place blocks an architecture migration later, for a reason that will not be obvious.
FixIf you use published versions with Function update mode for reproducible rollback, pair it with a release cadence and treat publishing as the patching event. And audit for functions whose $LATEST is still on Manual mode from a past incident — that is where “temporary mitigation” becomes permanent.
Architecture
Who patches, by deployment shape
| Shape | AWS does | You do |
|---|---|---|
| Managed runtime, Auto | Publishes versions and applies them | Roll back if an update breaks you |
| Managed runtime, Function update | Publishes versions; applies them when you deploy | Deploy regularly, or receive nothing |
| Managed runtime, Manual | Publishes versions only | Everything — and leave this mode quickly |
| Container image | Publishes updated base images | “rebuilding your function's container image from the latest base image and redeploying” |
| Customer-managed runtime | Applies whatever the alias points to | Publisher patches and moves the alias; owner picks the alias |
Reading the middle column down, AWS's commitment is constant: it publishes. Reading the right column down, your obligation grows from react if something breaks to rebuild and redeploy. The mode is not a convenience setting; it is where you sit on that gradient.
The customer-managed shift, stated precisely
“If your function uses a customer-managed runtime, the runtime publisher, rather than Lambda, is responsible for publishing runtime versions with the latest patches and for updating runtime aliases.” And the division underneath it: “Lambda applies the runtime version that the alias points to, based on the function's runtime update mode. The function owner's responsibilities for each mode are the same as for Lambda-managed runtimes.”
So a customer-managed runtime moves the publishing half of AWS's job to your platform team and leaves the applying half with Lambda, gated by the same three modes. A function on Function update mode consuming a customer-managed runtime has two conditions to satisfy before it gets a patch: the publisher must move the alias, and the function owner must deploy. Two teams, each able to stall it, neither alerted when the other does.
The rollback capability mirrors that: “For a customer-managed runtime, the runtime publisher can also roll back a runtime alias for all functions that use it” — a blast radius worth knowing about from the consumer side.
Enforcing a posture instead of asking for one
This is the most useful operational detail on the page, and it is easy to miss. You can remove the choice: “You can restrict Lambda's runtime management controls by using AWS Identity and Access Management (IAM) to deny users in your AWS account access to the PutRuntimeManagementConfig API operation”, with the consequence stated plainly: “Denying access to this operation causes all functions to default to the Auto mode.”
That is a patching guarantee implemented as a permission boundary, applicable organisation-wide because “You can apply this restriction across your organization by using a service control policies (SCP)”, with exceptions granted case by case when a rollback is genuinely needed.
And the equivalent lever for customer-managed runtimes: “pinning a function to a runtime version also requires the lambda:AssociateRuntimeVersion permission. You can deny this action to prevent pinning to specific runtime versions.”
The pattern is the same one #116 found in the account-level policy API: the organisation's position is expressible as a denial rather than as a convention, which means it survives people who have not read the convention.
Why This Architecture Holds Up
Not imposing a deadline is the right call, given what a forced update can break
A runtime update is a change to the environment under running code, and the documentation is candid that incompatibility happens, which is why rollback exists. Hard-stopping functions on old versions would convert a security problem into an availability one on AWS's schedule rather than yours. The cost of that choice is that nothing escalates, which is why the responsibility table exists at all.
Three modes is the right number, and the middle one is genuinely useful
Synchronising runtime changes with deployments is a real engineering preference: it means a runtime change is tested by the same pipeline that tests your code, rather than arriving on a Tuesday. The mode is not a mistake. The mistake is leaving it on a function that stopped being deployed, and AWS names that case and tells you to switch.
Making the posture enforceable through IAM is better than documenting a policy
A rule that says use Auto mode is a rule people forget. Denying
PutRuntimeManagementConfig makes Auto the only reachable state, with rollback available
by exception. That converts a patching standard into a control, which is the difference between an
intention and a guarantee.
Key Architecture Decisions
| Decision | Choose this | Because |
|---|---|---|
| Default mode | Auto | It is the only mode where patching does not depend on your activity |
| Function update mode | Only where releases are frequent and scheduled | “If you don't update your function, then Lambda doesn't update the runtime” |
| Manual mode | Temporary rollback only, with an exit date | Documented for that purpose, and it blocks architecture changes on $LATEST |
| Enforcing a patching standard | Deny PutRuntimeManagementConfig via SCP |
It makes every function default to Auto rather than asking people to |
| Customer-managed runtimes | Also deny lambda:AssociateRuntimeVersion |
That is the permission that lets a function pin to an old runtime version |
| Reproducible rollback | Published versions with Function update mode | They snapshot code, configuration and runtime — at the cost of freezing the runtime |
| Container-image functions | A scheduled rebuild, not an event-driven one | AWS publishes base images; rebuilding and redeploying is entirely yours |
| Tracking runtime age | Read the version ARN from INIT_START |
There is no deadline and no notification, so age is a metric you have to own |
The audit worth running
List every function on Function update mode with its last modified date. Anything not deployed in months is unpatched, and this is the single query that finds it. Nothing in the service surfaces this pairing.
Find every $LATEST still on Manual mode. Each one is either an
incident nobody closed out or a deliberate pin nobody documented, and it silently blocks CPU
architecture changes.
Check whether PutRuntimeManagementConfig is restricted at all. If
anyone with function-write access can switch a function off Auto, your patching posture is a
convention rather than a control.
For container-image functions, compare base-image age against your rebuild cadence. This shape has no automatic path whatsoever — AWS publishes, you rebuild, and nothing connects the two.
For customer-managed runtimes, confirm somebody owns alias movement. The publisher half of the responsibility now belongs to a team in your organisation, and a platform team that publishes versions without moving aliases has patched nothing.
Closing Thought
The long run of posts before this one was about signals that go quiet: an alarm in
INSUFFICIENT_DATA, a canary that stopped running, a query that outran its own data, a
subscription that skipped. This is the same shape moved from monitoring into patching, and it is
arguably worse, because here the quiet thing is a security control and the eventual symptom is a
certificate expiry taking down a function that nobody had touched in two years.
What makes it tractable is that AWS writes the division down. The responsibility table is unusually honest for a shared-responsibility document: it names the mode where “Lambda doesn't update the runtime”, says what to do instead, and admits there is no deadline enforcing any of it. All of the ambiguity is in one word — regularly — and that word is yours to define.
So define it, then enforce it with the permission rather than the policy document. Auto by default; Function update only where a release cadence genuinely exists; Manual with an exit date written into the ticket that created it. And keep a list of functions whose runtime version is older than their last deployment, because that list is the one thing nothing in Lambda will build for you.
Reliability — Amazon EC2 automatic instance recovery: which status checks it acts on, what a recovered instance keeps and what it loses, why recovery is not replacement, and what happens to an instance whose impairment is a performance condition rather than a terminal one.
Official AWS Reference
- Managing Lambda runtime updates — that Lambda publishes security updates for all supported managed runtimes while responsibility for applying them varies by runtime update mode, the per-mode division including that Lambda does not update the runtime if you do not update the function, the recommendation to use Auto when you do not deploy regularly, that Manual mode is for temporary rollback only, that there is no time limit on a runtime version and that an old version may eventually fail through something like a certificate expiry, the container-image and customer-managed runtime splits, how published function versions behave per mode, the
$LATESTManual mode restriction on architecture changes, and the enforcement of Auto mode by denyingPutRuntimeManagementConfigorlambda:AssociateRuntimeVersion - Understanding how Lambda manages runtime updates — further reading on the runtime update modes, the two-phase rollout and how to identify a runtime version change; no claims in this post are drawn from it
- Customer-managed runtimes — further reading on the runtime resource whose publisher takes on the patching half of the responsibility, covered in Daily #79; no claims in this post are drawn from it
- Lambda function versions — further reading on published versions as immutable snapshots; no claims in this post are drawn from it
- Shared Responsibility Model — further reading on the general model this page specialises; no claims in this post are drawn from it
Comments