# 调用持久性 Lambda 函数
<a name="durable-invoking"></a>

持久性 Lambda 函数支持与标准 Lambda 函数相同的调用方法。您可以通过同步、异步或事件源映射的方式调用持久性函数。调用过程与标准函数相同，但持久性函数为长时间运行的执行和自动状态管理提供了额外的功能。

## 调用方法
<a name="durable-invoking-methods"></a>

**同步调用：**调用持久性函数并等待响应。Lambda 将同步调用限制为 15 分钟（或更短，具体取决于配置的函数和执行超时）。当您需要立即获取结果，或与需要响应的 API 和服务集成时，请使用同步调用。您可以使用等待操作进行高效计算，而不会中断调用方——调用会等待整个持久执行完成。对于幂等执行的启动，请使用[幂等性](durable-execution-idempotency.md)中所述的执行名称参数。

```
aws lambda invoke \
  --function-name my-durable-function:1 \
  --cli-binary-format raw-in-base64-out \
  --payload '{"orderId": "12345"}' \
  response.json
```

**异步调用：**将事件排入队列以进行处理，而不必等待响应。Lambda 将事件置于队列中并立即返回。异步调用最多支持 1 年的执行时间。在需要即发即弃的场景，或当处理过程可以在后台发生时，请使用异步调用。对于幂等执行的启动，请使用[幂等性](durable-execution-idempotency.md)中所述的执行名称参数。

```
aws lambda invoke \
  --function-name my-durable-function:1 \
  --invocation-type Event \
  --cli-binary-format raw-in-base64-out \
  --payload '{"orderId": "12345"}' \
  response.json
```

**事件源映射：**配置 Lambda 以在记录从流或基于队列的服务（如 Amazon SQS、Kinesis 或 DynamoDB）可用时自动调用持久性函数。事件源映射会轮询事件源并使用批量记录调用函数。有关将事件源映射与持久性函数结合使用的详细信息（包括执行持续时间限制），请参阅[结合使用事件源映射与持久性函数](durable-invoking-esm.md)。

有关每种调用方法的完整详细信息，请参阅[同步调用](invocation-sync.md)和[异步调用](invocation-async.md)。

**注意**  
持久性函数支持死信队列（DLQ）用于错误处理，但不支持 Lambda 目标。配置 DLQ 以从失败的调用中捕获记录。

## 限定 ARN 要求
<a name="durable-invoking-qualified-arns"></a>

持久性函数需要使用限定的标识符才能调用。必须使用版本号、别名或 `$LATEST` 来调用持久性函数。您可以使用完全限定的 ARN，也可以使用带有版本/别名后缀的函数名称。不能使用非限定标识符（没有版本或别名后缀）。

**有效调用：**

```
# Using full ARN with version number
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1

# Using full ARN with alias
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:prod

# Using full ARN with $LATEST
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:$LATEST

# Using function name with version number
my-durable-function:1

# Using function name with alias
my-durable-function:prod
```

**无效调用：**

```
# Unqualified ARN (not allowed)
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function

# Unqualified function name (not allowed)
my-durable-function
```

此要求可确保持久执行在其整个生命周期中保持一致。当持久执行启动时，它会固定到特定的函数版本。如果函数暂停并在数小时或数天后恢复，Lambda 将调用开始执行的相同版本，从而确保整个工作流中的代码一致性。

**最佳实践**  
对于生产环境中的持久性函数，请使用编号版本或别名，而非 `$LATEST`。编号版本是不可变的，支持确定性重放。或者，别名提供稳定的引用，您可以更新该引用以指向新版本，而无需更改调用代码。更新别名时，新执行将使用新版本，而正在进行的执行将继续使用其原始版本。在开发过程中，您可以将 `$LATEST` 用于原型设计或缩短部署时间，但需理解，如果在运行中的执行期间底层代码发生更改，则执行可能无法正确重放（甚至可能失败）。

## 了解执行生命周期
<a name="durable-invoking-execution-lifecycle"></a>

当您调用持久性函数时，Lambda 会创建一个可以跨越多个函数调用的持久执行：

1. **初始调用：**您的调用请求会创建新的持久执行。Lambda 分配一个唯一的执行 ID 并开始处理。

1. **执行和检查点：**当您的函数执行持久操作时，SDK 会创建跟踪进度的检查点。

1. **暂停（如果需要）：**如果您的函数使用持久等待（例如 `wait` 或 `waitForCallback`）或自动步骤重试，Lambda 会暂停执行并停止对计算时间计费。

1. **恢复：**需要恢复时（包括重试之后），Lambda 会再次调用您的函数。SDK 会重放检查点日志，并从暂停执行的地方继续执行。

1. **完成：**当您的函数返回最终结果或抛出未处理的错误时，持久执行完成。

对于同步调用，调用方等待整个持久执行完成，包括任何等待操作。如果执行超过调用超时（15 分钟或更短），则调用超时。对于异步调用，Lambda 会立即返回，并独立地继续执行。使用持久执行 API 来跟踪执行状态并检索最终结果。

## 从应用程序代码调用
<a name="durable-invoking-with-sdk"></a>

使用 AWS SDK 从应用程序代码中调用持久性函数。调用过程与标准函数相同：

------
#### [ TypeScript ]

```
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';

const client = new LambdaClient({});

// Synchronous invocation
const response = await client.send(new InvokeCommand({
  FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
  Payload: JSON.stringify({ orderId: '12345' })
}));

const result = JSON.parse(Buffer.from(response.Payload!).toString());

// Asynchronous invocation
await client.send(new InvokeCommand({
  FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
  InvocationType: 'Event',
  Payload: JSON.stringify({ orderId: '12345' })
}));
```

------
#### [ Python ]

```
import boto3
import json

client = boto3.client('lambda')

# Synchronous invocation
response = client.invoke(
    FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
    Payload=json.dumps({'orderId': '12345'})
)

result = json.loads(response['Payload'].read())

# Asynchronous invocation
client.invoke(
    FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
    InvocationType='Event',
    Payload=json.dumps({'orderId': '12345'})
)
```

------

## 链式调用
<a name="durable-invoking-chained"></a>

持久性函数可以使用 `DurableContext` 中的 `invoke` 操作调用其他持久性函数和非持久性函数。这会创建一个链式调用，其中调用函数等待（暂停）被调用函数完成：

------
#### [ TypeScript ]

```
export const handler = withDurableExecution(
  async (event: any, context: DurableContext) => {
    // Invoke another durable function and wait for result
    const result = await context.invoke(
      'process-order',
      'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1',
      { orderId: event.orderId }
    );
    
    return { statusCode: 200, body: JSON.stringify(result) };
  }
);
```

------
#### [ Python ]

```
@durable_execution
def handler(event, context: DurableContext):
    # Invoke another durable function and wait for result
    result = context.invoke(
        'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1',
        {'orderId': event['orderId']},
        name='process-order'
    )
    
    return {'statusCode': 200, 'body': json.dumps(result)}
```

------

链式调用会在调用函数中创建一个检查点。如果调用函数被中断，它将使用被调用函数的结果从检查点恢复，而无需重新调用该函数。

**注意**  
不支持跨账户链式调用。被调用的函数必须与调用函数在同一 AWS 账户中。