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

# Terapkan fungsi tahan lama Lambda dengan Infrastructure as Code
<a name="durable-getting-started-iac"></a>

Anda dapat menerapkan fungsi tahan lama Lambda menggunakan alat Infrastructure as Code (IAc) seperti AWS CloudFormation,, 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 dikendalikan versi.

Ketiga alat mengharuskan Anda untuk:
+ Aktifkan eksekusi tahan lama pada fungsi
+ Berikan izin pos pemeriksaan ke peran eksekusi
+ Publikasikan versi atau buat alias (fungsi tahan lama memerlukan ARN yang memenuhi syarat)

## 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 menciptakan 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 menerapkan 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>

Dengan AWS CDK, Anda dapat mendefinisikan 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 menerapkan 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 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 menerapkan 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 menerapkan dengan Terraform **

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

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

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

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

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

Dengan AWS CDK, Anda dapat mendefinisikan infrastruktur menggunakan bahasa pemrograman. Contoh berikut menunjukkan cara membuat fungsi tahan lama menggunakan TypeScript dari gambar wadah.

```
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 menerapkan 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 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 menerapkan 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 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 ARN yang memenuhi syarat**  
Buat versi atau alias untuk fungsi Anda. Fungsi tahan lama memerlukan ARN yang memenuhi syarat (dengan versi atau alias) untuk pemanggilan. Gunakan `AutoPublishAlias` dalam AWS SAM atau buat versi eksplisit di CloudFormation, AWS CDK, dan Terraform.

**Ketergantungan paket**  
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)
+ Memantau kemajuan eksekusi di konsol Lambda di bawah tab Eksekusi tahan lama
+ Melihat operasi pos pemeriksaan dalam peristiwa AWS CloudTrail data
+ Tinjau CloudWatch Log untuk keluaran fungsi dan perilaku pemutaran ulang

Untuk informasi selengkapnya tentang penerapan fungsi Lambda dengan alat iAc, lihat:
+ [CloudFormation AWS::Lambda: :Referensi fungsi ](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)