# Lambda の耐久性のある関数を作成する
Lambda の耐久性のある関数の使用を開始するには、Lambda コンソールを使用して耐久性のある関数を作成します。数分で、ステップを使用してチェックポイントベースの実行のデモンストレーションを待機する耐久性のある関数を作成してデプロイできます。
チュートリアルを実行すると、`DurableContext` オブジェクトの使用方法、ステップを含むチェックポイントの作成、待機で実行の一時停止など、基礎的な耐久性のある関数の概念について学習します。待機後に関数が再開されると、再生が機能する方法についても説明します。
分かりやすくするため、関数の作成には Python または Node.js ランタイムを使用します。これらはインタープリター言語なので、コンソールの組み込みコードエディタで関数のコードを直接編集できます。
Java 版の耐久性のある関数は現在プレビュー中のため、デプロイにはコンテナイメージを使用する必要があります。コンテナイメージから耐久性のある関数を作成する方法の詳細については、「[耐久関数のサポートされているランタイム](durable-supported-runtimes.md)」または「[コードとしてのインフレストラクチャを使用して Lambda の耐久性のある関数をデプロイする](durable-getting-started-iac.md)」を参照してください。
**注記**
耐久性のある関数は現在、Python および Node.js (JavaScript/TypeScript) ランタイムと、Java などのコンテナイメージ (OCI) をサポートしています。サポートされているランタイムバージョンとコンテナイメージオプションの詳細なリストについては、「[耐久関数のサポートされているランタイム](durable-supported-runtimes.md)」を参照してください。Lambda によるコンテナイメージの使用に関する詳細については、「Lambda デベロッパーガイド」の「[コンテナイメージを使用した Lambda 関数の作成](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html)」を参照してください。
**ヒント**
**サーバーレスソリューション**を構築する方法については、「[サーバーレスデベロッパーガイド](https://docs.aws.amazon.com/serverless/latest/devguide/)」を参照してください。
## 前提条件
### AWS アカウント にサインアップする
AWS アカウント がない場合は、以下のステップを実行して作成します。
**AWS アカウント にサインアップするには**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
AWS アカウントにサインアップすると、*AWS アカウントのルートユーザー*が作成されます。ルートユーザーには、アカウントのすべての AWS のサービス とリソースへのアクセス権があります。セキュリティのベストプラクティスとして、ユーザーに管理アクセスを割り当て、ルートユーザーのみを使用して[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)を実行してください。
サインアップ処理が完了すると、AWS からユーザーに確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。
### 管理アクセスを持つユーザーを作成する
AWS アカウントにサインアップしたら、AWS アカウントのルートユーザーをセキュリティで保護し、AWS IAM アイデンティティセンター を有効にして、管理ユーザーを作成します。これにより、日常的なタスクにルートユーザーを使用しないようにします。
**AWS アカウントのルートユーザー をセキュリティで保護する**
1. **[ルートユーザー]** を選択し、AWS アカウント のメールアドレスを入力して、アカウント所有者として [AWS マネジメントコンソール](https://console.aws.amazon.com/) にサインインします。次のページでパスワードを入力します。
ルートユーザーを使用してサインインする方法については、「*AWS サインイン ユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。
1. ルートユーザーの多要素認証 (MFA) を有効にします。
手順については、「*IAM ユーザーガイド*」の「[AWS アカウント ルートユーザーの仮想 MFA デバイスを有効にする (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)」を参照してください。
**管理アクセスを持つユーザーを作成する**
1. IAM アイデンティティセンターを有効にします。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[AWS IAM アイデンティティセンター の有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。
1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。
IAM アイデンティティセンターディレクトリ をアイデンティティソースとして使用するチュートリアルについては、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[デフォルトの IAM アイデンティティセンターディレクトリ を使用してユーザーアクセスを設定する](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。
**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。
IAM アイデンティティセンターユーザーを使用してサインインする方法については、「*AWS サインイン ユーザーガイド*」の「[AWS アクセスポータルにサインインする](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)」を参照してください。
**追加のユーザーにアクセス権を割り当てる**
1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。
1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[グループを追加する](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。
## コンソールで Lambda の耐久性のある関数を作成します
この例では、耐久性のある関数は自動チェックポイントを使用して、複数のステップで注文を処理します。関数によって注文 ID を含む JSON オブジェクトを受け取り、注文が検証され、支払いが処理され、注文が確認されます。各ステップは自動的にチェックポイントされるため、関数が中断された場合、最後に完了したステップから再開されます。
関数では待機オペレーションも示され、外部確認の待機をシミュレーションするため、実行が短時間一時停止されます。
**コンソールで耐久性のある関数を作成する方法**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. **[一から作成]** を選択します。
1. **[基本情報]** ペインで、**[関数名]** に「`myDurableFunction`」を入力します。
1. **[ランタイム]** で、**[Node.js 24]** または **[Python 3.14]** のいずれかを選択します。
1. **[耐久性のある実行の有効化]** を選択します。
Lambda によってチェックポイントオペレーション (`lambda:CheckpointDurableExecutions` および `lambda:GetDurableExecutionState`) のアクセス許可を含む[実行ロール](lambda-intro-execution-role.md)が使用され、耐久性のある関数が作成されます。
**注記**
Lambda ランタイムには Durable Execution SDK が含まれているため、依存関係をパッケージ化せず、耐久性のある関数をテストできます。ただし、本番稼働用のデプロイパッケージに SDK を含めることをお勧めします。バージョン整合性が確保され、関数に影響を与える可能性があるランタイム更新を回避できます。
コンソールの組み込み Code Editor を使用して、耐久性のある関数コードを追加します。
------
#### [ Node.js ]
**コンソールでコードを変更するには**
1. **[コード]** タブを選択します。
Lambda が関数コードを作成すると、それがコンソールの組み込みコードエディタに表示されます。コードエディターに **index.mjs** タブが表示されない場合は、次の図に示すように、ファイルエクスプローラーで **index.mjs** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/durable-nodejs.png)
1. 次のコードを **index.mjs** タブに貼り付け、Lambda が作成したコードを置き換えます。
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event, context) => {
const orderId = event.orderId;
// Step 1: Validate order
const validationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Validating order ${orderId}`);
return { orderId, status: "validated" };
});
// Step 2: Process payment
const paymentResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Processing payment for order ${orderId}`);
return { orderId, status: "paid", amount: 99.99 };
});
// Wait for 10 seconds to simulate external confirmation
await context.wait({ seconds: 10 });
// Step 3: Confirm order
const confirmationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Confirming order ${orderId}`);
return { orderId, status: "confirmed" };
});
return {
orderId: orderId,
status: "completed",
steps: [validationResult, paymentResult, confirmationResult]
};
}
);
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**耐久性のある関数コードの概要**
次のステップに進む前に、関数コードについて紹介し、耐久性のある関数の主な概念について説明します。
+ `withDurableExecution` ラッパー
耐久性のある関数は `withDurableExecution` でラップされます。このラッパーによって `DurableContext` オブジェクトが提供され、チェックポイントオペレーションが管理されることで、耐久性のある実行が実現されます。
+ `DurableContext` オブジェクト
標準の Lambda コンテキストではなく、関数は `DurableContext` を受け取ります。このオブジェクトは、チェックポイントを作成する `step()` や `wait()` などの耐久性のあるオペレーションの方法について説明します。
+ ステップとチェックポイント
各 `context.step()` の呼び出しは、実行前と実行後にチェックポイントを作成します。関数が中断された場合、最後に完了したチェックポイントから再開されます。関数は完了したステップを再実行しません。代わりに、保存された結果を使用します。
+ 待機オペレーション
`context.wait()` 呼び出しにより、コンピューティングリソースが消費されずに実行が一時停止されます。待機が完了すると、Lambda によって関数が再度呼び出されてチェックポイントログが再生され、保存された値が完了したステップに置き換えられます。
+ 再生メカニズム
待機または中断後に関数が再開されると、Lambda によって最初からコードが実行されます。ただし、完了したステップは再実行されません。Lambda によってチェックポイントログの結果が再生されます。そのため、コードは決定的である必要があります。
------
#### [ Python ]
**コンソールでコードを変更するには**
1. **[コード]** タブを選択します。
Lambda が関数コードを作成すると、それがコンソールの組み込みコードエディタに表示されます。コードエディターに **lambda\$1function.py** タブが表示されない場合は、次の図に示すように、ファイルエクスプローラーで **lambda\$1function.py** 選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/durable-python.png)
1. 次のコードを **lambda\$1function.py** タブに貼り付け、Lambda が作成したコードを置き換えます。
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
from aws_durable_execution_sdk_python.config import Duration
@durable_step
def validate_order(step_context, order_id):
step_context.logger.info(f"Validating order {order_id}")
return {"orderId": order_id, "status": "validated"}
@durable_step
def process_payment(step_context, order_id):
step_context.logger.info(f"Processing payment for order {order_id}")
return {"orderId": order_id, "status": "paid", "amount": 99.99}
@durable_step
def confirm_order(step_context, order_id):
step_context.logger.info(f"Confirming order {order_id}")
return {"orderId": order_id, "status": "confirmed"}
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
# Step 1: Validate order
validation_result = context.step(validate_order(order_id))
# Step 2: Process payment
payment_result = context.step(process_payment(order_id))
# Wait for 10 seconds to simulate external confirmation
context.wait(Duration.from_seconds(10))
# Step 3: Confirm order
confirmation_result = context.step(confirm_order(order_id))
return {
"orderId": order_id,
"status": "completed",
"steps": [validation_result, payment_result, confirmation_result]
}
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**耐久性のある関数コードの概要**
次のステップに進む前に、関数コードについて紹介し、耐久性のある関数の主な概念について説明します。
+ `@durable_execution` デコレータ
ハンドラー関数は `@durable_execution` でデコレーションされています。このデコレータによって `DurableContext` オブジェクトが提供されてチェックポイントオペレーションが管理されることで、耐久性のある実行が実現されます。
+ `@durable_step` デコレータ
各ステップ関数は `@durable_step` でデコレーションされています。このデコレータにより、チェックポイントを作成する耐久性のあるステップとして関数がマークされます。
+ `DurableContext` オブジェクト
標準の Lambda コンテキストではなく、関数は `DurableContext` を受け取ります。このオブジェクトは、チェックポイントを作成する `step()` や `wait()` などの耐久性のあるオペレーションの方法について説明します。
+ ステップとチェックポイント
各 `context.step()` の呼び出しは、実行前と実行後にチェックポイントを作成します。関数が中断された場合、最後に完了したチェックポイントから再開されます。関数は完了したステップを再実行しません。代わりに、保存された結果を使用します。
+ 待機オペレーション
`context.wait()` 呼び出しにより、コンピューティングリソースが消費されずに実行が一時停止されます。待機が完了すると、Lambda によって関数が再度呼び出されてチェックポイントログが再生され、保存された値が完了したステップに置き換えられます。
+ Python SDK は同期します。
Python SDK では、`await` が使用されないことに注意してください。耐久性のあるオペレーションは、すべて同期メソッドの呼び出しです。
------
## コンソールの Code Editor を使用して耐久性のある関数を呼び出す
明示的なバージョンが指定されていない (または公開されていない) 場合、コンソールは `$LATEST` バージョン修飾子を使用して耐久性のある関数を呼び出します。ただし、コードの確定的な実行には、常に安定したバージョンを指す修飾 ARN を使用する必要があります。
**関数のバージョンを発行する方法**
1. **[バージョニング]** タブを選択します。
1. **[新しいバージョンを発行]** を選択します。
1. **[バージョンの説明]** には、「**Initial version**」と入力します (オプション)。
1. **[公開]** を選択します。
1. Lambda によって関数のバージョン 1 が作成されます。関数 ARN の末尾に `:1` が含まれるようになり、バージョン 1 であることが示されていることに注意してください。
次に、関数に送信するテストイベントを作成します。イベントは、注文 ID を含む JSON 形式のドキュメントです。
**テストイベントを作成するには**
1. コンソールコードエディタの **[TEST EVENTS]** セクションで、**[テストイベントを作成]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. **[イベント名]** で、「**myTestEvent**」と入力します。
1. **[Event JSON]** セクションで、デフォルトの JSON を次のように置き換えます。
```
{
"orderId": "order-12345"
}
```
1. **[保存]** を選択します。
**耐久性のある関数をテストして実行を表示する方法**
コンソールコードエディタの **[TEST EVENTS]** セクションで、テストイベントの横にある実行アイコンを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
耐久性のある関数の実行が開始されます。10 秒の待機が含まれるため、最初の呼び出しはすぐに完了します。関数は待機期間後に再開されます。実行の進行状況は、**[耐久性のある実行]** タブで確認できます。
**耐久性のある関数の実行を表示する方法**
1. **[耐久性のある実行]** タブを選択します。
1. リストで実行を検索します。実行には現在のステータス (実行中、成功、失敗) が表示されます。
1. 実行 ID を選択して詳細を確認します。以下の情報が含まれます。
+ 各ステップが完了した日時が示される実行タイムライン
+ チェックポイント履歴
+ 待機期間
+ ステップの結果
CloudWatch Logs で関数のログを表示し、各ステップのコンソール出力を確認することもできます。
**CloudWatch Logs で関数の呼び出しレコードを表示するには**
1. Amazon CloudWatch コンソールの [[[Log groups (ロググループ)] ページ](https://console.aws.amazon.com/cloudwatch/home#logs:)] を開きます。
1. 関数のロググループの名前を選択します (`/aws/lambda/myDurableFunction`) 。
1. 下にスクロールし、表示したい関数呼び出しの**ログストリーム**を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/log-stream.png)
関数の呼び出しごとにログエントリ (最初の実行および待機後の再生を含む) を確認してください。
**注記**
`DurableContext` (`context.logger` や `stepContext.logger` など) からロガーを使用すると、Lambda コンソールの耐久性のある実行ビューとステップビューにもログが表示されます。これらのログのロードには時間がかかる場合があります。
## クリーンアップ
耐久性のある関数のサンプルで作業が完了したら、削除します。また、関数のログを保存するロググループと、コンソールが作成した[実行ロール](lambda-intro-execution-role.md)も削除できます。
**Lambda 関数を削除するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 作成した関数を選択します。
1. **[アクション]** で、**[削除]** を選択します。
1. テキスト入力フィールドに **confirm** と入力し、**[削除]** を選択します。
**ロググループを削除するには**
1. Amazon CloudWatch コンソールの [[Log groups (ロググループ)] ページ](https://console.aws.amazon.com/cloudwatch/home#logs:)を開きます。
1. 関数のロググループ (`/aws/lambda/myDurableFunction`) を選択します。
1. [**アクション**]、[**ロググループの削除**] の順にクリックします。
1. **ロググループの削除**ダイアログボックスで、[**削除**] をクリックします。
**実行ロールを削除するには**
1. AWS Identity and Access Management (IAM) コンソールの [[Roles (ロール)] ページ](https://console.aws.amazon.com/iam/home?#/roles)を開きます。
1. 関数の実行ロールを選択します (`myDurableFunction-role-31exxmpl` など)。
1. **[削除]** を選択します。
1. **[ロールを削除]** ダイアログボックスにロール名を入力し、**[削除]** を選択します。
## その他のリソースと次のステップ
コンソールを使用してシンプルな耐久性のある関数を作成してテストを行ったら、次の各ステップを実行してください。
+ 分散トランザクション、注文処理、人間によるレビューワークフローなど、耐久性のある関数の一般的なユースケースについて説明します。「[例](durable-examples.md)」を参照してください。
+ CloudWatch メトリクスおよび実行履歴を使用し、耐久性のある関数の実行をモニタリングする方法について説明します。「[モニタリングとデバッグ](durable-monitoring.md)」を参照してください。
+ 耐久性のある関数を同期的および非同期的に呼び出し、長時間の実行を管理する方法について説明します。「[耐久性のある関数の呼び出し](durable-invoking.md)」を参照してください。
+ 決定的コードの記述、チェックポイントサイズの管理、コストの最適化に関するベストプラクティスに従います。「[ベストプラクティス](durable-best-practices.md)」を参照してください。
+ 耐久性のある関数をローカルやクラウドでテストする方法について説明します。「[耐久性のある関数のテスト](durable-testing.md)」を参照してください。
+ 耐久性のある関数と Step Functions を比較して、各アプローチがどのような場合に最も効果的かを明らかにします。「[耐久性のある関数か Step Functions か](durable-step-functions.md)」を参照してください。
# AWS CLI を使用して Lambda の耐久性のある関数をデプロイして呼び出す
AWS CLI を使用して、命令コマンドで Lambda の耐久性のある関数を作成してデプロイします。このアプローチにより、デプロイプロセスの各ステップを直接制御できます。
## 前提条件
+ AWS CLI をインストールして設定します。手順については、「[AWS CLI のインストール](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)」を参照してください。
+ 関数コードおよび耐久性のある実行 SDK でデプロイパッケージを作成します。
+ チェックポイントのアクセス許可で IAM 実行ロールを作成します。
## 実行ロールを作成する
基本的な Lambda 実行およびチェックポイントオペレーションのアクセス許可を持つ IAM ロールを作成します。
**実行ロールを作成するには**
1. Lambda のロール引き受けを許可する信頼ポリシードキュメントを作成します。`trust-policy.json` として保存します。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. ロールを作成します。
```
aws iam create-role \
--role-name durable-function-role \
--assume-role-policy-document file://trust-policy.json
```
1. チェックポイントオペレーションと基本実行の耐久性のある実行ポリシーをアタッチします。
```
aws iam attach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
```
`AWSLambdaBasicDurableExecutionRolePolicy` 管理ポリシーには、チェックポイントオペレーション (`lambda:CheckpointDurableExecutions` および `lambda:GetDurableExecutionState`) と基本的な Lambda 実行に必要なアクセス許可が含まれています。
## 耐久性のある関数の作成します
`--durable-config` パラメータで耐久性のある関数を作成します。
**耐久性のある関数を作成する方法**
1. 依存関係を持つ関数コードを .zip ファイルにパッケージ化します。
```
zip -r function.zip index.mjs node_modules/
```
1. 耐久性のある実行を有効にして関数を作成します。
```
aws lambda create-function \
--function-name myDurableFunction \
--runtime nodejs22.x \
--role arn:aws:iam::123456789012:role/durable-function-role \
--handler index.handler \
--zip-file fileb://function.zip \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
**注記**
関数の作成時のみに、耐久性のある実行を有効にできます。既存の関数には有効にできません。
**注記**
現在、Java (プレビュー) の耐久性のある関数は、コンテナイメージを介してのみ作成できます。コンテナイメージから耐久性のある関数を作成する方法の詳細については、「[耐久関数のサポートされているランタイム](durable-supported-runtimes.md)」を参照してください。
## バージョンの発行
耐久性のある関数は `$LATEST` バージョン修飾子を使用して呼び出すことができますが、コードの確定的な実行を確保するためには、常に安定したバージョンを指す修飾 ARN を使用する必要があります。
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Initial version"
```
コマンドはバージョン ARN を返します。ARN の末尾にあるバージョン番号 (例えば、`:1`) を書き留めてください。
オプションとして、バージョンを指すエイリアスを作成します。
```
aws lambda create-alias \
--function-name myDurableFunction \
--name prod \
--function-version 1
```
## 耐久性のある関数を呼び出す
修飾 ARN (バージョンまたはエイリアス) を使用して、耐久性のある関数を呼び出します。
**注記**
**べき等呼び出し:** 失敗した呼び出しを再試行するときに、at-most-once の実行セマンティクスを保証する実行名を指定すると、実行が重複しないようにできます。詳細については、「[べき等性](durable-execution-idempotency.md)」を参照してください。
**同期呼び出し**
15 分以内に完了する実行には、同期呼び出しを使用します。
```
aws lambda invoke \
--function-name myDurableFunction:1 \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
または、エイリアスを使用します。
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
**非同期呼び出し**
長時間の実行には、非同期呼び出しを使用します。
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--invocation-type Event \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
非同期呼び出しを使用すると、Lambda は即時に返します。関数はバックグラウンドで実行を続行します。
**注記**
コンソールでのプロトタイプ作成とテストに `$LATEST` を使用できます。本番稼働ワークロードの場合は、公開されたバージョンまたはエイリアスを使用します。
## 耐久性のある実行を管理する
次のコマンドを使用して、耐久性のある関数の実行を管理してモニタリングします。
**実行を一覧表示する**
耐久性のある関数におけるすべての実行を一覧表示します。
```
aws lambda list-durable-executions-by-function \
--function-name myDurableFunction
```
**実行の詳細を取得する**
特定の実行に関する詳細を取得します。
```
aws lambda get-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**実行履歴を取得する**
実行のチェックポイント履歴を表示します。
```
aws lambda get-durable-execution-history \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**実行を停止する**
実行中の耐久性のある実行を停止します。
```
aws lambda stop-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
## 関数コードの更新
耐久性のある関数コードを更新し、新しいバージョンを発行します。
**新しいバージョンを更新して公開する方法**
1. 関数コードを更新します。
```
aws lambda update-function-code \
--function-name myDurableFunction \
--zip-file fileb://function.zip
```
1. アップデートが完了するまで待機します。
```
aws lambda wait function-updated \
--function-name myDurableFunction
```
1. 新しいバージョンを発行します。
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Updated order processing logic"
```
1. 新しいバージョンをポイントするようにエイリアスを更新します。
```
aws lambda update-alias \
--function-name myDurableFunction \
--name prod \
--function-version 2
```
**重要**
開始したバージョンを使用して処理中の実行が継続されます。新しい呼び出しには、更新されたエイリアスバージョンが使用されます。
## 関数ログの表示
CloudWatch ログで耐久性のある関数のログを確認します。
```
aws logs tail /aws/lambda/myDurableFunction --follow
```
ログをフィルタリングして特定の実行を確認します。
```
aws logs filter-log-events \
--log-group-name /aws/lambda/myDurableFunction \
--filter-pattern "exec-abc123"
```
## リソースをクリーンアップする
耐久性のある関数および関連付けされたリソースを削除します。
```
# Delete the function
aws lambda delete-function --function-name myDurableFunction
# Delete the IAM role policies
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
# Delete the role
aws iam delete-role --role-name durable-function-role
```
## 次のステップ
AWS CLI を使用して耐久性のある関数をデプロイした後
+ `list-durable-executions` および `get-durable-execution` コマンドを使用して実行をモニタリングする
+ AWS CloudTrail データイベントでチェックポイントオペレーションを表示する
+ 実行失敗または長時間実行の CloudWatch アラームを設定する
+ シェルスクリプトまたは CI/CD パイプラインを使用してデプロイを自動化する
Lambda の AWS CLI コマンドに関する詳細については、「[AWS CLI コマンドリファレンス](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html)」を参照してください。
# コードとしてのインフレストラクチャを使用して Lambda の耐久性のある関数をデプロイする
AWS CloudFormation、AWS CDK、AWS Serverless Application Model、Terraform などの Infrastructure as Code (IaC) ツールを使用して Lambda の耐久性のある関数はデプロイできます。これらのツールを使用するとコードで関数、実行ロール、アクセス許可を定義し、デプロイを反復可能でバージョン管理できます。
3 つのツールはすべて以下の内容が必要です。
+ 関数に耐久性のある実行を有効にする
+ 実行ロールにチェックポイントのアクセス許可を付与する
+ バージョンを発行するか、エイリアスを作成する (耐久性のある関数には修飾 ARN が必要)
## ZIP からの耐久性のある関数
### AWS CloudFormation
CloudFormation を使用して、テンプレートの耐久性のある関数を定義します。次の例では、必要なアクセス許可を持つ耐久性のある関数を作成します。
```
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
```
**テンプレートをデプロイするには**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK では、プログラミング言語を使用してインフラストラクチャを定義できます。次の例では、TypeScript および 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'
)
```
------
**CDK スタックをデプロイする方法**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM は、サーバーレスアプリケーションの CloudFormation テンプレートを簡素化します。次のテンプレートは、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
```
**SAM テンプレートをデプロイする方法**
```
sam build
sam deploy --guided
```
### Terraform
Terraform は、AWS リソースをサポートする一般的なオープンソース IaC ツールです。次の例では、AWS プロバイダーバージョン 6.25.0 以降を使用して Terraform で耐久性のある関数を作成します。
```
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
}
```
**Terraform でデプロイするには**
```
terraform init
terraform plan
terraform apply
```
**注記**
Lambda の耐久性のある関数の Terraform サポートには、AWS プロバイダーバージョン 6.25.0 以降が必要です。古いバージョンを使用している場合は、プロバイダーのバージョンを更新します。
## OCI コンテナイメージからの耐久性のある関数
コンテナイメージに基づいて耐久性のある関数を作成することもできます。コンテナイメージを構築する方法については、「[耐久関数のサポートされているランタイム](durable-supported-runtimes.md)」を参照してください。
### AWS CDK
AWS CDK では、プログラミング言語を使用してインフラストラクチャを定義できます。次の例では、コンテナイメージから 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.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',
});
}
}
```
**CDK スタックをデプロイする方法**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM は、サーバーレスアプリケーションの CloudFormation テンプレートを簡素化します。次のテンプレートは、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
```
**SAM テンプレートをデプロイする方法**
```
sam build
sam deploy --guided
```
## 一般的な設定パターン
どの IaC ツールを使用するかを問わず、耐久性のある関数については次のパターンに従ってください。
**耐久性のある実行を有効にする**
関数に `DurableConfig` プロパティを設定して、耐久性のある実行を有効にします。このプロパティは、関数を作成する場合にのみ使用できます。既存の関数では耐久性のある実行を有効にできません。
**チェックポイントのアクセス許可を付与する**
`AWSLambdaBasicDurableExecutionRolePolicy` 管理ポリシーを実行ロールにアタッチします。このポリシーには、必要な `lambda:CheckpointDurableExecutions` および `lambda:GetDurableExecutionState` アクセス許可が含まれます。
**修飾 ARN を使用する**
関数のバージョンまたはエイリアスを作成します。耐久性のある関数には、呼び出しに修飾 ARN (バージョンまたはエイリアス付) が必要です。AWS SAM で `AutoPublishAlias` を使用するか、CloudFormation、AWS CDK、および Terraform で明示的なバージョンを作成します。
**パッケージの依存関係**
デプロイパッケージに耐久性のある実行 SDK を含めます。Node.js の場合、`@aws/durable-execution-sdk-js` をインストールします。Python の場合、`aws-durable-execution-sdk-python` をインストールします。
## 次のステップ
耐久性のある関数をデプロイした後
+ 修飾 ARN (バージョンまたはエイリアス) を使用して関数をテストする
+ [耐久性のある実行] タブの Lambda コンソールで実行の進行状況をモニタリングする
+ AWS CloudTrail データイベントでチェックポイントオペレーションを表示する
+ CloudWatch Logs を表示して、関数の出力と再生動作を確認する
IaC ツールを使用して Lambda 関数のデプロイの詳細については、以下を参照してください。
+ [CloudFormation AWS::Lambda::Function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Lambda モジュールのドキュメント](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM デベロッパーガイド](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)