

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 为你的 Amazon Lex V2 机器人创建AWS Lambda函数
<a name="lambda-attach"></a>

要为您的 Amazon Lex V2 机器人创建 Lambda 函数，AWS Lambda请从 AWS 管理控制台访问并创建一个新函数。您可以参阅[AWS Lambda开发者指南](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)，了解有关的更多详细信息AWS Lambda。

1. 登录 AWS 管理控制台并在上打开AWS Lambda控制台[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)。

1. 在左侧边栏中选择**函数**。

1. 选择**创建函数**。

1. 您可以选择**从头开始创作**以最少的代码开始，选择**使用蓝图**以从列表中选择常见用例的示例代码，或者选择**容器镜像**为您的函数选择要部署的容器镜像。如果您选择**从头开始创作**，请继续执行以下步骤：

   1. 给您的函数起一个有意义的**函数名称**来描述它的作用。

   1. 从**运行时**下拉菜单中选择一种语言来编写函数。

   1. 为您的函数选择一个指令集**架构**。

   1. 默认情况下，Lambda 创建具有基本权限的新角色。要使用现有角色或使用 AWS 策略模板创建角色，请展开**更改默认执行角色**菜单并选择一个选项。

   1. 展开**高级设置**菜单以配置更多选项。

1. 选择**创建函数**。

从头开始创建新函数时所看到的内容如下图所示。

