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 langlebige 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, Ihre Ausführungsrolle und Ihre Berechtigungen im Code definieren, sodass Bereitstellungen wiederholbar und versionskontrolliert sind.

Für alle drei Tools müssen Sie:

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

Dauerhafte Funktionen aus einer ZIP-Datei

AWS CloudFormation

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


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

Mit AWS CDK können Sie die Infrastruktur mithilfe von Programmiersprachen 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

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

Dauerhafte Funktionen aus einem OCI-Container-Image

Sie können Durable-Funktionen auch 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

Mit AWS CDK können Sie die Infrastruktur mithilfe von Programmiersprachen 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, um dauerhafte Funktionen zu gewährleisten:

Ermöglichen Sie eine dauerhafte Ausführung

Stellen Sie die DurableConfig Eigenschaft für Ihre Funktion ein, um eine dauerhafte Ausführung zu ermöglichen. Diese Eigenschaft ist nur beim Erstellen der Funktion verfügbar. Sie können die dauerhafte Ausführung vorhandener Funktionen nicht aktivieren.

Gewähren Sie Checkpoint-Berechtigungen

Hängen Sie die AWSLambdaBasicDurableExecutionRolePolicy verwaltete Richtlinie an die Ausführungsrolle an. Diese Richtlinie umfasst die erforderlichen lambda:CheckpointDurableExecution und lambda:GetDurableExecutionState Berechtigungen.

Verwenden Sie qualifizierte ARNs

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

Abhängigkeiten von Paketen

Nehmen Sie das Durable Execution SDK in Ihr Bereitstellungspaket auf. Für Node.js, installieren@aws/durable-execution-sdk-js. Für Python installieren Sieaws-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
Prü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

Konfigurieren Sie langlebige Funktionen