Implementa le funzioni durevoli di Lambda con Infrastructure as Code

Puoi implementare funzioni durevoli Lambda utilizzando strumenti Infrastructure as Code (IaC) AWS CloudFormation come AWS CDK, o. AWS Serverless Application Model Questi strumenti consentono di definire la funzione, il ruolo di esecuzione e le autorizzazioni nel codice, rendendo le distribuzioni ripetibili e controllate dalla versione.

Tutti e tre gli strumenti richiedono di:

• Abilitare l'esecuzione duratura della funzione

• Concedi i permessi di checkpoint al ruolo di esecuzione

• Pubblica una versione o crea un alias (le funzioni durevoli richiedono competenze qualificate) ARNs

AWS CloudFormation

CloudFormation Utilizzatelo per definire la vostra funzione duratura in un modello. L'esempio seguente crea una funzione durevole con le autorizzazioni richieste.

AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda durable function example

Resources:
  DurableFunctionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DurableExecutionPolicy
          PolicyDocument:
            Version: '2012-10-17'		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - lambda:CheckpointDurableExecutions
                  - lambda:GetDurableExecutionState
                Resource: !GetAtt DurableFunction.Arn

  DurableFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: myDurableFunction
      Runtime: nodejs22.x
      Handler: index.handler
      Role: !GetAtt DurableFunctionRole.Arn
      Code:
        ZipFile: |
          // Your durable function code here
          export const handler = async (event, context) => {
            return { statusCode: 200 };
          };
      DurableConfig:
        ExecutionTimeout: 10
        RetentionPeriodInDays: 1

  DurableFunctionVersion:
    Type: AWS::Lambda::Version
    Properties:
      FunctionName: !Ref DurableFunction
      Description: Initial version

  DurableFunctionAlias:
    Type: AWS::Lambda::Alias
    Properties:
      FunctionName: !Ref DurableFunction
      FunctionVersion: !GetAtt DurableFunctionVersion.Version
      Name: prod

Outputs:
  FunctionArn:
    Description: Durable function ARN
    Value: !GetAtt DurableFunction.Arn
  AliasArn:
    Description: Function alias ARN (use this for invocations)
    Value: !Ref DurableFunctionAlias

Per distribuire il modello

aws cloudformation deploy \
  --template-file template.yaml \
  --stack-name my-durable-function-stack \
  --capabilities CAPABILITY_IAM

AWS CDK

AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole usando TypeScript e Python.

TypeScript

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 DurableFunctionStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Create the durable function
    const durableFunction = new lambda.Function(this, 'DurableFunction', {
      runtime: lambda.Runtime.NODEJS_22_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
      functionName: 'myDurableFunction',
      durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
    });

    // Add checkpoint permissions
    durableFunction.addToRolePolicy(new iam.PolicyStatement({
      actions: [
        'lambda:CheckpointDurableExecutions',
        'lambda:GetDurableExecutionState',
      ],
      resources: [durableFunction.functionArn],
    }));

    // Create version and alias
    const version = durableFunction.currentVersion;
    const alias = new lambda.Alias(this, 'ProdAlias', {
      aliasName: 'prod',
      version: version,
    });

    // Output the alias ARN
    new cdk.CfnOutput(this, 'FunctionAliasArn', {
      value: alias.functionArn,
      description: 'Use this ARN to invoke the durable function',
    });
  }
}

Python

from aws_cdk import (
    Stack,
    aws_lambda as lambda_,
    aws_iam as iam,
    CfnOutput,
)
from constructs import Construct

class DurableFunctionStack(Stack):
    def __init__(self, scope: Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        # Create the durable function
        durable_function = lambda_.Function(
            self, 'DurableFunction',
            runtime=lambda_.Runtime.NODEJS_22_X,
            handler='index.handler',
            code=lambda_.Code.from_asset('lambda'),
            function_name='myDurableFunction',
            durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)}
        )

        # Add checkpoint permissions
        durable_function.add_to_role_policy(iam.PolicyStatement(
            actions=[
                'lambda:CheckpointDurableExecutions',
                'lambda:GetDurableExecutionState',
            ],
            resources=[durable_function.function_arn]
        ))

        # Create version and alias
        version = durable_function.current_version
        alias = lambda_.Alias(
            self, 'ProdAlias',
            alias_name='prod',
            version=version
        )

        # Output the alias ARN
        CfnOutput(
            self, 'FunctionAliasArn',
            value=alias.function_arn,
            description='Use this ARN to invoke the durable function'
        )

Per distribuire lo stack CDK

cdk deploy

AWS Serverless Application Model

AWS SAM semplifica i CloudFormation modelli per le applicazioni serverless. Il modello seguente crea una funzione durevole con. AWS SAM

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM

Resources:
  DurableFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: myDurableFunction
      Runtime: nodejs22.x
      Handler: index.handler
      CodeUri: ./src
      DurableConfig:
        ExecutionTimeout: 10
        RetentionPeriodInDays: 1
      Policies:
        - Version: '2012-10-17'		 	 	 
          Statement:
            - Effect: Allow
              Action:
                - lambda:CheckpointDurableExecutions
                - lambda:GetDurableExecutionState
              Resource: !Sub 'arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:${DurableFunction}'
      AutoPublishAlias: prod

Outputs:
  FunctionArn:
    Description: Durable function ARN
    Value: !GetAtt DurableFunction.Arn
  AliasArn:
    Description: Function alias ARN (use this for invocations)
    Value: !Ref DurableFunction.Alias

Per distribuire il modello SAM

sam build
sam deploy --guided

Modelli di configurazione comuni

Indipendentemente dallo strumento IaC utilizzato, segui questi schemi per funzioni durevoli:

Abilita un'esecuzione duratura

Impostare la proprietà DurableExecution.Enabled su true. Questa proprietà è disponibile solo durante la creazione della funzione, non è possibile abilitare l'esecuzione durevole su funzioni esistenti.

Concedi le autorizzazioni per il checkpoint

Aggiungi lambda:CheckpointDurableExecutions e lambda:GetDurableExecutionState al ruolo di esecuzione. Ambita queste autorizzazioni alla funzione specifica ARN.

Usa qualificati ARNs

Crea una versione o un alias per la tua funzione. Le funzioni durevoli richiedono una ARNs chiamata qualificata (con versione o alias). Utilizza AWS SAM o crea versioni esplicite AutoPublishAlias in e. CloudFormation AWS CDK

Dipendenze dei pacchetti

Includi l'SDK di esecuzione durevole nel tuo pacchetto di distribuzione. Per Node.js, installa@aws/durable-execution-sdk-js. Per Python, installa. aws-durable-execution-sdk-python

Fasi successive

Dopo aver implementato la tua funzione duratura:

• Verifica la tua funzione utilizzando l'ARN qualificato (versione o alias)

• Monitora l'avanzamento dell'esecuzione nella console Lambda nella scheda Esecuzioni durevoli

• Visualizza le operazioni dei checkpoint negli eventi relativi ai dati AWS CloudTrail

• Consulta CloudWatch i registri per verificare l'output delle funzioni e il comportamento di riproduzione

Per ulteriori informazioni sulla distribuzione delle funzioni Lambda con gli strumenti IAc, vedere:

• CloudFormation AWS::Lambda::Function riferimento

• AWS CDK Documentazione del modulo Lambda

• AWS SAM Guida per gli sviluppatori