Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Stellen Sie langlebige Lambda-Funktionen mit Infrastructure as Code bereit

Sie können dauerhafte Lambda-Funktionen mithilfe von Infrastructure as Code (IaC) -Tools wie AWS CloudFormation AWS CDK, oder bereitstellen. AWS Serverless Application Model Mit diesen Tools können Sie Ihre Funktion, Ausführungsrolle und Berechtigungen im Code definieren, sodass Bereitstellungen wiederholbar und versionskontrolliert werden können.

Für alle drei Tools müssen Sie:

AWS CloudFormation

Wird verwendet CloudFormation , um Ihre dauerhafte Funktion in einer Vorlage zu definieren. Im folgenden Beispiel wird eine dauerhafte Funktion mit den erforderlichen Berechtigungen erstellt.

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

Um die Vorlage bereitzustellen

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

AWS CDK

AWS CDK ermöglicht es Ihnen, die Infrastruktur mithilfe von Programmiersprachen zu definieren. Die folgenden Beispiele zeigen, wie eine dauerhafte Funktion mit TypeScript Python erstellt wird.

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'
        )

Um den CDK-Stack bereitzustellen

cdk deploy

AWS Serverless Application Model

AWS SAM vereinfacht CloudFormation Vorlagen für serverlose Anwendungen. Die folgende Vorlage erstellt eine dauerhafte Funktion mit 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

Um die SAM-Vorlage bereitzustellen

sam build
sam deploy --guided

Gängige Konfigurationsmuster

Unabhängig davon, welches IaC-Tool Sie verwenden, folgen Sie diesen Mustern für dauerhafte Funktionen:

Dauerhafte Ausführung aktivieren

Legen Sie die Eigenschaft DurableExecution.Enabled auf true fest. Diese Eigenschaft ist nur verfügbar, wenn die Funktion erstellt wird. Sie können die dauerhafte Ausführung für bestehende Funktionen nicht aktivieren.

Erteilen Sie Checkpoint-Berechtigungen

Fügen Sie der Ausführungsrolle lambda:CheckpointDurableExecutions und lambda:GetDurableExecutionState hinzu. Beschränken Sie diese Berechtigungen auf die spezifische Funktion ARN.

Verwenden Sie qualifiziert ARNs

Erstellen Sie eine Version oder einen Alias für Ihre Funktion. Dauerhafte Funktionen erfordern qualifizierte Funktionen ARNs (mit Version oder Alias) für den Aufruf. Verwenden Sie AutoPublishAlias in und AWS SAM oder erstellen Sie explizite Versionen in CloudFormation und AWS CDK.

Abhängigkeiten von Paketen

Nehmen Sie das Durable Execution SDK in Ihr Bereitstellungspaket auf. Installieren Sie Node.js@aws/durable-execution-sdk-js. Installieren Sie Pythonaws-durable-execution-sdk-python.

Nächste Schritte

Nach der Bereitstellung Ihrer dauerhaften Funktion:

Weitere Informationen zur Bereitstellung von Lambda-Funktionen mit IaC-Tools finden Sie unter: