Dauerhafte Funktionen aus einer ZIP-Datei Dauerhafte Funktionen aus einem OCI-Container-Image Gängige Konfigurationsmuster Nächste Schritte

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 AWS Serverless Application Model, oder Terraform bereitstellen. 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:

Ermöglichen Sie die dauerhafte Ausführung der Funktion
Erteilen Sie der Ausführungsrolle Checkpoint-Berechtigungen
Veröffentlichen Sie eine Version oder erstellen Sie einen Alias (dauerhafte Funktionen erfordern qualifizierte ARNs Funktionen)

Dauerhafte Funktionen aus einer ZIP-Datei

AWS CloudFormation

Verwenden Sie CloudFormation diese Option, 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/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

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

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

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

Um die SAM-Vorlage bereitzustellen


sam build
sam deploy --guided

Terraform

Terraform ist ein beliebtes Open-Source-IaC-Tool, das Ressourcen unterstützt. AWS Das folgende Beispiel erstellt eine dauerhafte Funktion mit Terraform unter Verwendung der Provider-Version 6.25.0 oder höher. AWS


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
}

Zur Bereitstellung mit Terraform


terraform init
terraform plan
terraform apply

Anmerkung

Die Terraform-Unterstützung für langlebige Lambda-Funktionen erfordert die AWS Provider-Version 6.25.0 oder höher. Aktualisieren Sie Ihre Provider-Version, wenn Sie eine ältere Version verwenden.

Dauerhafte Funktionen aus einem OCI-Container-Image

Sie können auch langlebige Funktionen auf der Grundlage von Container-Images erstellen. Anweisungen zum Erstellen eines Container-Images finden Sie unter Unterstützte Laufzeiten für langlebige Funktionen.

AWS CDK

AWS CDK ermöglicht es Ihnen, die Infrastruktur mithilfe von Programmiersprachen zu definieren. Die folgenden Beispiele zeigen, wie Sie mithilfe TypeScript eines Container-Images eine dauerhafte Funktion erstellen.


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

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

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

Stellen Sie die DurableConfig Eigenschaft Ihrer Funktion ein, um eine dauerhafte Ausführung zu ermöglichen. Diese Eigenschaft ist nur verfügbar, wenn die Funktion erstellt wird. Sie können die dauerhafte Ausführung vorhandener Funktionen nicht aktivieren.

Erteilen Sie Checkpoint-Berechtigungen

Ordnen Sie die AWSLambdaBasicDurableExecutionRolePolicy verwaltete Richtlinie der Ausführungsrolle zu. Diese Richtlinie umfasst die erforderlichen lambda:CheckpointDurableExecutions und erforderlichen lambda:GetDurableExecutionState Berechtigungen.

Qualifiziert verwenden 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 Terraform AWS SAM oder erstellen Sie explizite Versionen in CloudFormation AWS CDK, und Terraform.

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:

Testen Sie Ihre Funktion mit dem qualifizierten ARN (Version oder Alias)
Überwachen Sie den Ausführungsfortschritt in der Lambda-Konsole auf der Registerkarte Dauerhafte Ausführungen
Zeigen Sie Checkpoint-Operationen in Datenereignissen an AWS CloudTrail
Überprüfen Sie die CloudWatch Protokolle auf Funktionsausgabe und Wiedergabeverhalten

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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Mit CLI bereitstellen

Dauerhafte Funktionen oder Step Functions