Creating Lambda durable functions

To modify the code in the console

1. Choose the Code tab.

   In the console's built-in code editor, you should see the function code that Lambda created. If you don't see the index.mjs tab in the code editor, select index.mjs in the file explorer as shown on the following diagram.

   Diagram showing the console code editor and the index.mjs file in the file explorer

2. Paste the following code into the index.mjs tab, replacing the code that Lambda created.

   import {
    withDurableExecution,
   } from "@aws/durable-execution-sdk-js";
   export const handler = withDurableExecution(
    async (event, context) => {
    const orderId = event.orderId;
    
    // Step 1: Validate order
    const validationResult = await context.step(async (stepContext) => {
    stepContext.logger.info(`Validating order ${orderId}`);
    return { orderId, status: "validated" };
    });
    
    // Step 2: Process payment
    const paymentResult = await context.step(async (stepContext) => {
    stepContext.logger.info(`Processing payment for order ${orderId}`);
    return { orderId, status: "paid", amount: 99.99 };
    });
    
    // Wait for 10 seconds to simulate external confirmation
    await context.wait({ seconds: 10 });
    
    // Step 3: Confirm order
    const confirmationResult = await context.step(async (stepContext) => {
    stepContext.logger.info(`Confirming order ${orderId}`);
    return { orderId, status: "confirmed" };
    });
    
    return {
    orderId: orderId,
    status: "completed",
    steps: [validationResult, paymentResult, confirmationResult]
    };
    }
   );

3. In the DEPLOY section, choose Deploy to update your function's code:

   Deploy button in the Lambda console code editor

• The withDurableExecution wrapper:

  Your durable function is wrapped with withDurableExecution. This wrapper enables durable execution by providing the DurableContext object and managing checkpoint operations.

• The DurableContext object:

  Instead of the standard Lambda context, your function receives a DurableContext. This object provides methods for durable operations like step() and wait() that create checkpoints.

• Steps and checkpoints:

  Each context.step() call creates a checkpoint before and after execution. If your function is interrupted, it resumes from the last completed checkpoint. The function doesn't re-execute completed steps. It uses their stored results instead.

• Wait operations:

  The context.wait() call pauses execution without consuming compute resources. When the wait completes, Lambda invokes your function again and replays the checkpoint log, substituting stored values for completed steps.

• Replay mechanism:

  When your function resumes after a wait or interruption, Lambda runs your code from the beginning. However, completed steps don't re-execute. Lambda replays their results from the checkpoint log. This is why your code must be deterministic.

To modify the code in the console

1. Choose the Code tab.

   In the console's built-in code editor, you should see the function code that Lambda created. If you don't see the lambda_function.py tab in the code editor, select lambda_function.py in the file explorer as shown on the following diagram.

   Diagram showing the console code editor and the lambda_function.py file in the file explorer

2. Paste the following code into the lambda_function.py tab, replacing the code that Lambda created.

   from aws_durable_execution_sdk_python import (
    DurableContext,
    durable_execution,
    durable_step,
   )
   from aws_durable_execution_sdk_python.config import Duration
   @durable_step
   def validate_order(step_context, order_id):
    step_context.logger.info(f"Validating order {order_id}")
    return {"orderId": order_id, "status": "validated"}
   @durable_step
   def process_payment(step_context, order_id):
    step_context.logger.info(f"Processing payment for order {order_id}")
    return {"orderId": order_id, "status": "paid", "amount": 99.99}
   @durable_step
   def confirm_order(step_context, order_id):
    step_context.logger.info(f"Confirming order {order_id}")
    return {"orderId": order_id, "status": "confirmed"}
   @durable_execution
   def lambda_handler(event, context: DurableContext):
    order_id = event['orderId']
    
    # Step 1: Validate order
    validation_result = context.step(validate_order(order_id))
    
    # Step 2: Process payment
    payment_result = context.step(process_payment(order_id))
    
    # Wait for 10 seconds to simulate external confirmation
    context.wait(Duration.from_seconds(10))
    
    # Step 3: Confirm order
    confirmation_result = context.step(confirm_order(order_id))
    
    return {
    "orderId": order_id,
    "status": "completed",
    "steps": [validation_result, payment_result, confirmation_result]
    }

3. In the DEPLOY section, choose Deploy to update your function's code:

   Deploy button in the Lambda console code editor

• The @durable_execution decorator:

  Your handler function is decorated with @durable_execution. This decorator enables durable execution by providing the DurableContext object and managing checkpoint operations.

• The @durable_step decorator:

  Each step function is decorated with @durable_step. This decorator marks the function as a durable step that creates checkpoints.

• The DurableContext object:

  Instead of the standard Lambda context, your function receives a DurableContext. This object provides methods for durable operations like step() and wait() that create checkpoints.

• Steps and checkpoints:

  Each context.step() call creates a checkpoint before and after execution. If your function is interrupted, it resumes from the last completed checkpoint. The function doesn't re-execute completed steps. It uses their stored results instead.

• Wait operations:

  The context.wait() call pauses execution without consuming compute resources. When the wait completes, Lambda invokes your function again and replays the checkpoint log, substituting stored values for completed steps.

• Python SDK is synchronous:

  Note that the Python SDK doesn't use await. All durable operations are synchronous method calls.