Fonctionnalités durables grâce à une fermeture éclair Fonctions durables à partir d'une image de conteneur OCI Modèles de configuration courants Étapes suivantes

Déployez des fonctions durables Lambda avec l'infrastructure en tant que code

Vous pouvez déployer des fonctions durables Lambda à l'aide d'outils d'infrastructure en tant que code (IaC) tels que AWS CloudFormation, AWS CDK AWS Serverless Application Model, ou Terraform. Ces outils vous permettent de définir votre fonction, votre rôle d'exécution et vos autorisations dans le code, ce qui rend les déploiements reproductibles et contrôlés par version.

Les trois outils vous obligent à :

Permettre une exécution durable de la fonction
Accorder des autorisations de point de contrôle au rôle d'exécution
Publier une version ou créer un alias (les fonctions durables nécessitent une qualification ARNs)

Fonctionnalités durables grâce à une fermeture éclair

AWS CloudFormation

CloudFormation À utiliser pour définir votre fonction durable dans un modèle. L'exemple suivant crée une fonction durable dotée des autorisations requises.


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

Pour déployer le modèle


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

AWS CDK

AWS CDK vous permet de définir l'infrastructure à l'aide de langages de programmation. Les exemples suivants montrent comment créer une fonction durable à l'aide TypeScript de 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'
        )

Pour déployer la pile CDK


cdk deploy

AWS Serverless Application Model

AWS SAM simplifie les CloudFormation modèles pour les applications sans serveur. Le modèle suivant crée une fonction durable avec 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

Pour déployer le modèle SAM


sam build
sam deploy --guided

Terraform

Terraform est un outil IaC open source populaire qui prend en charge les ressources. AWS L'exemple suivant crée une fonction durable avec Terraform à l'aide du AWS fournisseur version 6.25.0 ou ultérieure.


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
}

Pour déployer avec Terraform


terraform init
terraform plan
terraform apply

Note

La prise en charge par Terraform des fonctions durables Lambda nécessite la version 6.25.0 ou ultérieure du AWS fournisseur. Mettez à jour la version de votre fournisseur si vous utilisez une ancienne version.

Fonctions durables à partir d'une image de conteneur OCI

Vous pouvez également créer des fonctions durables à partir d'images de conteneurs. Pour obtenir des instructions sur la création d'une image de conteneur, voir Runtimes pris en charge pour des fonctions durables.

AWS CDK

AWS CDK vous permet de définir l'infrastructure à l'aide de langages de programmation. Les exemples suivants montrent comment créer une fonction durable à TypeScript partir d'une image de conteneur.


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

Pour déployer la pile CDK


cdk deploy

AWS Serverless Application Model

AWS SAM simplifie les CloudFormation modèles pour les applications sans serveur. Le modèle suivant crée une fonction durable avec 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

Pour déployer le modèle SAM


sam build
sam deploy --guided

Modèles de configuration courants

Quel que soit l'outil IaC que vous utilisez, suivez les modèles suivants pour des fonctions durables :

Permettre une exécution durable

Définissez la DurableConfig propriété de votre fonction pour permettre une exécution durable. Cette propriété n'est disponible que lors de la création de la fonction. Vous ne pouvez pas activer l'exécution durable sur des fonctions existantes.

Accorder des autorisations aux points de contrôle

Associez la politique AWSLambdaBasicDurableExecutionRolePolicy gérée au rôle d'exécution. Cette politique inclut les lambda:GetDurableExecutionState autorisations lambda:CheckpointDurableExecutions et les autorisations requises.

Utiliser qualifié ARNs

Créez une version ou un alias pour votre fonction. Les fonctions durables nécessitent une qualification ARNs (avec version ou alias) pour être invoquées. Utilisez AutoPublishAlias AWS SAM ou créez des versions explicites dans CloudFormation AWS CDK, et Terraform.

Dépendances de package

Incluez le SDK d'exécution durable dans votre package de déploiement. Pour Node.js, installez@aws/durable-execution-sdk-js. Pour Python, installezaws-durable-execution-sdk-python.

Étapes suivantes

Après avoir déployé votre fonction durable :

Testez votre fonction à l'aide de l'ARN qualifié (version ou alias)
Surveillez la progression de l'exécution dans la console Lambda sous l'onglet Exécutions durables
Afficher les opérations des points de contrôle dans les événements de AWS CloudTrail données
Consultez CloudWatch les journaux pour connaître le comportement des fonctions, des sorties et des rediffusions

Pour plus d'informations sur le déploiement de fonctions Lambda avec les outils IaC, voir :

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déploiement avec CLI

Fonctions durables ou Step Functions