From e0e83dfc47bdc528bf30f02b3b362b0f70c4b180 Mon Sep 17 00:00:00 2001 From: Nithin Chandran Rajashankar Date: Thu, 23 Apr 2026 17:55:16 +0000 Subject: [PATCH 1/5] feat(lambda-durable-execution-java-cdk): Add Lambda Durable Execution Java SDK pattern Deploy a resilient multi-step order processing workflow using the AWS Lambda Durable Execution SDK for Java (v1.0.1) with automatic checkpointing and failure recovery. Key features: - DurableHandler base class with DurableContext - 5-step workflow: validate, reserve, pay, wait, ship - ctx.step() for checkpointed operations - ctx.wait() for zero-compute-cost suspension - Docker-based Java 17 Lambda with Maven build - CDK TypeScript infrastructure with DurableConfig escape hatch --- lambda-durable-execution-java-cdk/.gitignore | 6 + lambda-durable-execution-java-cdk/README.md | 125 ++++++++++++++++++ lambda-durable-execution-java-cdk/bin/app.ts | 7 + lambda-durable-execution-java-cdk/cdk.json | 11 ++ .../example-pattern.json | 62 +++++++++ .../lambda-durable-execution-java-stack.ts | 56 ++++++++ .../package.json | 20 +++ .../src/Dockerfile | 5 + .../main/java/com/example/OrderProcessor.java | 63 +++++++++ lambda-durable-execution-java-cdk/src/pom.xml | 43 ++++++ .../tsconfig.json | 20 +++ 11 files changed, 418 insertions(+) create mode 100644 lambda-durable-execution-java-cdk/.gitignore create mode 100644 lambda-durable-execution-java-cdk/README.md create mode 100644 lambda-durable-execution-java-cdk/bin/app.ts create mode 100644 lambda-durable-execution-java-cdk/cdk.json create mode 100644 lambda-durable-execution-java-cdk/example-pattern.json create mode 100644 lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts create mode 100644 lambda-durable-execution-java-cdk/package.json create mode 100644 lambda-durable-execution-java-cdk/src/Dockerfile create mode 100644 lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java create mode 100644 lambda-durable-execution-java-cdk/src/pom.xml create mode 100644 lambda-durable-execution-java-cdk/tsconfig.json diff --git a/lambda-durable-execution-java-cdk/.gitignore b/lambda-durable-execution-java-cdk/.gitignore new file mode 100644 index 000000000..7be64f01b --- /dev/null +++ b/lambda-durable-execution-java-cdk/.gitignore @@ -0,0 +1,6 @@ +node_modules +cdk.out +*.js +*.d.ts +package-lock.json +src/target diff --git a/lambda-durable-execution-java-cdk/README.md b/lambda-durable-execution-java-cdk/README.md new file mode 100644 index 000000000..b332648e5 --- /dev/null +++ b/lambda-durable-execution-java-cdk/README.md @@ -0,0 +1,125 @@ +# Lambda Durable Execution with Java SDK + +This pattern deploys a Lambda durable function written in Java that orchestrates a multi-step order processing workflow with automatic checkpointing and failure recovery. + +Learn more about this pattern at Serverless Land Patterns: https://serverlessland.com/patterns/lambda-durable-execution-java-cdk + +Important: this application uses various AWS services and there are costs associated with these services after the Free Tier usage - please see the [AWS Pricing page](https://aws.amazon.com/pricing/) for details. You are responsible for any AWS costs incurred. No warranty is implied in this example. + +## Requirements + +- [Create an AWS account](https://portal.aws.amazon.com/gp/aws/developer/registration/index.html) if you do not already have one and log in. The IAM user that you use must have sufficient permissions to make necessary AWS service calls and manage AWS resources. +- [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) installed and configured +- [Git Installed](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) +- [Node and NPM](https://nodejs.org/en/download/) installed +- [AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) installed +- [Java 17+](https://docs.aws.amazon.com/corretto/latest/corretto-17-ug/downloads-list.html) installed +- [Apache Maven](https://maven.apache.org/install.html) installed + +## Deployment Instructions + +1. Create a new directory, navigate to that directory in a terminal and clone the GitHub repository: + ```bash + git clone https://github.com/aws-samples/serverless-patterns + ``` +2. Change directory to the pattern directory: + ```bash + cd serverless-patterns/lambda-durable-execution-java-cdk + ``` +3. Build the Java Lambda function: + ```bash + cd src + mvn clean package -q + cd .. + ``` +4. Install CDK dependencies: + ```bash + npm install + ``` +5. Deploy the stack: + ```bash + cdk deploy + ``` + +## How it works + +This pattern uses the [AWS Lambda Durable Execution SDK for Java](https://github.com/aws/aws-durable-execution-sdk-java/) (GA April 2026) to build a resilient order processing workflow. + +The Java function extends `DurableHandler` and uses `DurableContext` to: + +1. **Validate order** — `ctx.step()` checkpoints the validation result +2. **Reserve inventory** — `ctx.step()` checkpoints the reservation ID +3. **Process payment** — `ctx.step()` checkpoints the payment confirmation +4. **Wait for warehouse** — `ctx.wait()` suspends execution for 5 seconds with zero compute charges +5. **Confirm shipment** — `ctx.step()` checkpoints the tracking number + +If the function is interrupted at any point, it replays from the beginning but skips completed steps using stored checkpoint results. + +### Architecture + +``` +┌─────────────────────────────────────────────────────────┐ +│ Lambda Durable Function │ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────┐ │ +│ │ Validate │→ │ Reserve │→ │ Process │→ │ Wait │ │ +│ │ Order │ │Inventory │ │ Payment │ │ (free) │ │ +│ └──────────┘ └──────────┘ └──────────┘ └────────┘ │ +│ ↓ checkpoint ↓ checkpoint ↓ checkpoint │ │ +│ ↓ │ +│ ┌──────────┐ │ +│ │ Confirm │ │ +│ │ Shipment │ │ +│ └──────────┘ │ +└─────────────────────────────────────────────────────────┘ +``` + +### Key Java SDK concepts + +- **`DurableHandler`** — Base class for durable functions. Extend this and implement `handleRequest(I input, DurableContext ctx)`. +- **`ctx.step(name, type, fn)`** — Execute code with automatic checkpointing and retry support. +- **`ctx.wait(name, duration)`** — Suspend execution without compute charges. +- **`ctx.invoke()`** — Invoke another Lambda function and wait for the result. +- **`ctx.map()`** — Apply a function across a collection concurrently. +- **`ctx.parallel()`** — Run multiple operations concurrently. + +## Testing + +1. After deployment, note the `FunctionAliasArn` output. + +2. Invoke the durable function using the alias ARN: + ```bash + aws lambda invoke \ + --function-name \ + --payload '{"orderId": "ORD-001", "amount": 149.99}' \ + --cli-binary-format raw-in-base64-out \ + output.json + + cat output.json + ``` + +3. Expected output: + ```json + { + "orderId": "ORD-001", + "status": "COMPLETED", + "validation": "VALIDATED", + "reservationId": "RES-a1b2c3d4", + "paymentId": "PAY-e5f6g7h8", + "trackingNumber": "TRACK-i9j0k1l2" + } + ``` + +4. Monitor the durable execution in the Lambda console under the **Durable executions** tab. + +## Cleanup + +```bash +cdk destroy +``` + +--- + +Copyright 2026 Amazon.com, Inc. or its affiliates. All Rights Reserved. + +SPDX-License-Identifier: MIT-0 diff --git a/lambda-durable-execution-java-cdk/bin/app.ts b/lambda-durable-execution-java-cdk/bin/app.ts new file mode 100644 index 000000000..b16bee3f5 --- /dev/null +++ b/lambda-durable-execution-java-cdk/bin/app.ts @@ -0,0 +1,7 @@ +#!/usr/bin/env node +import "source-map-support/register"; +import * as cdk from "aws-cdk-lib"; +import { LambdaDurableExecutionJavaStack } from "../lib/lambda-durable-execution-java-stack"; + +const app = new cdk.App(); +new LambdaDurableExecutionJavaStack(app, "LambdaDurableExecutionJavaStack"); diff --git a/lambda-durable-execution-java-cdk/cdk.json b/lambda-durable-execution-java-cdk/cdk.json new file mode 100644 index 000000000..822400f59 --- /dev/null +++ b/lambda-durable-execution-java-cdk/cdk.json @@ -0,0 +1,11 @@ +{ + "app": "npx ts-node --prefer-ts-exts bin/app.ts", + "watch": { + "include": ["**"], + "exclude": ["README.md", "cdk*.json", "**/*.d.ts", "**/*.js", "node_modules", "src"] + }, + "context": { + "@aws-cdk/aws-lambda:recognizeLayerVersion": true, + "@aws-cdk/core:checkSecretUsage": true + } +} diff --git a/lambda-durable-execution-java-cdk/example-pattern.json b/lambda-durable-execution-java-cdk/example-pattern.json new file mode 100644 index 000000000..5d3b18be4 --- /dev/null +++ b/lambda-durable-execution-java-cdk/example-pattern.json @@ -0,0 +1,62 @@ +{ + "title": "Lambda Durable Execution with Java SDK", + "description": "Build a resilient, multi-step order processing workflow using the AWS Lambda Durable Execution SDK for Java with automatic checkpointing and failure recovery.", + "language": "Java", + "level": "300", + "framework": "AWS CDK", + "introBox": { + "headline": "How it works", + "text": [ + "This pattern deploys a Lambda durable function written in Java that orchestrates a multi-step order processing workflow. The function uses the Durable Execution SDK for Java (v1.0.1) to automatically checkpoint progress at each step.", + "The workflow: (1) validates the order, (2) reserves inventory, (3) processes payment, (4) waits for warehouse processing (no compute charges), (5) confirms shipment. Each step is checkpointed, so if the function is interrupted, it resumes from the last completed step.", + "This is the first Java-based durable execution pattern. The Java SDK provides an idiomatic experience with DurableHandler and DurableContext, supporting steps, waits, callbacks, invoke, map, and parallel operations." + ] + }, + "gitHub": { + "template": { + "repoURL": "https://github.com/aws-samples/serverless-patterns/tree/main/lambda-durable-execution-java-cdk", + "templateURL": "serverless-patterns/lambda-durable-execution-java-cdk", + "projectFolder": "lambda-durable-execution-java-cdk", + "templateFile": "lib/lambda-durable-execution-java-stack.ts" + } + }, + "resources": { + "bullets": [ + { + "text": "Lambda Durable Execution SDK for Java on GitHub", + "link": "https://github.com/aws/aws-durable-execution-sdk-java/" + }, + { + "text": "Lambda Durable Functions Documentation", + "link": "https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html" + }, + { + "text": "Deploy Lambda durable functions with Infrastructure as Code", + "link": "https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html" + } + ] + }, + "deploy": { + "text": [ + "cd src && mvn clean package -q", + "cd .. && cdk deploy" + ] + }, + "testing": { + "text": [ + "See the GitHub repo for detailed testing instructions." + ] + }, + "cleanup": { + "text": [ + "Delete the stack: cdk destroy." + ] + }, + "authors": [ + { + "name": "Nithin Chandran R", + "bio": "Technical Account Manager at AWS", + "linkedin": "nithin-chandran-r" + } + ] +} diff --git a/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts new file mode 100644 index 000000000..c99379d49 --- /dev/null +++ b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts @@ -0,0 +1,56 @@ +import * as cdk from "aws-cdk-lib"; +import * as lambda from "aws-cdk-lib/aws-lambda"; +import * as iam from "aws-cdk-lib/aws-iam"; +import { Construct } from "constructs"; + +export class LambdaDurableExecutionJavaStack extends cdk.Stack { + constructor(scope: Construct, id: string, props?: cdk.StackProps) { + super(scope, id, props); + + // Lambda function + const fn = new lambda.Function(this, "DurableOrderProcessorFn", { + runtime: lambda.Runtime.JAVA_17, + handler: "com.example.OrderProcessor::handleRequest", + code: lambda.Code.fromAsset("src/target/lambda-durable-execution-java-1.0.0.jar"), + timeout: cdk.Duration.minutes(15), + memorySize: 512, + description: "Durable order processing workflow using Java SDK", + }); + + // Enable durable execution via escape hatch + const cfnFn = fn.node.defaultChild as lambda.CfnFunction; + cfnFn.addOverride("Properties.DurableConfig", { + ExecutionTimeout: 3600, + RetentionPeriodInDays: 7, + }); + + // Durable execution checkpoint permissions + fn.addToRolePolicy( + new iam.PolicyStatement({ + actions: [ + "lambda:CheckpointDurableExecution", + "lambda:GetDurableExecutionState", + ], + resources: ["*"], + }) + ); + + // Version and alias via L1 to avoid CDK version property validation + const version = new lambda.CfnVersion(this, "FnVersion", { + functionName: fn.functionName, + description: "Durable execution version", + }); + + const alias = new lambda.CfnAlias(this, "ProdAlias", { + functionName: fn.functionName, + functionVersion: version.attrVersion, + name: "prod", + }); + + new cdk.CfnOutput(this, "FunctionName", { value: fn.functionName }); + new cdk.CfnOutput(this, "FunctionAliasArn", { + value: alias.ref, + description: "Use this ARN to invoke the durable function", + }); + } +} diff --git a/lambda-durable-execution-java-cdk/package.json b/lambda-durable-execution-java-cdk/package.json new file mode 100644 index 000000000..6d7b9a917 --- /dev/null +++ b/lambda-durable-execution-java-cdk/package.json @@ -0,0 +1,20 @@ +{ + "name": "lambda-durable-execution-java-cdk", + "version": "1.0.0", + "bin": { + "app": "bin/app.ts" + }, + "scripts": { + "build": "tsc", + "cdk": "cdk" + }, + "dependencies": { + "aws-cdk-lib": "2.180.0", + "constructs": "10.4.2" + }, + "devDependencies": { + "@types/node": "^22.0.0", + "ts-node": "^10.9.0", + "typescript": "~5.7.0" + } +} diff --git a/lambda-durable-execution-java-cdk/src/Dockerfile b/lambda-durable-execution-java-cdk/src/Dockerfile new file mode 100644 index 000000000..f1d792c40 --- /dev/null +++ b/lambda-durable-execution-java-cdk/src/Dockerfile @@ -0,0 +1,5 @@ +FROM maven:3.9-amazoncorretto-17 AS build +WORKDIR /app +COPY pom.xml . +COPY main/ src/main/ +RUN mvn clean package -DskipTests diff --git a/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java b/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java new file mode 100644 index 000000000..61fc0e1ec --- /dev/null +++ b/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java @@ -0,0 +1,63 @@ +package com.example; + +import software.amazon.lambda.durable.DurableContext; +import software.amazon.lambda.durable.DurableHandler; + +import java.time.Duration; +import java.util.Map; +import java.util.UUID; + +/** + * Durable order processing workflow that demonstrates automatic checkpointing, + * wait operations, and multi-step orchestration using the Java Durable Execution SDK. + * + * Each step is checkpointed — if the function is interrupted, it resumes from + * the last completed step without re-executing previous work. + */ +public class OrderProcessor extends DurableHandler, Map> { + + @Override + public Map handleRequest(Map input, DurableContext ctx) { + String orderId = (String) input.getOrDefault("orderId", UUID.randomUUID().toString()); + double amount = ((Number) input.getOrDefault("amount", 99.99)).doubleValue(); + + // Step 1: Validate order + String validation = ctx.step("validate-order", String.class, stepCtx -> { + System.out.println("Validating order " + orderId); + if (amount <= 0) { + throw new IllegalArgumentException("Invalid order amount: " + amount); + } + return "VALIDATED"; + }); + + // Step 2: Reserve inventory + String reservationId = ctx.step("reserve-inventory", String.class, stepCtx -> { + System.out.println("Reserving inventory for order " + orderId); + return "RES-" + UUID.randomUUID().toString().substring(0, 8); + }); + + // Step 3: Process payment + String paymentId = ctx.step("process-payment", String.class, stepCtx -> { + System.out.println("Processing payment of $" + amount + " for order " + orderId); + return "PAY-" + UUID.randomUUID().toString().substring(0, 8); + }); + + // Wait for warehouse processing (no compute charges during wait) + ctx.wait("warehouse-processing", Duration.ofSeconds(5)); + + // Step 4: Confirm shipment + String trackingNumber = ctx.step("confirm-shipment", String.class, stepCtx -> { + System.out.println("Confirming shipment for order " + orderId); + return "TRACK-" + UUID.randomUUID().toString().substring(0, 8); + }); + + return Map.of( + "orderId", orderId, + "status", "COMPLETED", + "validation", validation, + "reservationId", reservationId, + "paymentId", paymentId, + "trackingNumber", trackingNumber + ); + } +} diff --git a/lambda-durable-execution-java-cdk/src/pom.xml b/lambda-durable-execution-java-cdk/src/pom.xml new file mode 100644 index 000000000..2e2955378 --- /dev/null +++ b/lambda-durable-execution-java-cdk/src/pom.xml @@ -0,0 +1,43 @@ + + + 4.0.0 + + com.example + lambda-durable-execution-java + 1.0.0 + jar + + + 17 + 17 + UTF-8 + + + + + software.amazon.lambda.durable + aws-durable-execution-sdk-java + 1.0.1 + + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.6.0 + + + package + + shade + + + + + + + diff --git a/lambda-durable-execution-java-cdk/tsconfig.json b/lambda-durable-execution-java-cdk/tsconfig.json new file mode 100644 index 000000000..15e54de36 --- /dev/null +++ b/lambda-durable-execution-java-cdk/tsconfig.json @@ -0,0 +1,20 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "commonjs", + "lib": ["es2020"], + "declaration": true, + "strict": true, + "noImplicitAny": true, + "strictNullChecks": true, + "noImplicitThis": true, + "alwaysStrict": true, + "outDir": "build", + "rootDir": ".", + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "esModuleInterop": true + }, + "exclude": ["node_modules", "build", "src"] +} From 8f0072a7f4cf2de9d0e67a72d80394d576b4cd61 Mon Sep 17 00:00:00 2001 From: Nithin Chandran Rajashankar Date: Fri, 24 Apr 2026 03:39:58 +0000 Subject: [PATCH 2/5] fix(iam): use AWSLambdaBasicDurableExecutionRolePolicy managed policy Replace inline durable execution policy (wildcard resources) with the AWS managed policy for least-privilege IAM, matching the approach recommended in PR #3053 review feedback. --- .../lib/lambda-durable-execution-java-stack.ts | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts index c99379d49..0a824684a 100644 --- a/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts +++ b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts @@ -24,15 +24,11 @@ export class LambdaDurableExecutionJavaStack extends cdk.Stack { RetentionPeriodInDays: 7, }); - // Durable execution checkpoint permissions - fn.addToRolePolicy( - new iam.PolicyStatement({ - actions: [ - "lambda:CheckpointDurableExecution", - "lambda:GetDurableExecutionState", - ], - resources: ["*"], - }) + // Durable execution permissions via AWS managed policy + fn.role!.addManagedPolicy( + iam.ManagedPolicy.fromAwsManagedPolicyName( + "service-role/AWSLambdaBasicDurableExecutionRolePolicy" + ) ); // Version and alias via L1 to avoid CDK version property validation From abd1032fde56a2f16160ada18bda3630bc0b88c4 Mon Sep 17 00:00:00 2001 From: Nithin Chandran Rajashankar Date: Tue, 26 May 2026 07:22:06 +0000 Subject: [PATCH 3/5] fix: Replay determinism and structured logging - Wrap UUID.randomUUID() in ctx.step() to ensure stable orderId across replays after mid-workflow interruption - Replace System.out.println with stepCtx.getLogger().info() for DurableLogger with retry-attempt counters, replay flags, and correlation metadata Addresses review feedback from parikhudit. --- lambda-durable-execution-java-cdk/README.md | 1 + .../src/main/java/com/example/OrderProcessor.java | 13 ++++++++----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/lambda-durable-execution-java-cdk/README.md b/lambda-durable-execution-java-cdk/README.md index b332648e5..2031c8f7d 100644 --- a/lambda-durable-execution-java-cdk/README.md +++ b/lambda-durable-execution-java-cdk/README.md @@ -40,6 +40,7 @@ Important: this application uses various AWS services and there are costs associ ```bash cdk deploy ``` + > **Note:** If this is the first time you deploy a CDK stack in this account/region, run `cdk bootstrap` before `cdk deploy`. ## How it works diff --git a/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java b/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java index 61fc0e1ec..0edc61aae 100644 --- a/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java +++ b/lambda-durable-execution-java-cdk/src/main/java/com/example/OrderProcessor.java @@ -18,12 +18,15 @@ public class OrderProcessor extends DurableHandler, Map handleRequest(Map input, DurableContext ctx) { - String orderId = (String) input.getOrDefault("orderId", UUID.randomUUID().toString()); + // Wrap UUID generation in a step to ensure determinism on replay + String orderId = input.containsKey("orderId") + ? (String) input.get("orderId") + : ctx.step("generate-order-id", String.class, stepCtx -> UUID.randomUUID().toString()); double amount = ((Number) input.getOrDefault("amount", 99.99)).doubleValue(); // Step 1: Validate order String validation = ctx.step("validate-order", String.class, stepCtx -> { - System.out.println("Validating order " + orderId); + stepCtx.getLogger().info("Validating order " + orderId); if (amount <= 0) { throw new IllegalArgumentException("Invalid order amount: " + amount); } @@ -32,13 +35,13 @@ public Map handleRequest(Map input, DurableConte // Step 2: Reserve inventory String reservationId = ctx.step("reserve-inventory", String.class, stepCtx -> { - System.out.println("Reserving inventory for order " + orderId); + stepCtx.getLogger().info("Reserving inventory for order " + orderId); return "RES-" + UUID.randomUUID().toString().substring(0, 8); }); // Step 3: Process payment String paymentId = ctx.step("process-payment", String.class, stepCtx -> { - System.out.println("Processing payment of $" + amount + " for order " + orderId); + stepCtx.getLogger().info("Processing payment of $" + amount + " for order " + orderId); return "PAY-" + UUID.randomUUID().toString().substring(0, 8); }); @@ -47,7 +50,7 @@ public Map handleRequest(Map input, DurableConte // Step 4: Confirm shipment String trackingNumber = ctx.step("confirm-shipment", String.class, stepCtx -> { - System.out.println("Confirming shipment for order " + orderId); + stepCtx.getLogger().info("Confirming shipment for order " + orderId); return "TRACK-" + UUID.randomUUID().toString().substring(0, 8); }); From dc114d1664ff7cb37fbc529d7f2afda880ffd5b3 Mon Sep 17 00:00:00 2001 From: Nithin Chandran Rajashankar Date: Tue, 26 May 2026 08:37:05 +0000 Subject: [PATCH 4/5] chore: Remove unused Dockerfile The CDK stack uses Code.fromAsset() with the pre-built JAR and the README instructs mvn clean package on the host. The Dockerfile was never part of the deploy flow. --- lambda-durable-execution-java-cdk/src/Dockerfile | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 lambda-durable-execution-java-cdk/src/Dockerfile diff --git a/lambda-durable-execution-java-cdk/src/Dockerfile b/lambda-durable-execution-java-cdk/src/Dockerfile deleted file mode 100644 index f1d792c40..000000000 --- a/lambda-durable-execution-java-cdk/src/Dockerfile +++ /dev/null @@ -1,5 +0,0 @@ -FROM maven:3.9-amazoncorretto-17 AS build -WORKDIR /app -COPY pom.xml . -COPY main/ src/main/ -RUN mvn clean package -DskipTests From 13d6593a52529a3a37d20dd26e6572617fb84051 Mon Sep 17 00:00:00 2001 From: Nithin Chandran Rajashankar Date: Tue, 26 May 2026 09:51:38 +0000 Subject: [PATCH 5/5] refactor: Use native durableConfig property and L2 Alias Switched from L1 escape hatch (CfnFunction.addOverride + CfnVersion + CfnAlias) to native durableConfig property on lambda.Function with L2 lambda.Alias against fn.currentVersion. Requires aws-cdk-lib@2.257.0. Cleaner, type-safe, and consistent with official CDK docs. --- .../lambda-durable-execution-java-stack.ts | 28 ++++++------------- .../package.json | 2 +- 2 files changed, 9 insertions(+), 21 deletions(-) diff --git a/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts index 0a824684a..4aaae51b9 100644 --- a/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts +++ b/lambda-durable-execution-java-cdk/lib/lambda-durable-execution-java-stack.ts @@ -7,7 +7,6 @@ export class LambdaDurableExecutionJavaStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); - // Lambda function const fn = new lambda.Function(this, "DurableOrderProcessorFn", { runtime: lambda.Runtime.JAVA_17, handler: "com.example.OrderProcessor::handleRequest", @@ -15,37 +14,26 @@ export class LambdaDurableExecutionJavaStack extends cdk.Stack { timeout: cdk.Duration.minutes(15), memorySize: 512, description: "Durable order processing workflow using Java SDK", + durableConfig: { + executionTimeout: cdk.Duration.hours(1), + retentionPeriod: cdk.Duration.days(7), + }, }); - // Enable durable execution via escape hatch - const cfnFn = fn.node.defaultChild as lambda.CfnFunction; - cfnFn.addOverride("Properties.DurableConfig", { - ExecutionTimeout: 3600, - RetentionPeriodInDays: 7, - }); - - // Durable execution permissions via AWS managed policy fn.role!.addManagedPolicy( iam.ManagedPolicy.fromAwsManagedPolicyName( "service-role/AWSLambdaBasicDurableExecutionRolePolicy" ) ); - // Version and alias via L1 to avoid CDK version property validation - const version = new lambda.CfnVersion(this, "FnVersion", { - functionName: fn.functionName, - description: "Durable execution version", - }); - - const alias = new lambda.CfnAlias(this, "ProdAlias", { - functionName: fn.functionName, - functionVersion: version.attrVersion, - name: "prod", + const alias = new lambda.Alias(this, "ProdAlias", { + aliasName: "prod", + version: fn.currentVersion, }); new cdk.CfnOutput(this, "FunctionName", { value: fn.functionName }); new cdk.CfnOutput(this, "FunctionAliasArn", { - value: alias.ref, + value: alias.aliasName, description: "Use this ARN to invoke the durable function", }); } diff --git a/lambda-durable-execution-java-cdk/package.json b/lambda-durable-execution-java-cdk/package.json index 6d7b9a917..4ef538c4c 100644 --- a/lambda-durable-execution-java-cdk/package.json +++ b/lambda-durable-execution-java-cdk/package.json @@ -9,7 +9,7 @@ "cdk": "cdk" }, "dependencies": { - "aws-cdk-lib": "2.180.0", + "aws-cdk-lib": "^2.257.0", "constructs": "10.4.2" }, "devDependencies": {