# Implemente funções duráveis do Lambda com infraestrutura como código
É possível implantar funções duráveis do Lambda usando ferramentas de infraestrutura como código (IaC) como AWS CloudFormation, AWS CDK, AWS Serverless Application Model ou Terraform. Essas ferramentas permitem que você defina sua função, perfil de execução e permissões no código, tornando as implantações repetíveis e controladas por versão.
Todas as três ferramentas exigem que você:
+ Habilite a execução durável da função
+ Conceda permissões de ponto de verifica';cão para o perfil de execução
+ Publique uma versão ou crie um alias (funções duráveis exigem ARNs qualificados)
## Funcionalidades duradouras a partir de um ZIP
### AWS CloudFormation
Use CloudFormation para definir sua função durável em um modelo. O exemplo a seguir cria uma função durável com as permissões necessárias.
```
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
```
**Para implantar o modelo**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK permite definir a infraestrutura usando linguagens de programação. Os exemplos a seguir mostram como criar uma função durável 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'
)
```
------
**Para implantar a pilha do CDK**
```
cdk deploy
```
### AWS Serverless Application Model
O AWS SAM simplifica os modelos do CloudFormation para aplicações com tecnologia sem servidor. O modelo a seguir cria uma função durável com o 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
```
**Para implantar o modelo do SAM**
```
sam build
sam deploy --guided
```
### Terraform
O Terraform é uma ferramenta popular de IaC de código aberto que oferece suporte a recursos de AWS. O exemplo a seguir cria uma função durável com o Terraform usando a versão 6.25.0 ou posterior do provedor 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
}
```
**Para implantar com o Terraform**
```
terraform init
terraform plan
terraform apply
```
**nota**
O suporte do Terraform para funções duráveis do Lambda requer a versão 6.25.0 ou posterior do provedor AWS. Atualize a versão do seu provedor se você estiver usando uma versão mais antiga.
## Funções duráveis a partir de uma imagem de contêiner OCI
Ainda é possível criar funções Durable com base em imagens de contêiner. Para obter instruções sobre como criar uma imagem de contêiner, consulte [Runtimes compatíveis com funções duráveis](durable-supported-runtimes.md).
### AWS CDK
AWS CDK permite definir a infraestrutura usando linguagens de programação. Os exemplos a seguir mostram como criar uma função durável usando TypeScript a partir de uma imagem de contêiner.
```
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',
});
}
}
```
**Para implantar a pilha do CDK**
```
cdk deploy
```
### AWS Serverless Application Model
O AWS SAM simplifica os modelos do CloudFormation para aplicações com tecnologia sem servidor. O modelo a seguir cria uma função durável com o 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
```
**Para implantar o modelo do SAM**
```
sam build
sam deploy --guided
```
## Padrões de configuração comuns
Independentemente de qual ferramenta de IaC você usar, siga estes padrões para funções duráveis:
**Habilitação da execução durável**
Defina a propriedade `DurableConfig` em sua função para permitir uma execução durável. Essa propriedade só estará disponível ao criar a função. Não é possível habilitar execuções duráveis em funções existentes.
**Concessão de permissões de ponto de verificação**
Anexe a política gerenciada `AWSLambdaBasicDurableExecutionRolePolicy` ao perfil de execução. Essa política inclui as permissões obrigatórias de `lambda:CheckpointDurableExecution` e `lambda:GetDurableExecutionState`.
**Use ARNs qualificados**
Crie um uma versão ou alias para a sua função. As funções duráveis exigem ARNs qualificados (com versão ou alias) para invocação. Use `AutoPublishAlias` no AWS SAM ou crie versões explícitas no CloudFormation, AWS CDK e Terraform.
**Dependências de pacotes**
Inclua o SDK de execução durável em seu pacote de implantação. Para o Node.js, instale `@aws/durable-execution-sdk-js`. Para Python, instale `aws-durable-execution-sdk-python`.
## Próximas etapas
Depois de implantar sua função durável:
+ Teste sua função usando o ARN qualificado (versão ou alias)
+ Monitore o progresso da execução no console do Lambda, na guia Execuções duráveis
+ Visualize as operações de ponto de verificação em eventos de dados do AWS CloudTrail
+ Analise o CloudWatch Logs para analisar a saída da função e o comportamento de reprodução
Para obter mais informações sobre como implantar funções do Lambda com ferramentas de IaC, consulte:
+ [CloudFormation Referência de AWS::Lambda::Function do](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentação do módulo Lambda do](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Guia do desenvolvedor do](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)