# Implementación de funciones duraderas de Lambda con la infraestructura como código
<a name="durable-getting-started-iac"></a>

Puede implementar funciones duraderas de Lambda mediante herramientas de Infraestructura como código (IaC) como AWS CloudFormation, AWS CDK, AWS Serverless Application Model o Terraform. Estas herramientas le permiten definir la función, el rol de ejecución y los permisos en el código, lo que permite que las implementaciones sean repetibles y estén controladas por versiones.

Las tres herramientas requieren que haga lo siguiente:
+ Permita una ejecución duradera de la función.
+ Conceda permiso para pasar el rol de ejecución.
+ Publique una versión o cree un alias (las funciones duraderas requieren ARN calificados).

## Funciones duraderas desde un archivo ZIP
<a name="durable-iac-zip"></a>

### AWS CloudFormation
<a name="durable-iac-cloudformation"></a>

Utilice CloudFormation para definir la función duradera en una plantilla. En el siguiente ejemplo, se crea una función duradera con los permisos necesarios.

```
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 implementar la plantilla**

```
aws cloudformation deploy \
  --template-file template.yaml \
  --stack-name my-durable-function-stack \
  --capabilities CAPABILITY_IAM
```

### AWS CDK
<a name="durable-iac-cdk"></a>

AWS CDK permite definir la infraestructura mediante lenguajes de programación. En los siguientes ejemplos, se muestra cómo crear una función duradera con TypeScript y 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'
        )
```

------

**Cómo implementar la pila de CDK**

```
cdk deploy
```

### AWS Serverless Application Model
<a name="durable-iac-sam"></a>

AWS SAM simplifica las plantillas de CloudFormation para aplicaciones sin servidor. La siguiente plantilla crea una función duradera 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
```

**Cómo implementar la plantilla de SAM**

```
sam build
sam deploy --guided
```

### Terraform
<a name="durable-iac-terraform"></a>

Terraform es una popular herramienta de IaC de código abierto que admite recursos de AWS. En el siguiente ejemplo, se crea una función duradera con Terraform mediante la versión 6.25.0 o posterior del proveedor de 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
}
```

**Cómo implementar con Terraform**

```
terraform init
terraform plan
terraform apply
```

**nota**  
El soporte de Terraform para las funciones duraderas de Lambda requiere la versión 6.25.0 o posterior del proveedor de AWS. Actualice la versión de su proveedor si está usando una versión antigua.

## Funciones duraderas desde una imagen de contenedor OCI
<a name="durable-iac-oci"></a>

También puede crear funciones duraderas a partir de imágenes de contenedor. Para obtener instrucciones sobre cómo crear una imagen de contenedor, consulte [Tiempos de ejecución compatibles para funciones duraderas.](durable-supported-runtimes.md)

### AWS CDK
<a name="durable-iac-oci-cdk"></a>

AWS CDK permite definir la infraestructura mediante lenguajes de programación. En los siguientes ejemplos, se muestra cómo crear una función duradera con TypeScript a partir de una imagen de contenedor.

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

**Cómo implementar la pila de CDK**

```
cdk deploy
```

### AWS Serverless Application Model
<a name="durable-iac-oci-sam"></a>

AWS SAM simplifica las plantillas de CloudFormation para aplicaciones sin servidor. La siguiente plantilla crea una función duradera 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
```

**Cómo implementar la plantilla de SAM**

```
sam build
sam deploy --guided
```

## Patrones de configuración frecuentes
<a name="durable-iac-common-patterns"></a>

Independientemente de la herramienta de IaC que utilice, siga estos patrones para ejecutar funciones duraderas:

**Habilitación de la ejecución duradera**  
Defina la propiedad `DurableConfig` en la función para habilitar una ejecución duradera. Esta propiedad solo está disponible cuando se crea la función. No puede habilitar la ejecución duradera en las funciones existentes.

**Concesión de permisos de puntos de control**  
Adjunte la política administrada de `AWSLambdaBasicDurableExecutionRolePolicy` a su rol de ejecución. Esta política incluye los permisos `lambda:CheckpointDurableExecution` y `lambda:GetDurableExecutionState` necesarios.

**Uso de ARN calificados**  
Cree una versión o un alias para la función. Las funciones duraderas requieren ARN calificados (con versión o alias) para su invocación. Utilice `AutoPublishAlias` en AWS SAM o cree versiones explícitas en CloudFormation, AWS CDK y Terraform.

**Dependencias del paquete**  
Incluya el SDK de ejecución duradera en su paquete de implementación. En el caso de Node.js, instale `@aws/durable-execution-sdk-js`. En el caso de Python, instale `aws-durable-execution-sdk-python`.

## Siguientes pasos
<a name="durable-iac-next-steps"></a>

Tras implementar la función duradera:
+ Pruebe su función con el ARN calificado (versión o alias).
+ Supervise el progreso de la ejecución en la consola de Lambda en la pestaña Ejecuciones duraderas.
+ Vea las operaciones de los puntos de control en los eventos de datos de AWS CloudTrail.
+ Revise Registros de CloudWatch para ver el rendimiento de las funciones y el comportamiento de reproducción.

Para obtener más información acerca de cómo implementar funciones de Lambda con herramientas de IaC, consulte:
+ [CloudFormation Referencia de AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentación del módulo de Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Guía para desarrolladores de](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)