Funzioni durevoli da un file ZIP Funzioni durevoli da un'immagine del contenitore OCI Modelli di configurazione comuni Fasi successive

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, AWS Serverless Application Model, o Terraform. 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

Funzioni durevoli da un file ZIP

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/AWSLambdaBasicDurableExecutionRolePolicy

  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: 3600
        RetentionPeriodInDays: 7

  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) },
    });

    // 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 durable execution managed policy for checkpoint permissions
        durable_function.role.add_managed_policy(
            iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy')
        )

        # 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: 3600
        RetentionPeriodInDays: 7
      Policies:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
      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

Terraform

Terraform è un popolare strumento IaC open source che supporta le risorse. AWS L'esempio seguente crea una funzione duratura con Terraform utilizzando la versione del AWS provider 6.25.0 o successiva.


terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 6.25.0"
    }
  }
}

provider "aws" {
  region = "us-east-2"
}

# IAM Role for Lambda Function
resource "aws_iam_role" "lambda_role" {
  name = "durable-function-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "lambda.amazonaws.com"
      }
    }]
  })
}

# Attach durable execution policy for checkpoint operations
resource "aws_iam_role_policy_attachment" "lambda_durable" {
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy"
  role       = aws_iam_role.lambda_role.name
}

# Lambda Function with Durable Execution enabled
resource "aws_lambda_function" "durable_function" {
  filename      = "function.zip"
  function_name = "myDurableFunction"
  role          = aws_iam_role.lambda_role.arn
  handler       = "index.handler"
  runtime       = "nodejs22.x"
  timeout       = 30
  memory_size   = 512

  durable_config {
    execution_timeout = 900
    retention_period  = 7
  }
}

# Publish a version
resource "aws_lambda_alias" "prod" {
  name             = "prod"
  function_name    = aws_lambda_function.durable_function.function_name
  function_version = aws_lambda_function.durable_function.version
}

output "function_arn" {
  description = "ARN of the Lambda function"
  value       = aws_lambda_function.durable_function.arn
}

output "alias_arn" {
  description = "ARN of the function alias (use this for invocations)"
  value       = aws_lambda_alias.prod.arn
}

Da distribuire con Terraform


terraform init
terraform plan
terraform apply

Nota

Il supporto Terraform per le funzioni durevoli Lambda AWS richiede la versione del provider 6.25.0 o successiva. Aggiorna la versione del provider se utilizzi una versione precedente.

Funzioni durevoli da un'immagine del contenitore OCI

È inoltre possibile creare funzioni Durable basate sulle immagini dei contenitori. Per istruzioni su come creare un'immagine del contenitore, consulta Runtime supportati per funzioni durevoli.

AWS CDK

AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole utilizzando l'immagine TypeScript di un contenitore.


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.DockerImageFunction(this, 'DurableFunction', {
      code: lambda.DockerImageCode.fromImageAsset('./lambda', {
        platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64,
      }),
      functionName: 'myDurableFunction',
      memorySize: 512,
      timeout: cdk.Duration.seconds(30),
      durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) },
    });

    // 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',
    });
  }
}

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
      PackageType: Image
      ImageUri: ./src
      DurableConfig:
        ExecutionTimeout: 3600
        RetentionPeriodInDays: 7
      Policies:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
      AutoPublishAlias: prod
    Metadata:
      DockerTag: latest
      DockerContext: ./src
      Dockerfile: Dockerfile

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

Imposta la DurableConfig proprietà sulla tua funzione per abilitare l'esecuzione duratura. Questa proprietà è disponibile solo durante la creazione della funzione. Non è possibile abilitare l'esecuzione duratura di funzioni esistenti.

Concedi le autorizzazioni per i checkpoint

Allega la policy AWSLambdaBasicDurableExecutionRolePolicy gestita al ruolo di esecuzione. Questa politica include i requisiti lambda:CheckpointDurableExecutions e lambda:GetDurableExecutionState le autorizzazioni.

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). Usa AWS SAM o crea versioni esplicite AutoPublishAlias in CloudFormation, AWS CDK e Terraform.

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:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Implementazione con CLI

Funzioni durevoli o Step Functions