Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Terapkan fungsi Lambda yang tahan lama dengan Infrastruktur sebagai Kode
<a name="durable-getting-started-iac"></a>

Anda dapat menerapkan fungsi tahan lama Lambda menggunakan alat Infrastructure as Code (IAc) AWS CloudFormation seperti AWS CDK,, AWS Serverless Application Model, atau Terraform. Alat ini memungkinkan Anda menentukan fungsi, peran eksekusi, dan izin dalam kode, membuat penerapan dapat diulang dan dikontrol versi.

Ketiga alat mengharuskan Anda untuk:
+ Aktifkan eksekusi yang tahan lama pada fungsi
+ Berikan izin pos pemeriksaan untuk peran eksekusi
+ Publikasikan versi atau buat alias (fungsi tahan lama membutuhkan kualifikasi ARNs)

## Fungsi tahan lama dari ZIP
<a name="durable-iac-zip"></a>

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

Gunakan CloudFormation untuk menentukan fungsi tahan lama Anda dalam template. Contoh berikut membuat fungsi tahan lama dengan izin yang diperlukan.

```
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
```

**Untuk menyebarkan template**

```
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 memungkinkan Anda menentukan infrastruktur menggunakan bahasa pemrograman. Contoh berikut menunjukkan cara membuat fungsi tahan lama menggunakan TypeScript dan 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'
        )
```

------

**Untuk menyebarkan tumpukan CDK**

```
cdk deploy
```

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

AWS SAM menyederhanakan CloudFormation template untuk aplikasi tanpa server. Template berikut menciptakan fungsi yang tahan lama dengan 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
```

**Untuk menyebarkan template SAM**

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

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

Terraform adalah alat iAc open-source populer yang mendukung sumber daya. AWS Contoh berikut membuat fungsi tahan lama dengan Terraform menggunakan AWS penyedia versi 6.25.0 atau yang lebih baru.

```
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
}
```

**Untuk menyebarkan dengan Terraform**

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

**catatan**  
Dukungan Terraform untuk fungsi tahan lama Lambda memerlukan versi AWS penyedia 6.25.0 atau yang lebih baru. Perbarui versi penyedia Anda jika Anda menggunakan versi yang lebih lama.

## Fungsi tahan lama dari gambar kontainer OCI
<a name="durable-iac-oci"></a>

Anda juga dapat membuat fungsi Tahan Lama berdasarkan gambar kontainer. Untuk petunjuk tentang cara membuat image container, lihat [Runtime yang didukung untuk fungsi tahan lama](durable-supported-runtimes.md).

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

AWS CDK memungkinkan Anda menentukan infrastruktur menggunakan bahasa pemrograman. Contoh berikut menunjukkan cara membuat fungsi tahan lama menggunakan TypeScript dari gambar kontainer.

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

**Untuk menyebarkan tumpukan CDK**

```
cdk deploy
```

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

AWS SAM menyederhanakan CloudFormation template untuk aplikasi tanpa server. Template berikut menciptakan fungsi yang tahan lama dengan 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
```

**Untuk menyebarkan template SAM**

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

## Pola konfigurasi umum
<a name="durable-iac-common-patterns"></a>

Terlepas dari alat IAc mana yang Anda gunakan, ikuti pola ini untuk fungsi yang tahan lama:

**Aktifkan eksekusi yang tahan lama**  
Atur `DurableConfig` properti pada fungsi Anda untuk mengaktifkan eksekusi yang tahan lama. Properti ini hanya tersedia saat membuat fungsi. Anda tidak dapat mengaktifkan eksekusi tahan lama pada fungsi yang ada.

**Berikan izin pos pemeriksaan**  
Lampirkan kebijakan `AWSLambdaBasicDurableExecutionRolePolicy` terkelola ke peran eksekusi. Kebijakan ini mencakup persyaratan `lambda:CheckpointDurableExecution` dan `lambda:GetDurableExecutionState` izin.

**Gunakan yang memenuhi syarat ARNs**  
Buat versi atau alias untuk fungsi Anda. Fungsi tahan lama membutuhkan kualifikasi ARNs (dengan versi atau alias) untuk pemanggilan. Gunakan `AutoPublishAlias` dalam AWS SAM atau buat versi eksplisit di CloudFormation, AWS CDK, dan Terraform.

**Package dependensi**  
Sertakan SDK eksekusi tahan lama dalam paket penerapan Anda. Untuk Node.js, instal`@aws/durable-execution-sdk-js`. Untuk Python, instal. `aws-durable-execution-sdk-python`

## Langkah selanjutnya
<a name="durable-iac-next-steps"></a>

Setelah menerapkan fungsi tahan lama Anda:
+ Uji fungsi Anda menggunakan ARN yang memenuhi syarat (versi atau alias)
+ Pantau kemajuan eksekusi di konsol Lambda di bawah tab Eksekusi tahan lama
+ Lihat operasi pos pemeriksaan dalam peristiwa AWS CloudTrail data
+ Tinjau CloudWatch Log untuk output fungsi dan perilaku pemutaran ulang

Untuk informasi selengkapnya tentang penerapan fungsi Lambda dengan alat IAc, lihat:
+ [CloudFormation AWS::Lambda::Function referensi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Dokumentasi modul Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Panduan Pengembang](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)