Rust Durable Functions availability?

[luiscarlosjayk]

Hi team,
was writing a small testing rust lambda taking approach of https://crates.io/crates/durable-execution-sdk and found that I couldn't deploy my lambda because CloudFormation (CDK) rejects it.

Was trying to see whether there's an alpha version of aws-cdk-lib or cargo-lambda-cdk that enables it but seems it's still not available anywhere.

Thanks

[MentalOfCrow]

There are two independent support questions here: infrastructure support and Rust runtime/SDK support.

CDK now has infrastructure support. Current aws-cdk-lib exposes durableConfig on lambda.FunctionOptions, including DockerImageFunctionProps, and automatically uses AWSLambdaBasicDurableExecutionRolePolicy for the generated role:

import { Duration } from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';

const fn = new lambda.DockerImageFunction(this, 'RustDurableFunction', {
  code: lambda.DockerImageCode.fromImageAsset('../rust-handler'),
  architecture: lambda.Architecture.ARM_64, // match the image you build
  durableConfig: {
    executionTimeout: Duration.hours(1),
    retentionPeriod: Duration.days(7),
  },
});

const version = fn.currentVersion;
const live = new lambda.Alias(this, 'Live', {
  aliasName: 'live',
  version,
});

The L2 support landed in feat(lambda): add support for durable functions, and the current Lambda construct README documents the property.

The service runtime restriction is the part causing the rejection. AWS's current supported runtimes for durable functions lists Node.js, Python and Java managed runtimes. Rust normally uses the OS-only provided.al2023 runtime, which is not in that managed-runtime allowlist.

AWS does document OCI container images as the route for additional/custom runtime configurations. That is why the example above uses DockerImageFunction: it synthesizes PackageType: Image and omits the unsupported provided.al2023 Runtime property. Your image must include the Rust Lambda runtime client, the durable execution SDK, and a bootstrap/entrypoint compatible with the Lambda Runtime API.

Important caveats for the Rust crate:

• durable-execution-sdk is currently an 0.1.0-alpha* AWS Labs crate, not one of the stable language SDKs listed in the Lambda documentation. Pin the exact version and treat the workload as experimental.
• A CDK alpha package cannot make an unsupported Lambda runtime valid; CDK only emits CloudFormation. If PackageType: Image plus DurableConfig is rejected in your Region/account, that is a service availability limitation and requires AWS confirmation, not a CDK escape hatch.
• Durable execution must be enabled when the function is created. Adding it to an existing function causes replacement; an explicitly fixed functionName can block that replacement.
• Durable functions are invoked through a qualified ARN. Publish a version/use an alias rather than invoking $LATEST. AWS's IaC guide also calls out the version/alias and checkpoint-permission requirements.

Inspect cdk synth before deploying. For the Rust container path, the AWS::Lambda::Function should contain PackageType: Image and DurableConfig, but no Runtime or Handler fields.

So the short answer is: there is no separate cargo-lambda-cdk switch required; current CDK can represent the durable configuration. For Rust, use an OCI image and the alpha Rust SDK, with the understanding that Rust support is still experimental rather than a listed stable managed-runtime combination.

If this gets the Rust image past CloudFormation validation, please mark it as the accepted answer so others can find the managed-runtime versus container distinction.