# 创建 Lambda 持久性函数
要开始使用 Lambda 持久性函数，请使用 Lambda 控制台创建持久性函数。您可以在几分钟内创建并部署一个持久性函数，该函数使用步骤和等待来演示基于检查点的执行。
在您执行教程的过程中，您将学习一些基本的持久性函数概念，例如如何使用 `DurableContext` 对象、如何通过步骤创建检查点以及如何使用等待功能来暂停执行。您还将了解到在您的函数在等待结束后恢复时，重放机制是如何运作的。
为了简单起见，本教程将向您展示如何使用 Python 或 Node.js 运行时创建函数。您可以使用这些解释性语言，在控制台的内置代码编辑器中直接编辑函数代码。
Java（预览）中的持久性函数目前只能通过容器映像部署。有关通过容器映像创建持久性函数的更多信息，请参阅[持久性函数支持的运行时](durable-supported-runtimes.md)或[使用基础设施即代码部署 Lambda 持久性函数](durable-getting-started-iac.md)。
**注意**
持久性函数目前支持 Python 和 Node.js（JavaScript/TypeScript）运行时和容器映像（OCI），如 Java。有关支持的运行时版本和容器映像选项的完整列表，请参阅[持久性函数支持的运行时](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 Identity Center并创建一个管理用户，以避免使用根用户执行日常任务。
**保护您的 AWS 账户根用户**
1. 选择**根用户**并输入您的 AWS 账户 电子邮件地址，以账户拥有者身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。
要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](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 Identity Center。
有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。
1. 在 IAM Identity Center 中，为用户授予管理访问权限。
有关如何使用 IAM Identity Center 目录 作为身份源的教程，请参阅**《AWS IAM Identity Center 用户指南》中的 [Configure user access with the default。IAM Identity Center 目录](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)
**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。
要获取使用 IAM Identity Center 用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in to the AWS access portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。
**将访问权限分配给其他用户**
1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。
有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。
1. 将用户分配到一个组，然后为该组分配单点登录访问权限。
有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。
## 使用控制台创建 Lambda 持久性函数
在此示例中，您的持久性函数通过多个步骤处理订单，并具有自动检查点机制。该函数采用包含订单 ID 的 JSON 对象，对其进行验证，处理付款，然后确认订单。每个步骤都会自动进行检查点操作，因此如果函数被中断，它会从最后完成的步骤处恢复执行。
您的函数还演示了一个等待操作，它会暂停执行一小段时间，以此来模拟等待外部确认的过程。
**要使用控制台创建持久性函数**
1. 打开 Lamba 控制台的 [Functions page](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 运行时包括持久执行 SDK，因此您无需打包依赖项即可测试持久性函数。但是，我们建议将 SDK 包含在您的生产部署包中。这样可以确保版本一致性，并且可以避免可能影响函数的潜在运行时更新。
使用控制台的内置代码编辑器添加您的持久性函数代码。
------
#### [ Node.js ]
**在控制台中修改代码**
1. 选择**节点**选项卡。
在控制台的内置代码编辑器中，会显示 Lambda 创建的函数代码。如果代码编辑器中没有显示 **index.mjs** 选项卡，请在文件资源管理器中选择 **index.mjs**，如下图所示。
![\[\]](http://docs.aws.amazon.com/zh_cn/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. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**了解持久性函数代码**
在继续执行下一步之前，我们来查看一下函数代码并了解一些关键的持久性函数概念。
+ `withDurableExecution` 封装器：
您的持久性函数使用 `withDurableExecution` 进行封装。此封装器通过提供 `DurableContext` 对象和管理检查点操作来实现持久执行。
+ `DurableContext` 对象：
您的函数会接收 `DurableContext` 而不是标准的 Lambda 上下文。此对象提供了用于执行诸如 `step()` 和 `wait()` 等持久操作的方法，这些操作会创建检查点。
+ 步骤和检查点：
每次 `context.step()` 调用都会在执行前后创建一个检查点。如果您的函数被中断，它将从上次完成的检查点恢复。该函数不会重新执行已完成的步骤。它会改用它们存储的结果。
+ 等待操作：
`context.wait()` 调用将暂停执行，但不会消耗计算资源。当等待完成时，Lambda 会再次调用您的函数并重放检查点日志，从而用存储的值替代已完成的步骤。
+ 重放机制：
当您的函数在等待或中断后恢复时，Lambda 会从头开始运行您的代码。但是，已完成的步骤不会重新执行。Lambda 会从检查点日志中重放其结果。这就是为什么您的代码必须是确定性的。
------
#### [ Python ]
**在控制台中修改代码**
1. 选择**节点**选项卡。
在控制台的内置代码编辑器中，会显示 Lambda 创建的函数代码。如果代码编辑器中没有显示 **lambda\$1function.py** 选项卡，请在文件资源管理器中选择 **lambda\$1function.py**，如下图所示。
![\[\]](http://docs.aws.amazon.com/zh_cn/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. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**了解持久性函数代码**
在继续执行下一步之前，我们来查看一下函数代码并了解一些关键的持久性函数概念。
+ `@durable_execution` 修饰器：
您的处理函数使用 `@durable_execution` 进行修饰。此修饰器通过提供 `DurableContext` 对象和管理检查点操作来实现持久执行。
+ `@durable_step` 修饰器：
每个步骤函数都使用 `@durable_step` 进行修饰。此修饰器将该函数标记为创建检查点的持久步骤。
+ `DurableContext` 对象：
您的函数会接收 `DurableContext` 而不是标准的 Lambda 上下文。此对象提供了用于执行诸如 `step()` 和 `wait()` 等持久操作的方法，这些操作会创建检查点。
+ 步骤和检查点：
每次 `context.step()` 调用都会在执行前后创建一个检查点。如果您的函数被中断，它将从上次完成的检查点恢复。该函数不会重新执行已完成的步骤。它会改用它们存储的结果。
+ 等待操作：
`context.wait()` 调用将暂停执行，但不会消耗计算资源。当等待完成时，Lambda 会再次调用您的函数并重放检查点日志，从而用存储的值替代已完成的步骤。
+ Python SDK 是同步的：
请注意，Python SDK 不使用 `await`。所有持久操作都是同步方法调用。
------
## 使用控制台代码编辑器调用持久性函数
如果未指定（或发布）显式版本，则控制台使用 `$LATEST` 版本限定符调用持久性函数。但是，为了确定性地执行代码，必须始终使用指向稳定版本的限定 ARN。
**要发布您的函数的版本**
1. 选择**版本**选项卡。
1. 选择 **새 버전 발행**。
1. 在**版本描述**中，输入 **Initial version**（可选）。
1. 选择**发布**。
1. Lambda 会创建您的函数的版本 1。请注意，函数 ARN 现在在末尾包含 `:1`，表示这是版本 1。
现在，创建一个测试事件以发送到您的函数。该事件是一个 JSON 格式的文档，其中包含订单 ID。
**创建测试事件**
1. 在控制台代码编辑器的**测试事件**部分中，选择**创建测试事件**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. 对于**事件名称**，输入 **myTestEvent**。
1. 在**事件 JSON** 部分中，使用以下内容替换默认 JSON：
```
{
"orderId": "order-12345"
}
```
1. 选择**保存**。
**要测试您的持久性函数并查看执行情况**
在控制台代码编辑器的**测试事件**部分中，选择测试事件旁边的运行图标：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
您的持久性函数开始执行。因为该函数包含一段10秒的等待时间，所以初始调用会快速完成，函数将在等待期结束后恢复执行。您可以在**持久执行**选项卡中查看执行进度。
**要查看您的持久性函数执行情况**
1. 选择**持久执行**选项卡。
1. 在列表中找到执行。执行将显示当前状态（正在运行、成功或失败）。
1. 选择执行 ID 以查看详细信息，其中包括：
+ 显示每个步骤完成时间的执行时间表
+ 检查点历史记录
+ 等待期
+ 步骤结果
您还可以在 CloudWatch Logs 中查看函数的日志，以查看每个步骤的控制台输出。
**在 CloudWatch Logs 中查看函数的调用记录**
1. 打开 CloudWatch 控制台的 [Log groups page](https://console.aws.amazon.com/cloudwatch/home#logs:)（日志组页面）。
1. 选择函数 (`/aws/lambda/myDurableFunction`) 的日志组。
1. 向下滚动，选择要查看的函数调用的**日志流**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/log-stream.png)
您应该能看到每次调用该函数时产生的日志条目，包括首次执行时的记录以及等待结束后进行的重放记录。
**注意**
当您使用 `DurableContext` 中的记录器（如 `context.logger` 或 `stepContext.logger`）时，日志还会显示在 Lambda 控制台的持久执行和步骤视图中。这些日志可能需要一些时间才能加载。
## 清理
使用完示例持久性函数后，请将其删除。您还可以删除存储函数日志的日志组以及控制台创建的[执行角色](lambda-intro-execution-role.md)。
**删除 Lambda 函数**
1. 打开 Lamba 控制台的 [Functions（函数）页面](https://console.aws.amazon.com/lambda/home#/functions)。
1. 选择您创建的函数。
1. 依次选择**操作**和**删除**。
1. 在文本输入字段中键入 **confirm**，然后选择**删除**。
**删除日志组**
1. 打开 CloudWatch 控制台的 [Log groups page](https://console.aws.amazon.com/cloudwatch/home#logs:)（日志组页面）。
1. 选择函数的日志组 (`/aws/lambda/myDurableFunction`)。
1. 依次选择 **Actions**（操作）和 **Delete log group(s)**（删除日志组）。
1. 在 **Delete log group(s)**（删除日志组）对话框中，选择 **Delete**（删除）。
**删除执行角色**
1. 打开 AWS Identity and Access Management (IAM) 控制台的 [Roles page](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 执行角色。
## 创建执行角色
创建一个 IAM 角色，赋予其执行基本 Lambda 任务和进行检查点操作的权限。
**创建执行角色**
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（版本或别名）调用您的持久性函数。
**注意**
**幂等调用：**为防止在重试失败的调用时重复执行，您可以提供一个执行名称来确保最多一次执行语义。有关详细信息，请参阅[幂等性](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 Logs 中查看您的持久性函数日志：
```
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 警报
+ 使用 shell 脚本或 CI/CD 管道自动部署
有关 Lambda 的 AWS CLI 命令的更多信息，请参阅 [AWS CLI 命令参考](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html)。
# 使用基础设施即代码部署 Lambda 持久性函数
您可以使用基础设施即代码（IaC）工具（例如 AWS CloudFormation、AWS CDK、AWS Serverless Application Model 或 Terraform）部署 Lambda 持久性函数。这些工具允许您通过代码来定义函数、执行角色以及权限，从而使得部署过程可重复且能够进行版本控制。
这三种工具都要求您：
+ 对函数启用持久执行
+ 授予对执行角色的检查点权限
+ 发布版本或创建别名（持久性函数需要限定的 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
```
**注意**
Terraform 对 Lambda 持久性函数的支持需要 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 参考](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)