![\[新的 Lambda 函数。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-new-function.png)


Lambda 处理程序函数因您使用的语言而异。它至少需要一个 `event` JSON 对象作为参数。您可以进入 [AWS LambdaLex V2 的输入事件格式](lambda-input-format.md) 查看 Amazon Lex V2 提供的 `event` 中包含的字段。修改处理程序函数，最终返回与 [AWS LambdaLex V2 的响应格式](lambda-response-format.md) 中所述格式相匹配的 `response` JSON 对象。
+ 编写完函数后，选择**部署**以允许使用该函数。

请记住，您最多可以将每个机器人别名与一个 Lambda 函数相关联。但是，您可以在 Lambda 代码中为机器人定义任意数量的函数，然后在 Lambda 处理程序函数中调用这些函数。例如，虽然同一个机器人别名中的所有意图都必须调用相同的 Lambda 函数，但您可以创建一个路由器函数来为每个意图激活单独的函数。可以为应用程序使用或修改的路由器函数示例如下所示：

```
import os
import json
import boto3

# reuse client connection as global
client = boto3.client('lambda')

def router(event):
    intent_name = event['sessionState']['intent']['name']
    fn_name = os.environ.get(intent_name)
    print(f"Intent: {intent_name} -> Lambda: {fn_name}")
    if (fn_name):
        # invoke lambda and return result
        invoke_response = client.invoke(FunctionName=fn_name, Payload = json.dumps(event))
        print(invoke_response)
        payload = json.load(invoke_response['Payload'])
        return payload
    raise Exception('No environment variable for intent: ' + intent_name)

def lambda_handler(event, context):
    print(event)
    response = router(event)
    return response
```

**何时在 Amazon Lex V2 机器人对话中使用AWS Lambda功能**

在与用户的对话中，您可以在以下时间使用 Lambda 函数：
+ 在识别意图后的初始响应中，例如，在用户说要订购披萨之后。
+ 从用户引发槽位值后，例如，在用户告诉机器人他们要订购的披萨大小之后。
+ 在每次重试之间引发一个槽位时，例如，客户没有使用公认的披萨尺寸时。
+ 确认意图时，例如，在确认披萨订单时。
+ 要履行意图时，例如，要订购披萨时。
+ 在履行意图之后以及机器人结束对话之前。例如，切换到点饮料的意图时。

**Topics**
+ [使用控制台将AWS Lambda函数附加到 Amazon Lex V2 机器人](lambda-attach-console.md)
+ [使用 API 操作将AWS Lambda函数附加到 Amazon Lex V2 机器人](lambda-attach-api.md)

# 使用控制台将AWS Lambda函数附加到 Amazon Lex V2 机器人
<a name="lambda-attach-console"></a>

您必须先将 Lambda 函数附加到您的 Amazon Lex V2 机器人别名中，然后才能调用该函数。每个机器人别名只能关联一个 Lambda 函数。使用 AWS 管理控制台执行这些步骤以关联 Lambda 函数。

1. 登录 AWS 管理控制台并通过以下网址打开 Amazon Lex 控制台[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)。

1. 从左侧面板中选择**机器人**，然后从机器人列表中选择要关联 Lambda 函数的机器人的名称。

1. 在左侧面板中，从**部署**菜单下选择**别名**。

1. 从别名列表中，选择要向其关联 Lambda 函数的别名。

1. 在**语言**面板中，选择您希望 Lambda 函数使用的语言。如果面板中不存在某种语言，请选择**管理别名中的语言**以添加该语言。

1. 在**源**下拉菜单中，选择要关联的 Lambda 函数的名称。

1. 在 **Lambda 函数版本或别名**下拉菜单中，选择要使用的 Lambda 函数的版本或别名。然后选择**保存**。在机器人支持的语言中，所有意图都使用相同的 Lambda 函数。

**将 Amazon Lex V2 意图设置为使用控制台调用 Lambda 函数**

1. 选择机器人后，在要调用 Lambda 函数的机器人的语言下方的左侧菜单中选择**意图**。

1. 选择要在其中调用 Lambda 函数的意图以打开意图编辑器。

1. 设置 Lambda 代码挂钩有两个选项：

   1. 要在对话的每一步之后调用 Lambda 函数，请滚动到意图编辑器底部的**代码挂钩**部分，然后选中**使用 Lambda 函数进行初始化和验证**复选框，如下图所示：  
![\[Amazon Lex V2 意图编辑器的代码挂钩部分。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-code-hooks-all.png)

   1. 或者，在对话阶段使用**对话框代码挂钩**部分来调用 Lambda 函数。**对话框代码挂钩**部分如下所示：  
![\[Amazon Lex V2 意图编辑器的代码挂钩部分。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-code-hook-step.png)

      可通过两种方法控制 Amazon Lex V2 如何调用代码挂钩以获取响应：
      + 切换**活动**按钮以将其标记为*活动*或*非活动*状态。当代码挂钩处于*活动*状态时，Amazon Lex V2 将调用该代码挂钩。当代码挂钩处于*非活动*状态时，Amazon Lex V2 不会运行代码挂钩。
      + 展开 **Lambda 对话框代码挂钩**部分，然后选中**调用 Lambda 函数**复选框将其标记为*已启用*或*已禁用*。只有在代码挂钩标记为活动状态时，才能启用或禁用该挂钩。当标记为*已启用*时，代码挂钩正常运行。当标记为*已禁用*时，不会调用代码挂钩，Amazon Lex V2 则表现为代码挂钩已成功返回。要配置对话框代码挂钩成功、失败或超时后的响应，请选择**高级选项**。

      可以在以下对话阶段调用 Lambda 代码挂钩：
      + 要调用该函数作为**初始响应**，请滚动到**初始响应**部分，点击**响应以确认用户的请求**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部找到**对话框代码挂钩**。
      + 要在**槽位引发**后调用该函数，请滚动到**槽位**部分，单击相关**槽位提示**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部附近找到**对话框代码挂钩**，位于**默认值**正上方。

        您也可以在每次引发后调用该函数。为此，请展开**槽位提示**部分的**机器人引发信息**，选择**更多提示选项**，然后选择**每次引发后调用 Lambda 代码挂钩**对应复选框。
      + 要调用**意图确认**函数，请滚动至**确认**部分，点击**确认意图提示**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部找到**对话框代码挂钩**。
      + 要调用**意图履行**函数，请滚动至**履行**部分。切换**活动**按钮以将代码挂钩设置为*活动*状态。点击**成功履行时**旁边的箭头展开，然后选择**高级选项**。选中**履行 Lambda 代码挂钩**部分的**使用 Lambda 函数进行履行**旁边的复选框，将代码挂钩设置为*已启用*。

1. 设置调用 Lambda 函数的对话阶段后，请再次**构建**机器人以测试该函数。

# 使用 API 操作将AWS Lambda函数附加到 Amazon Lex V2 机器人
<a name="lambda-attach-api"></a>

您必须先将 Lambda 函数附加到您的 Amazon Lex V2 机器人别名中，然后才能调用该函数。每个机器人别名只能关联一个 Lambda 函数。使用 API 操作执行以下步骤以关联 Lambda 函数。

如果您要创建新的机器人别名，请使用[CreateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotAlias.html)操作来附加 Lambda 函数。要将 Lambda 函数附加到现有机器人别名，请使用操作。[UpdateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateBotAlias.html)修改 `botAliasLocaleSettings` 字段以包含正确的设置：

```
{
    "botAliasLocaleSettings" : {
        locale: {
            "codeHookSpecification": {
                "lambdaCodeHook": {
                    "codeHookInterfaceVersion": "1.0",
                    "lambdaARN": "arn:aws:lambda:region:account-id:function:function-name"
                }
            },
            "enabled": true
        },
        ...
    }
}
```

1. `botAliasLocaleSettings` 字段映射到一个对象，该对象的键是要在其中关联 Lambda 函数的区域设置。有关支持的区域设置和有效密钥代码的列表，请参阅 [支持的语言和区域设置](how-languages.md#supported-languages)。

1. 要查找 Lambda 函数，请在[https://console.aws.amazon.com/lambda/家](https://console.aws.amazon.com/lambda/home)中打开AWS Lambda控制台，在左侧边栏中选择**函**数，然后选择要与机器人别名关联的函数。`lambdaARN`在**函数概述**的右侧，找到**函数 ARN** 下的 `lambdaARN`。其中应包含区域、账户 ID 和函数名称。

1. 要允许 Amazon Lex V2 为别名调用 Lambda 函数，请将 `enabled` 字段设置为 `true`。

**将 Amazon Lex V2 意图设置为使用 API 操作调用 Lambda 函数**

要在意图期间设置 Lambda 函数调用，请在创建新意图时使用该[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)操作；如果您在现有意图中调用该函数，则使用该[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作。在意图操作中控制 Lambda 函数调用的字段是 `dialogCodeHook`、`initialResponseSetting`、`intentConfirmationSetting` 和 `fulfillmentCodeHook`。

如果在获取插槽期间调用该函数，则在创建新插槽时使用该[CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)操作，或者使用该[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)操作在现有插槽中调用该函数。在槽位操作中控制 Lambda 函数调用的字段是 `valueElicitationSetting` 对象的 `slotCaptureSetting` 字段。

1. 要将 Lambda 对话框代码挂钩设置为在对话的每回合之后运行，请将该`enabled`字段中以下[DialogCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookSettings.html)对象的`dialogCodeHook`字段设置为：`true`

   ```
   "dialogCodeHook": {
       "enabled": boolean
   }
   ```

1. 或者，您可以将 Lambda 对话框代码挂钩设置为仅在对话中的特定时刻运行，方法是修改结构中与您要调用该函数的对话阶段相对应的`codeHook` and/or `elicitationCodeHook`字段。要使用 Lambda 对话框代码挂钩实现意图，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`fulfillmentCodeHook`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作中的字段。这三种类型的代码挂钩的结构和用途如下：

## codeHook
<a name="lambda-code-hook"></a>

`codeHook` 字段定义了代码挂钩在对话的给定阶段运行的设置。它是一个具有以下结构的[DialogCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookInvocationSetting.html)对象：

```
"codeHook": {
    "active": boolean,
    "enableCodeHookInvocation": boolean,
    "invocationLabel": string,
    "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
}
```
+ 将 Amazon Lex V2 的 `active` 字段更改为 `true`，从而在对话中该取值对应的时刻调用代码挂钩。
+ 将 Amazon Lex V2 的 `enableCodeHookInvocation` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ `invocationLabel` 表示调用代码挂钩的对话步骤。
+ 通过 `postCodeHookSpecification` 字段指定代码挂钩成功、失败或超时后的操作和消息。

## elicitationCodeHook
<a name="lambda-elicitation-code-hook"></a>

`elicitationCodeHook` 字段定义了在需要重新引发一个或多个槽位时运行的代码挂钩的设置。如果槽位引发失败或意图确认被拒绝，则可能会出现这种情况。该`elicitationCodeHook`字段是一个具有以下结构的[ElicitationCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ElicitationCodeHookInvocationSetting.html)对象：

```
"elicitationCodeHook": {
    "enableCodeHookInvocation": boolean,
    "invocationLabel": string
}
```
+ 将 Amazon Lex V2 的 `enableCodeHookInvocation` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ `invocationLabel` 表示调用代码挂钩的对话步骤。

## fulfillmentCodeHook
<a name="lambda-fulfillment-code-hook"></a>

`fulfillmentCodeHook` 字段定义了为履行意图而运行的代码挂钩的设置。它映射到以下[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)对象：

```
"fulfillmentCodeHook": {
    "active": boolean,
    "enabled": boolean,
    "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```
+ 将 Amazon Lex V2 的 `active` 字段更改为 `true`，从而在对话中该取值对应的时刻调用代码挂钩。
+ 将 Amazon Lex V2 的 `enabled` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ 通过 `fulfillmentUpdatesSpecification` 字段指定在履行意图期间出现用户更新的消息以及与之相关的时间。
+ 通过 `postFulfillmentStatusSpecification` 字段指定代码挂钩成功、失败或超时后的消息和操作。

您可以通过将 `active` 和 `enableCodeHookInvocation`/`enabled` 字段设置为 `true`，在对话的以下时间点调用 Lambda 代码挂钩：

## 初始响应中
<a name="lambda-hook-initial-response"></a>

要在识别意图后在初始响应中调用 Lambda 函数，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作`initialResponse`字段中的`codeHook`结构。该`initialResponse`字段映射到以下[InitialResponseSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_InitialResponseSetting.html)对象：

```
"initialResponse": {
    "codeHook": {
        "active": boolean,
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "initialResponse": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "nextStep": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
    "conditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html)
}
```

## 引发槽位之后或重新引发槽位期间
<a name="lambda-hook-elicit-slot"></a>

要在获得槽值后调用 Lambda 函数，请使用或`slotCaptureSetting`操作`valueElicitation`字段中的字段。[CreateSlot[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)该`slotCaptureSetting`字段映射到以下[SlotCaptureSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SlotCaptureSetting.html)对象：

```
"slotCaptureSetting": {
    "captureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "captureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "captureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
    "codeHook": {
        "active": true,
        "enableCodeHookInvocation": true,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "elicitationCodeHook": {
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string
    },
    "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html)
}
```
+ 要在成功引发槽位后调用 Lambda 函数，请使用 `codeHook` 字段。
+ 要在槽位引发失败且 Amazon Lex V2 尝试重试槽位引发后调用 Lambda 函数，请使用 `elicitationCodeHook` 字段。

## 确认或拒绝意图后
<a name="lambda-hook-confirm-intent"></a>

要在确认意图时调用 Lambda 函数，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`intentConfirmationSetting`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作的字段。该`intentConfirmation`字段映射到以下[IntentConfirmationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_IntentConfirmationSetting.html)对象：

```
"intentConfirmationSetting": {
    "active": boolean,
    "codeHook": {
        "active": boolean,
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "confirmationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "confirmationNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "confirmationResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialResponseSpecificationogState.html),
    "declinationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "declinationNextStep": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "declinationResponse": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
    "elicitationCodeHook": {
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
    },
    "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
    "promptSpecification": [PromptSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PromptSpecification.html)
}
```
+ 要在用户确认意图及其槽位后调用 Lambda 函数，请使用 `codeHook` 字段。
+ 要在用户拒绝意图确认且 Amazon Lex V2 尝试重试槽位引发后调用 Lambda 函数，请使用 `elicitationCodeHook` 字段。

## 履行意图期间
<a name="lambda-hook-fulfill-intent"></a>

要调用 Lambda 函数来实现意图，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`fulfillmentCodeHook`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作中的字段。该`fulfillmentCodeHook`字段映射到以下[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)对象：

```
{
    "active": boolean,
    "enabled": boolean,
    "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```

3. 设置调用 Lambda 函数的对话阶段后，请执行 `BuildBotLocale` 操作重建机器人以测试该函数。