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 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](durable-supported-runtimes.md).
### 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 Python`aws-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:
+ [CloudFormation AWS::Lambda::Function Referenz](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Dokumentation zum Lambda-Modul](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Entwicklerhandbuch](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)