Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Implementa le funzioni durevoli di Lambda con Infrastructure as Code
Puoi implementare funzioni durevoli Lambda utilizzando strumenti Infrastructure as Code (IaC) AWS CloudFormation come AWS CDK, AWS Serverless Application Model, o Terraform. Questi strumenti consentono di definire la funzione, il ruolo di esecuzione e le autorizzazioni nel codice, rendendo le distribuzioni ripetibili e controllate dalla versione.
Tutti e tre gli strumenti richiedono di:
+ Abilitare l'esecuzione duratura della funzione
+ Concedi i permessi di checkpoint al ruolo di esecuzione
+ Pubblica una versione o crea un alias (le funzioni durevoli richiedono competenze qualificate) ARNs
## Funzioni durevoli da un file ZIP
### AWS CloudFormation
CloudFormation Utilizzatelo per definire la vostra funzione duratura in un modello. L'esempio seguente crea una funzione durevole con le autorizzazioni richieste.
```
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
```
**Per distribuire il modello**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole usando TypeScript e 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'
)
```
------
**Per distribuire lo stack CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM semplifica i CloudFormation modelli per le applicazioni serverless. Il modello seguente crea una funzione durevole con. 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
```
**Per distribuire il modello SAM**
```
sam build
sam deploy --guided
```
### Terraform
Terraform è un popolare strumento IaC open source che supporta le risorse. AWS L'esempio seguente crea una funzione duratura con Terraform utilizzando la versione del AWS provider 6.25.0 o successiva.
```
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
}
```
**Da distribuire con Terraform**
```
terraform init
terraform plan
terraform apply
```
**Nota**
Il supporto Terraform per le funzioni durevoli Lambda AWS richiede la versione del provider 6.25.0 o successiva. Aggiorna la versione del provider se utilizzi una versione precedente.
## Funzioni durevoli da un'immagine del contenitore OCI
È inoltre possibile creare funzioni Durable basate sulle immagini dei contenitori. Per istruzioni su come creare un'immagine del contenitore, consulta [Runtime supportati per funzioni durevoli](durable-supported-runtimes.md).
### AWS CDK
AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole utilizzando l'immagine TypeScript di un contenitore.
```
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',
});
}
}
```
**Per distribuire lo stack CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM semplifica i CloudFormation modelli per le applicazioni serverless. Il modello seguente crea una funzione durevole con. 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
```
**Per distribuire il modello SAM**
```
sam build
sam deploy --guided
```
## Modelli di configurazione comuni
Indipendentemente dallo strumento IaC utilizzato, segui questi schemi per funzioni durevoli:
**Abilita un'esecuzione duratura**
Imposta la `DurableConfig` proprietà sulla tua funzione per abilitare l'esecuzione duratura. Questa proprietà è disponibile solo durante la creazione della funzione. Non è possibile abilitare l'esecuzione duratura di funzioni esistenti.
**Concedi le autorizzazioni per i checkpoint**
Allega la policy `AWSLambdaBasicDurableExecutionRolePolicy` gestita al ruolo di esecuzione. Questa politica include i requisiti `lambda:CheckpointDurableExecution` e `lambda:GetDurableExecutionState` le autorizzazioni.
**Usa qualificati ARNs**
Crea una versione o un alias per la tua funzione. Le funzioni durevoli richiedono una ARNs chiamata qualificata (con versione o alias). Usa AWS SAM o crea versioni esplicite `AutoPublishAlias` in CloudFormation, AWS CDK e Terraform.
**Dipendenze dei pacchetti**
Includi l'SDK di esecuzione durevole nel tuo pacchetto di distribuzione. Per Node.js, installa`@aws/durable-execution-sdk-js`. Per Python, installa. `aws-durable-execution-sdk-python`
## Fasi successive
Dopo aver implementato la tua funzione duratura:
+ Verifica la tua funzione utilizzando l'ARN qualificato (versione o alias)
+ Monitora l'avanzamento dell'esecuzione nella console Lambda nella scheda Esecuzioni durevoli
+ Visualizza le operazioni dei checkpoint negli eventi relativi ai dati AWS CloudTrail
+ Consulta CloudWatch i registri per verificare l'output delle funzioni e il comportamento di riproduzione
Per ulteriori informazioni sulla distribuzione delle funzioni Lambda con gli strumenti IAc, vedere:
+ [CloudFormation AWS::Lambda::Function riferimento](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentazione del modulo Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Guida per gli sviluppatori](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)