サポート終了通知: 2025 年 9 月 15 日、 AWS は Amazon Lex V1 のサポートを終了します。 V1 2025 年 9 月 15 日を過ぎると、Amazon Lex V1 コンソールまたは Amazon Lex V1 リソースにはアクセスできなくなります。Amazon Lex V2 を使用している場合は、代わりに [Amazon Lex V2 ガイド](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html)を参照してください。
翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon Lex の開始方法
Amazon Lex には、既存のアプリケーションと統合できる API オペレーションがあります。サポートされているオペレーションのリストについては、「[API リファレンス](API_Reference.md)」を参照してください。以下のいずれかのオプションを使用できます。
+ AWS SDK - SDK を使用するとき、Amazon Lex へのリクエストは自動的に署名され、指定した認証情報を使用して認証されます。これは、アプリケーション構築に推奨される選択肢です。
+ AWS CLI — を使用して AWS CLI 、コードを記述しなくても任意の Amazon Lex 機能にアクセスできます。
+ AWS コンソール - コンソールは Amazon Lex をテストして使用を開始する最も簡単な方法です。
Amazon Lex を初めて使用する場合は、まず「[Amazon Lex: 仕組み](how-it-works.md)」を読むことをお勧めします。
**Topics**
+ [ステップ 1: AWS アカウントをセットアップし、管理者ユーザーを作成する](gs-account.md)
+ [ステップ 2: をセットアップする AWS Command Line Interface](gs-set-up-cli.md)
+ [ステップ 3: 開始方法 (コンソール)](gs-console.md)
+ [ステップ 4: ご利用開始にあたって (AWS CLI)](gs-cli.md)
# ステップ 1: AWS アカウントをセットアップし、管理者ユーザーを作成する
Amazon Lex を初めて使用する場合は、事前に以下のタスクをすべて実行してください。
1. [にサインアップする AWS](#gs-account-create)
1. [ユーザーの作成](#gs-account-user)
## にサインアップする AWS
アカウントがすでにある場合は AWS 、このタスクをスキップします。
Amazon Web Services (AWS) にサインアップすると AWS、Amazon Lex を含む のすべてのサービスに AWS アカウントが自動的にサインアップされます。請求されるのは、使用したサービスの料金のみです。
Amazon Lex の場合、使用したリソースに対してのみ料金を支払います。 AWS の新規のお客様の場合、無料で Amazon Lex の使用を開始できます。詳細については、「[AWS 無料利用枠](https://aws.amazon.com/free/)」を参照してください。
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 アカウント ID を書き留めます。
## ユーザーの作成
Amazon Lex などの のサービスでは AWS、アクセス時に認証情報を指定する必要があります。これにより、サービスが所有するリソースにアクセスするためのアクセス許可があるかどうかをサービスが判断できます。コンソールを使用するにはパスワードが必要です。ただし、 AWS アカウントの認証情報 AWS を使用して にアクセスすることはお勧めしません。代わりに、以下をお勧めします。
+ AWS Identity and Access Management (IAM) を使用してユーザーを作成する
+ 管理権限を持つ IAM グループにユーザーを追加する
+ 作成した ユーザーに管理権限を付与します。
その後、特別な URL とユーザーの認証情報 AWS を使用して にアクセスできます。
このガイドの「使用開始」実習では、管理者権限を持つユーザー (`adminuser`) が存在すること想定しています。手順に従ってアカウントに `adminuser` を作成します。
**管理者ユーザーを作成し、コンソールにサインインするには**
1. AWS アカウントに `adminuser` という管理者ユーザーを作成します。手順については、「*IAM ユーザーガイド*」の「[最初のユーザーと管理者グループの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)」を参照してください。
1. ユーザーとして、特別な URL AWS マネジメントコンソール を使用して にサインインできます。詳細については、[「IAM ユーザーガイド」](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_how-users-sign-in.html)の*「ユーザーがアカウントにサインインする方法」*を参照してください。
IAM の詳細については、以下を参照してください。
+ [AWS Identity and Access Management (IAM)](https://aws.amazon.com/iam/)
+ [IAM の開始方法](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html)
+ [IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
## 次のステップ
[ステップ 2: をセットアップする AWS Command Line Interface](gs-set-up-cli.md)
# ステップ 2: をセットアップする AWS Command Line Interface
AWS Command Line Interface (AWS CLI) で Amazon Lex を使用する場合は、ダウンロードして設定します。
**重要**
「開始方法」の演習のステップを実行する AWS CLI ために は必要ありません。ただし、このガイドの後半の演習の一部では AWS CLIを使用します。コンソールを使用して開始する場合は、このステップをスキップして「[ステップ 3: 開始方法 (コンソール)](gs-console.md)」に進んでください。後で、 が必要な場合は AWS CLI、ここに戻ってセットアップします。
**を設定するには AWS CLI**
1. AWS CLIをダウンロードして設定します。手順については、*AWS Command Line Interface ユーザーガイド*の次のトピックを参照してください。
+ [のセットアップ AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
+ [AWS Command Line Interfaceの設定](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. AWS CLI 管理者ユーザーの名前付きプロファイルを設定ファイルの末尾に追加します。 AWS CLI コマンドを実行するときは、このプロファイルを使用します。名前付きプロファイルの詳細については、*AWS Command Line Interface ユーザーガイド*の「[名前付きプロファイル](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles)」を参照してください。
```
[profile adminuser]
aws_access_key_id = adminuser access key ID
aws_secret_access_key = adminuser secret access key
region = aws-region
```
使用可能な AWS リージョンのリストについては、の[「リージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html)」を参照してください*Amazon Web Services 全般のリファレンス*。
1. コマンドプロンプトに Help コマンドを入力して、セットアップを検証します。
```
aws help
```
##
[ステップ 3: 開始方法 (コンソール)](gs-console.md)
# ステップ 3: 開始方法 (コンソール)
Amazon Lex の使用開始方法を学ぶ最も簡単な方法は、コンソールを使用することです。開始するために、以下の作成済みの演習を利用できます。すべての演習でコンソールを使用します。
+ 演習 1 - 設計図を使用して Amazon Lex ボットを作成します。設計図は、すべての必要なボット設定を提供する事前定義されたボットです。最低限の作業を行うだけでエンドツーエンドのセットアップをテストできます。
さらに、 が提供する Lambda 関数の設計図を使用して AWS Lambda Lambda 関数を作成します。関数は、ボットと互換性のある事前定義済みのコードを使用するコードフックです。
+ 演習 2 - ボットを手動で作成して設定し、カスタムボットを作成します。また、コードフックとして Lambda 関数を作成します。サンプルコードが用意されています。
+ 演習 3 - ボットを発行し、このボットの新しいバージョンを作成します。この演習では、ボットのバージョンを参照するエイリアスを作成します。
**Topics**
+ [演習 1: 設計図を使用して Amazon Lex ボットを作成する (コンソール)](gs-bp.md)
+ [演習 2: Amazon Lex のカスタムボットを作成する](getting-started-ex2.md)
+ [演習 3: バージョンを発行してエイリアスを作成する](gettingstarted-ex3.md)
# 演習 1: 設計図を使用して Amazon Lex ボットを作成する (コンソール)
この演習では、以下のことを行います。
+ 最初の Amazon Lex ボットを作成して Amazon Lex コンソールでテストします。
この演習では **OrderFlowers** 設計図を使用します。設計図については、「[Amazon Lex と AWS Lambda ブループリント](lex-lambda-blueprints.md)」を参照してください。
+ AWS Lambda 関数を作成し、Lambda コンソールでテストします。リクエストの処理中に、この Lambda 関数をボットから呼び出します。この演習では、 AWS Lambda コンソールで提供されている Lambda ブループリント (**lex-order-flowers-python**) を使用して Lambda 関数を作成します。設計図コードは、同じ Lambda 関数を使用して初期化と検証を行う方法、および `OrderFlowers` インテントを達成する方法を示しています。
+ ボットを更新し、インテントを達成するためのコードフックとして Lambda 関数を追加します。エンドツーエンドエクスペリエンスをテストします。
以下のセクションでは設計図の機能について説明します。
## Amazon Lex ボット: 設計図の概要
**OrderFlowers** 設計図を使用して Amazon Lex ボットを作成します。ボットの構造の詳細については、「[Amazon Lex: 仕組み](how-it-works.md)」を参照してください。このボットは次のように事前設定されています。
+ **インテント** – OrderFlowers
+ **スロットタイプ** – 1 つのカスタムスロットタイプ (`FlowerTypes`) と列挙値 (`roses`、`lilies`、`tulips`)。
+ **スロット** – ボットでインテントを達成する前に、インテントには以下の情報 (つまり、スロット) が必要です。
+ `PickupTime` (AMAZON.TIME 組み込みタイプ)
+ `FlowerType` (FlowerTypes カスタムタイプ)
+ `PickupDate` (AMAZON.DATE 組み込みタイプ)
+ **発話** – 以下のサンプル発話はユーザーのインテントを示しています。
+ 「花をピックアップしたい」
+ 「花を注文したい」
+ **プロンプト** – ボットは、インテントを識別した後で、以下のプロンプトを使用してスロットを満たします。
+ `FlowerType` スロットのプロンプト – 「どの花を注文なさいますか?」
+ `PickupDate` スロットのプロンプト – 「何日に \$1FlowerType\$1 をピックアップなさいますか?」
+ `PickupTime` スロットのプロンプト – 「何時に \$1FlowerType\$1 をピックアップなさいますか?」
+ 確認ステートメント – 「了解いたしました。お客様の \$1FlowerType\$1 は \$1PickupDate\$1 の \$1PickupTime\$1 までにご用意させていただきます。それでよろしいでしょうか?」
## AWS Lambda 関数: 設計図の概要
この演習の Lambda 関数では、初期化と検証、およびフルフィルメントの両方のタスクを実行します。したがって、Lambda 関数を作成した後に、初期化/検証とフルフィルメントタスクの両方を処理するコードフックとして同じ Lambda 関数を指定することで、インテント設定を更新します。
+ 初期化および検証のコードフックとして、Lambda 関数は基本的な検証を実行します。例えば、ユーザーが指定したピックアップの時間が通常の営業時間外である場合、Lambda 関数は時間を指定し直すことをユーザーに再度プロンプトするように Amazon Lex に指示します。
+ フルフィルメントコードフックの一環として、Lambda 関数は花の注文が確定した (つまり、インテントが達成された) ことを示す概要メッセージを返します。
**次のステップ**
[ステップ 1: Amazon Lex ボット (コンソール) を作成する](gs-bp-create-bot.md)
# ステップ 1: Amazon Lex ボット (コンソール) を作成する
この演習では、花を注文するボットとして OrderFlowersBot を作成します。
Amazon Lex ボット (コンソール) を作成するには
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。
1. 初めてのボットの場合には [**Get Started**] (ご利用開始にあたって)、それ以外の場合は [**ボット**] ページを選択し、続いて [**作成**] を選択します。
1. [**Create your Lex bot**] ページで、以下の情報を指定して [**Create**] を選択します。
+ [**OrderFlowers**] 設計図を選択します。
+ ボット名 (OrderFlowers) はデフォルトのままにしておきます。
+ [**COPPA**] で [**No**] を選択します。
+ **ユーザーの発話ストレージ**で、適切なレスポンスを選択します。
1. **[作成]** を選択します。コンソールは Amazon Lex に対して必要なリクエストを行い、設定を保存します。次に、コンソールはボットエディタウィンドウを表示します。
1. ボットが作成されたことが確認されるまで待機します。
1. ボットをテストします。
**注記**
ボットをテストするには、テストウィンドウにテキストを入力するか、テストウィンドウにあるマイクボタンを選択して話しかけます (対応しているブラウザの場合)。
次のサンプルテキストを使用してボットと会話し、花を注文します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/OrderFlowers-NoLambda.png)
この入力により、ボットは `OrderFlowers` インテントを推測し、スロットデータのプロンプトを表示します。すべての必要なスロットデータを提供すると、ボットはすべての情報をクライアントアプリケーション (この例ではコンソール) に返すことで、インテント (`OrderFlowers`) を達成します。コンソールは、テストウィンドウに情報を表示します。
具体的には次のとおりです。
+ 「何日にバラをピックアップなさいますか?」の文で「バラ」という単語が使用されているのは、`pickupDate` スロットのプロンプトが `{FlowerType}` を置き換えるように設定されているためです。これはコンソールで確認できます。
+ 「了解いたしました。お客様のバラは ...」という文は、確認プロンプトとして設定したものです。
+ 最後の文 (「`FlowerType:roses...`」) は、クライアント (この例ではテストウィンドウ) に単純に返されるスロットデータです。次の演習では、Lambda 関数を使用してインテントを達成します。インテントが達成されると、注文が確定されたことを示すメッセージが表示されます。
**次のステップ**
[ステップ 2 (オプション): 情報フローの詳細を確認する (コンソール)](gs-bp-details-two-runtime-apis.md)
# ステップ 2 (オプション): 情報フローの詳細を確認する (コンソール)
このセクションでは、クライアントと Amazon Lex 間の情報フローについて、サンプル会話のユーザー入力別に説明します。
この例では、ボットとの会話にコンソールテストウィンドウを使用します。
**Amazon Lex のテストウィンドウを開くには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。
1. テストするボットを選択します。
1. コンソールの右側で、**[Test chatbot]** (chatbot のテスト) を選択します。
次のいずれかのトピックを選択し、音声または入力による情報フローを確認してください。
**Topics**
+ [ステップ 2a (オプション): 音声による情報フローの詳細を確認する (コンソール)](gs-bp-details-postcontent-flow.md)
+ [ステップ 2b (オプション): 入力による情報フローの詳細を確認する (コンソール)](gs-bp-details-part1.md)
# ステップ 2a (オプション): 音声による情報フローの詳細を確認する (コンソール)
このセクションでは、クライアントが音声を使用してリクエストを送信した場合の、クライアントと Amazon Lex 間の情報フローについて説明します。詳細については、「[PostContent](API_runtime_PostContent.md)」を参照してください。
1. ユーザーの発話: 花を注文したい。
1. クライアント (コンソール) は以下の [PostContent](API_runtime_PostContent.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream
```
リクエストの URI と本文の両方で Amazon Lex に情報が提供されています。
+ リクエスト URI ボット名 (`OrderFlowers`)、ボットエイリアス (`$LATEST`)、ユーザー名 (ユーザーを識別するランダムな文字列)。`content` はこれが `PostContent` API リクエストである (`PostText` リクエストではない) と示します。
+ リクエストヘッダー
+ `x-amz-lex-session-attributes` –「\$1\$1」を表す base64 エンコード値。クライアントが最初のリクエストを行うときにはセッション属性はありません。
+ `Content-Type` – オーディオ形式が反映されています。
+ リクエストボディ – ユーザー入力のオーディオストリーム (「花を注文したい」)。
**注記**
話すのではなく `PostContent` API にテキスト (「花を注文したい」) を送信することをユーザーが選択した場合、リクエストボディはユーザー入力です。それに応じて `Content-Type` ヘッダーが設定されています。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: accept
Request body
input stream
```
1. 入力ストリームから、Amazon Lex はインテント (`OrderFlowers`) を検出します。次に、そのインテントのスロットのいずれか (この場合は `FlowerType`)、およびその値を引き出すプロンプトの 1 つ を選択し、以下のヘッダーを付けてレスポンスを送信します。
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:I would like to order some flowers.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:What type of flowers would you like to order?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:FlowerType
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjpudWxsLCJQaWNrdXBEYXRlIjpudWxsfQ==
```
ヘッダー値では以下の情報が指定されています。
+ `x-amz-lex-input-transcript` – リクエスト内の音声 (ユーザー入力) のトランスクリプト
+ `x-amz-lex-message` – Amazon Lex がレスポンスで返した音声のトランスクリプト
+ `x-amz-lex-slots` – スロットと値のペアを表す次の文字列を base64 でエンコードした値
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes` – セッション属性を表す文字列 (\$1\$1) を base64 でエンコードした値
クライアントはレスポンス本文内の音声を再生します。
1. ユーザーの発声: バラ
1. クライアント (コンソール) は以下の [PostContent](API_runtime_PostContent.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("roses")
```
リクエストボディはユーザー入力の音声ストリーム (「バラ」) です。`sessionAttributes` は空のままです。
1. Amazon Lex は現在のインテントのコンテキストで入力ストリームを解釈します (`FlowerType` スロットに関する情報をこのユーザーに求めていたことを覚えています)。Amazon Lex はまず現在のインテントのスロット値を更新します。次に、別のスロット (`PickupDate`) をそのプロンプトメッセージの 1 つ (いつバラをピックアップなさいますか?) と共に選択し、以下のヘッダーを付けてレスポンスを返します。
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:roses
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupDate
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6bnVsbH0=
```
ヘッダー値では以下の情報が指定されています。
+ `x-amz-lex-slots` – スロットと値のペアを表す次の文字列を base64 でエンコードした値
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes` – セッション属性を表す文字列 (\$1\$1) を base64 でエンコードした値
クライアントはレスポンス本文内の音声を再生します。
1. ユーザーの発声: 明日
1. クライアント (コンソール) は以下の [PostContent](API_runtime_PostContent.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("tomorrow")
```
リクエストボディはユーザー入力の音声ストリーム (「明日」) です。`sessionAttributes` は空のままです。
1. Amazon Lex は現在のインテントのコンテキストで入力ストリームを解釈します (`PickupDate` スロットに関する情報をこのユーザーに求めていたことを覚えています)。Amazon Lex は現在のインテントのスロット (`PickupDate`) の値を更新します。次に、値を引き出す別のスロット (`PickupTime`)、およびその値を引き出すいずれかのプロンプト (「2017 年 3 月 18 日の何時にバラをピックアップなさいますか」) を選択し、以下のヘッダーを付けてレスポンスを返します。
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:tomorrow
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses on 2017-03-18?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupTime
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:3a205b70-0b69-11e7-b447-eb69face3e6f
```
ヘッダー値では以下の情報が指定されています。
+ `x-amz-lex-slots` – スロットと値のペアを表す次の文字列を base64 でエンコードした値
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes` – セッション属性を表す文字列 (\$1\$1) を base64 でエンコードした値
クライアントはレスポンス本文内の音声を再生します。
1. ユーザーの発声: 午後 6 時
1. クライアント (コンソール) は以下の [PostContent](API_runtime_PostContent.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: "audio/mpeg"
Request body
input stream ("6 pm")
```
リクエストボディはユーザー入力の音声ストリーム (「午後 6 時」) です。`sessionAttributes` は空のままです。
1. Amazon Lex は現在のインテントのコンテキストで入力ストリームを解釈します (`PickupTime` スロットに関する情報をこのユーザーに求めていたことを覚えています)。まず現在のインテントのスロット値を更新します。
ここで、Amazon Lex はすべてのスロットのデータがそろっていることを検出します。ただし、`OrderFlowers` インテントには確認メッセージが設定されています。そのため、Amazon Lex はインテントの達成に進む前に、ユーザーからの明示的な確認を必要とします。花を注文する前に確認を要求する以下のヘッダーを付けてレスポンスを送信します。
```
x-amz-lex-dialog-state:ConfirmIntent
x-amz-lex-input-transcript:six p. m.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:Okay, your roses will be ready for pickup by 18:00 on 2017-03-18. Does this sound okay?
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:083ca360-0b6a-11e7-b447-eb69face3e6f
```
ヘッダー値では以下の情報が指定されています。
+ `x-amz-lex-slots` – スロットと値のペアを表す次の文字列を base64 でエンコードした値
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes` – セッション属性を表す文字列 (\$1\$1) を base64 でエンコードした値
クライアントはレスポンス本文内の音声を再生します。
1. ユーザーの発声: はい
1. クライアント (コンソール) は以下の [PostContent](API_runtime_PostContent.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("Yes")
```
リクエストボディはユーザー入力の音声ストリーム (「はい」) です。`sessionAttributes` は空のままです。
1. Amazon Lex は入力ストリームを解釈し、注文を進めることをユーザーが望んでいることを理解します。`OrderFlowers` インテントには、フルフィルメントアクティビティとして `ReturnIntent` が設定されています。これにより、Amazon Lex からすべてのインテントデータがクライアントに返されます。Amazon Lex は以下の内容でレスポンスを返します。
```
x-amz-lex-dialog-state:ReadyForFulfillment
x-amz-lex-input-transcript:yes
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
```
`x-amz-lex-dialog-state` レスポンスヘッダーは `ReadyForFulfillment` に設定されています。これで、クライアントはインテントを達成できます。
1. ここで、ボットを再テストします。新しい (ユーザー) コンテキストを確立するには、コンソールで [**Clear**] リンクを選択します。`OrderFlowers` インテントに指定するデータに、以下のような無効なデータを含めます。例:
+ 花の種類として「Jasmine」 (サポートされている花の種類ではない)
+ 花をピックアップする日付として「昨日」
ボットではこれらの値が受け付けられることがわかります。これは、ユーザーデータを初期化および検証するコードがないためです。次のセクションでは、その処理を行う Lambda 関数を追加します。Lambda 関数について、以下の点に注意してください。
+ ユーザー入力のたびにスロットデータを検証します。インテントは最後に達成されます。つまり、ボットはスロットデータをクライアントに返すだけではなく、花の注文を処理してユーザーにメッセージを返します。詳細については、「[Lambda 関数を使用する](using-lambda.md)」を参照してください。
+ セッション属性も設定します。セッション属性の詳細については、「[PostText](API_runtime_PostText.md)」を参照してください。
ご利用開始のセクションを完了したら、その他の演習 ([その他の例: Amazon Lex ボットの作成](additional-exercises.md)) を行うことができます。[旅行を予約する](ex-book-trip.md) は、セッション属性を使用してクロスインテント情報を共有し、ユーザーと動的に会話します。
**次のステップ**
[ステップ 3: Lambda 関数を作成する (コンソール)](gs-bp-create-lambda-function.md)
# ステップ 2b (オプション): 入力による情報フローの詳細を確認する (コンソール)
このセクションでは、クライアントが `PostText` API を使用してリクエストを送信する場合の、クライアントと Amazon Lex の間の情報のフローについて説明します。詳細については、「[PostText](API_runtime_PostText.md)」を参照してください。
1. ユーザーの入力: 「花を注文したい」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
リクエストの URI と本文の両方で Amazon Lex に情報が提供されています。
+ リクエスト URI – ボット名 (`OrderFlowers`)、ボットのエイリアス (`$LATEST`)、およびユーザー名 (ユーザーを識別するランダムな文字列) を提供します。末尾の `text` では、これが `PostText` API リクエストである (`PostContent` ではない) ことが示されています。
+ リクエストボディ – ユーザー入力 (`inputText`) と空の `sessionAttributes` が含まれています。クライアントが最初のリクエストを行うときにはセッション属性はありません。Lambda 関数は後でセッション属性を使用します。
1. `inputText` から、Amazon Lex はインテント (`OrderFlowers`) を検出します。このインテントには、ユーザー入力の初期化と検証、あるいはフルフィルメントを行うためのコードフック (Lambda 関数) がありません。
Amazon Lex は、値を引き出すインテントのスロットのいずれか (この場合は `FlowerType`) を選択します。また、そのスロットの値を引き出すプロンプトの 1 つ (すべてインテント設定の一部) を選択し、以下のレスポンスをクライアントに返します。コンソールに、ユーザーへのレスポンスのメッセージが表示されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-10.png)
クライアントはレスポンス内のメッセージを表示しています。
1. ユーザーの入力: 「バラ」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
リクエストボディの `inputText` は、ユーザー入力を示します。`sessionAttributes` は空のままです。
1. Amazon Lex はまず、現在のインテントのコンテキストの `inputText` を解釈します (このサービスでは `FlowerType` スロットに関する情報を特定のユーザーに求めていたことが記憶されています)。Amazon Lex は現在のインテントのスロット値を更新し、別のスロット (`PickupDate`) をそのスロットのプロンプトメッセージの 1 つ (「何日にバラをピックアップなさいますか?」) `` と共に選択します。
次に、Amazon Lex は以下のレスポンスを返します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-20.png)
クライアントはレスポンス内のメッセージを表示しています。
1. ユーザーの入力: 「明日」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
リクエストボディの `inputText` は、ユーザー入力を示します。`sessionAttributes` は空のままです。
1. Amazon Lex はまず、現在のインテントのコンテキストの `inputText` を解釈します (このサービスでは `PickupDate` スロットに関する情報を特定のユーザーに求めていたことが記憶されています)。Amazon Lex は現在のインテントのスロット (`PickupDate`) の値を更新します。値を引き出す別のスロット (`PickupTime`) を選択します。値を引き出すプロンプトの 1 つ (2017 年 1 月 5 日の何時にバラを配達しますか? ) ``がクライアントに返されます。
次に、Amazon Lex は以下のレスポンスを返します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-30.png)
クライアントはレスポンス内のメッセージを表示しています。
1. ユーザーの入力: 「午後 6 時」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
リクエストボディの `inputText` は、ユーザー入力を示します。`sessionAttributes` は空のままです。
1. Amazon Lex はまず、現在のインテントのコンテキストの `inputText` を解釈します (このサービスでは `PickupTime` スロットに関する情報を特定のユーザーに求めていたことが記憶されています)。Amazon Lex はまず現在のインテントのスロット値を更新します。ここで、Amazon Lex はすべてのスロットのデータがそろっていることを検出します。
`OrderFlowers` インテントには確認メッセージが設定されています。そのため、Amazon Lex はインテントの達成に進む前に、ユーザーからの明示的な確認を必要とします。Amazon Lex は、花を注文する前に確認を要求する以下のメッセージをクライアントに送信します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-40.png)
クライアントはレスポンス内のメッセージを表示しています。
1. ユーザーの入力: 「はい」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
リクエストボディの `inputText` は、ユーザー入力を示します。`sessionAttributes` は空のままです。
1. Amazon Lex は、現在のインテントの確認のコンテキストで `inputText` を解釈して、注文を進めることをユーザーが望んでいることを理解します。`OrderFlowers` インテントには、フルフィルメントアクティビティとして `ReturnIntent` が設定されています (インテントを達成するための Lambda 関数はありません)。したがって、Amazon Lex は次のスロットデータをクライアントに返します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex は `dialogState` を `ReadyForFulfillment` に設定します。これで、クライアントはインテントを達成できます。
1. ここで、ボットをもう一度テストします。そのためには、コンソールで [**Clear**] リンクを選択して、新しい (ユーザー) コンテキストを確立する必要があります。ここで、花の注文のデータを提供するときに、無効なデータを指定してみます。例:
+ 花の種類として「Jasmine」 (サポートされている花の種類ではない)
+ 花をピックアップする日付として「昨日」
ボットではこれらの値が受け付けられることがわかります。これは、ユーザーデータを初期化/検証するコードがないためです。次のセクションでは、その処理を行う Lambda 関数を追加します。Lambda 関数について、以下の点に注意してください。
+ Lambda 関数はユーザー入力のたびにスロットデータを検証します。インテントは最後に達成されます。つまり、ボットはスロットデータをクライアントに返すだけではなく、花の注文を処理してユーザーにメッセージを返します。詳細については、「[Lambda 関数を使用する](using-lambda.md)」を参照してください。
+ Lambda 関数はセッション属性も設定します。セッション属性の詳細については、「[PostText](API_runtime_PostText.md)」を参照してください。
ご利用開始のセクションを完了したら、その他の演習 ([その他の例: Amazon Lex ボットの作成](additional-exercises.md)) を行うことができます。[旅行を予約する](ex-book-trip.md) は、セッション属性を使用してクロスインテント情報を共有し、ユーザーと動的に会話します。
**次のステップ**
[ステップ 3: Lambda 関数を作成する (コンソール)](gs-bp-create-lambda-function.md)
# ステップ 3: Lambda 関数を作成する (コンソール)
Lambda 関数を作成し (**lex-order-flowers-python** 設計図を使用)、 AWS Lambda コンソールでサンプルのイベントデータを使用して呼び出しのテストを行います。
Amazon Lex コンソールに戻り、前のセクションで作成した `OrderFlowersBot` の `OrderFlowers` インテントを達成するコードフックとして Lambda 関数を追加します。
**Lambda 関数を作成するには (コンソール)**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) で AWS Lambda コンソールを開きます。
1. [**Create function**] を選択します。
1. [**Create function**] (関数の作成) ページで、[**Blueprints**] (設計図) を選択します。フィルタテキストボックスに「**lex-**」と入力し、`Enter` キーを押して設計図を見つけ、[`lex-order-flowers-python` 設計図] を選択します。
Lambda 関数の設計図は Node.js と Python の両方で提供されています。この演習では Python ベースの設計図を使用します。
1. [**基本的な情報**] ページでは、以下を実行します。
+ Lambda 関数の名前 (`OrderFlowersCodeHook`) を入力します。
+ 実行ロールについては、**[Create a new role with basic Lambda permissions]** (基本的な Lambda アクセス権限で新しいロールを作成) を選択します。
+ 他はデフォルト値のままにしておきます。
1. [**関数の作成**] を選択してください。
1. 英語 (US) (en-US) 以外のロケールを使用している場合は、[特定のロケールの設計図の更新](lex-lambda-blueprints.md#blueprint-update-locale) の説明に従ってインテント名を更新します。
1. Lambda 関数をテストします。
1. [**テストイベントの選択**]、[**テストイベント設定**] の順に選択します。
1. **[Event template]** (イベントテンプレート) リストから **[Amazon Lex-Order Flowers]** (Amazon Lex - お花の注文) を選択します。このサンプルイベントは Amazon Lex のリクエスト/レスポンスモデル (「[Lambda 関数を使用する](using-lambda.md)」を参照) と一致します。テストイベント名 (`LexOrderFlowersTest`) を指定します。
1. **[作成]** を選択します。
1. [**テスト**] を選択してコードフックをテストします。
1. Lambda 関数が正常に実行されたことを確認します。この例のレスポンスは、Amazon Lex レスポンスモデルと一致します。
**次のステップ**
[ステップ 4: Lambda 関数をコードフックとして追加する (コンソール)](gs-bp-create-integrate.md)
# ステップ 4: Lambda 関数をコードフックとして追加する (コンソール)
このセクションでは、次のように Lambda 関数を使用するように OrderFlowers インテントの設定を更新します。
+ 最初に `OrderFlowers` インテントを達成するためのコードフックとして Lambda 関数を使用します。ボットをテストして、Lambda 関数からフルフィルメントメッセージを受信していることを確認します。Amazon Lex は、花の注文に必要なすべてのスロットのデータが提供された後にのみ、Lambda 関数を呼び出します。
+ 初期化と検証を行うために同じ Lambda 関数をコードフックとして設定します。Lambda 関数が、(スロットデータが提供されたときに) 検証を行っていることをテストして確認します。
**Lambda 関数をコードフックとして追加するには (コンソール)**
1. Amazon Lex コンソールで、**[OrderFlowers]** ボットを選択します。コンソールに [**OrderFlowers**] インテントが表示されます。インテントのバージョンが `$LATEST` に設定されていることを確認します。変更できるのはこのバージョンだけです。
1. Lambda 関数をフルフィルメントのコードフックとして追加してテストします。
1. エディタで、**[AWS Lambda function]** (関数) を **[Fulfillment]** (フルフィルメント) として選択し、前のステップで作成した Lambda 関数を選択します (`OrderFlowersCodeHook`)。[**OK**] を選択して、Lambda 関数を呼び出すアクセス権限を Amazon Lex に付与します。
この Lambda 関数は、インテントを達成するためのコードフックとして設定しています。この関数を Amazon Lex が呼び出すのは、インテントを達成するために必要なすべてのスロットデータをユーザーから取得した後のみです。
1. [**Goodbye message**] を指定します。
1. [**Build**] を選択します。
1. 前の会話を使用してボットをテストします。
最後の文章である「ありがとうございました。お客様のバラは ...」は、コードフックとして設定した Lambda 関数からのレスポンスです。前のセクションでは、Lambda 関数はありませんでした。ここでは、Lambda 関数を使用して実際に `OrderFlowers` インテントを達成します。
1. Lambda 関数を初期化および検証のコードフックとして追加してテストします。
Lambda 関数のサンプルコードを使用して、ユーザー入力の検証とフルフィルメントの両方を行うことができます。Lambda 関数が受け取る入力イベントには、どのコード部分を実行するかをコードで判断するためのフィールド (`invocationSource`) があります。詳細については、「[Lambda 関数の入力イベントとレスポンスの形式](lambda-input-response-format.md)」を参照してください。
1. `OrderFlowers` の \$1LATEST バージョンを選択します。これは更新できる唯一のバージョンです。
1. エディタで、[**オプション**] の [**Initialization and validation**] (初期化と検証) を選択します。
1. ここでも、同じ Lambda 関数を選択します。
1. [**Build**] を選択します。
1. ボットをテストします。
次の画像ように Amazon Lex と対話する準備が整いました。検証部分をテストするには、時間として 6 PM を選択します。Lambda 関数からレスポンス (「当社の営業時間は午前 10 時から午後 5 時までとなっております」) が返され、選択し直すことを求められます。すべての有効なスロットデータを提供すると、Lambda 関数によって注文が確定されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**次のステップ**
[ステップ 5 (オプション): 情報フローの詳細を確認する (コンソール)](gs-bp-details-after-lambda.md)
# ステップ 5 (オプション): 情報フローの詳細を確認する (コンソール)
このセクションでは、各ユーザー入力に対する、クライアントと Amazon Lex の間の情報のフローについて、Lambda 関数の統合も含めて説明します。
**注記**
このセクションでは、クライアントが `PostText` ランタイム API を使用して Amazon Lex にリクエストを送信することを前提としていて、それに応じてリクエストとレスポンスの詳細を示しています。クライアントが `PostContent` API を使用する場合の、クライアントと Amazon Lex の間の情報フローの例については、「[ステップ 2a (オプション): 音声による情報フローの詳細を確認する (コンソール)](gs-bp-details-postcontent-flow.md)」を参照してください。
`PostText` ランタイム API、および以下のステップで示しているリクエストとレスポンスに関するその他の詳細については、「[PostText](API_runtime_PostText.md)」を参照してください。
1. ユーザー: 「花を注文したい」
1. クライアント (コンソール) は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
リクエストの URI と本文の両方で Amazon Lex に情報が提供されています。
+ リクエスト URI – ボット名 (`OrderFlowers`)、ボットのエイリアス (`$LATEST`)、およびユーザー名 (ユーザーを識別するランダムな文字列) を提供します。末尾の `text` では、これが `PostText` API リクエストである (`PostContent` ではない) ことが示されています。
+ リクエストボディ – ユーザー入力 (`inputText`) と空の `sessionAttributes` が含まれています。クライアントが最初のリクエストを行うときにはセッション属性はありません。Lambda 関数は後でセッション属性を使用します。
1. `inputText` から、Amazon Lex はインテント (`OrderFlowers`) を検出します。このインテントには、ユーザーデータの初期化/検証を行うためのコードフックとして Lambda 関数が設定されています。そのため、Amazon Lex は以下の情報をイベントデータとして渡すことで、その Lambda 関数を呼び出します。
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
詳細については、「[入力イベントの形式](lambda-input-response-format.md#using-lambda-input-event-format)」を参照してください。
クライアントが送信する情報に加えて、Amazon Lex はまた、以下の追加データを含めます。
+ `messageVersion` – 現在 Amazon Lex でサポートしているのは 1.0 バージョンだけです。
+ `invocationSource` – Lambda 関数呼び出しの目的を示しています。この場合は、ユーザーデータの初期化および検証を行うことです。この時点で、Amazon Lex はインテントを達成するためのスロットデータの一部をユーザーがまだ指定していないことを知っています。
+ `currentIntent` の情報。すべてのスロット値は null に設定されています。
1. この時点では、すべてのスロット値は null です。Lambda 関数が検証する対象はありません。Lambda 関数は以下のレスポンスを Amazon Lex に返します。
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
レスポンスの形式については、「[レスポンスの形式](lambda-input-response-format.md#using-lambda-response-format)」を参照してください。
次の点に注意してください。
+ `dialogAction.type` – この値を `Delegate` に設定することで、Lambda 関数は次の一連のアクションを決定する責任を Amazon Lex に委任します。
**注記**
Lambda 関数は、ユーザーデータの検証で何かを検出した場合に、次に何をするかを Amazon Lex に指示します。それについては以下のステップで説明します。
1. `dialogAction.type` に従って、Amazon Lex は次の一連のアクションを決定します。どのスロットも入力されていないため、`FlowerType` スロットの値を引き出すことを決定します。値を引き出すプロンプトの 1 つ (「どの種類の花を注文しますか?」) をこのスロットに選択し、以下のレスポンスをクライアントに返します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-10.png)
クライアントはレスポンス内のメッセージを表示しています。
1. ユーザー: 「バラ」
1. クライアント は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
リクエストボディの `inputText` でユーザー入力が提供されています。`sessionAttributes` は空のままです。
1. Amazon Lex はまず現在のインテントのコンテキストで `inputText` を解釈します。サービスでは `FlowerType` スロットに関する情報をこのユーザーに求めていたことが記憶されています。現在のインテントのスロット値を更新し、以下のイベントデータを使用して Lambda 関数を呼び出します。
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
次の点に注意してください。
+ `invocationSource` – `DialogCodeHook` のままです (ユーザーデータを検証しているだけです)。
+ `currentIntent.slots` – Amazon Lex は `FlowerType` スロットを「バラ」に更新しています。
1. `invocationSource` の `DialogCodeHook` の値に従って、Lambda 関数はユーザーデータの検証を実行します。この関数は `roses` を有効なスロット値として認識し (また、`Price` をセッション属性として設定して)、以下のレスポンスを Amazon Lex に返します。
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
次の点に注意してください。
+ `sessionAttributes` – Lambda 関数は (バラの) `Price` をセッション属性として追加しています。
+ `dialogAction.type` – `Delegate` に設定されます。ユーザーデータは有効であるため、Lambda 関数は次の一連のアクションを選択するように Amazon Lex に指示します。
1. `dialogAction.type` に従って、Amazon Lex は次の一連のアクションを選択します。Amazon Lex は、より多くのスロットデータが必要であることを知っているため、インテント設定に従って最も優先度が高い次の未指定スロット (`PickupDate`) を選択します。Amazon Lex は、このスロットにプロンプトメッセージの 1 つ (「何日にバラを受け取りたいですか?」) をインテント設定に応じて選択し、クライアントに次のレスポンスを返答として送信します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-20.png)
クライアントには、レスポンスのメッセージ (「何日にバラをピックアップなさいますか?」) だけが表示されます。
1. ユーザー: 「明日」
1. クライアント は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
リクエストボディの `inputText` でユーザー入力が提供され、クライアントはセッション属性をサービスに返します。
1. Amazon Lex は、これが `PickupDate` スロットに対して引き出されているデータであるというコンテキストを覚えています。このコンテキストでは、`inputText` が `PickupDate` スロットに対する値であることを知っています。Amazon Lex は以下のイベントを送信することで Lambda 関数を呼び出します。
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex は `currentIntent.slots` の値を設定することで、`PickupDate` を更新しています。また、サービスによって `sessionAttributes` がそのまま Lambda 関数に渡されています。
1. `invocationSource` の `DialogCodeHook` の値に従って、Lambda 関数はユーザーデータの検証を行います。この関数は `PickupDate` のスロット値が有効であることを認識し、以下のレスポンスを Amazon Lex に返します。
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
次の点に注意してください。
+ `sessionAttributes` – 変更しません。
+ `dialogAction.type` – `Delegate` に設定されます。ユーザーデータは有効であるため、Lambda 関数は次の一連のアクションを選択するように Amazon Lex に指示します。
1. `dialogAction.type` に従って、Amazon Lex は次の一連のアクションを選択します。Amazon Lex は、より多くのスロットデータが必要であることを知っているため、インテント設定に従って最も優先度が高い次の未指定スロット (`PickupTime`) を選択します。Amazon Lex はプロンプトのメッセージ (「2017 年 1 月 5 日の何時にバラを配達いたしましょうか?」) のいずれかを選択し、 以下のレスポンスをクライアントに送信します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-30.png)
クライアントはレスポンス内のメッセージ (「2017 年 1 月 5 日の何時にバラを配達いたしましょうか?」) を表示します。
1. ユーザー: 「午後 4 時」
1. クライアント は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "4 pm",
"sessionAttributes": {
"Price": "25"
}
}
```
リクエストボディの `inputText` でユーザー入力が提供されています。クライアントはそのリクエストで `sessionAttributes` を渡します。
1. Amazon Lex はコンテキストを理解しています。`PickupTime` スロットに対するデータを引き出していたというコンテキストを理解しています。このコンテキストでは、`inputText` が `PickupTime` スロットに対する値であることを知っています。Amazon Lex は以下のイベントを送信することで Lambda 関数を呼び出します。
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex は `currentIntent.slots` の値を設定することで、`PickupTime` を更新しています。
1. `invocationSource` の `DialogCodeHook` の値に従って、Lambda 関数はユーザーデータの検証を実行します。この関数は `PickupDate` のスロット値が有効であることを認識し、以下のレスポンスを Amazon Lex に返します。
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
次の点に注意してください。
+ `sessionAttributes` – セッション属性は変更されていません。
+ `dialogAction.type` - `Delegate` に設定されます。ユーザーデータは有効であるため、Lambda 関数は次の一連のアクションを選択するように Amazon Lex に指示します。
1. この時点で、Amazon Lex はすべてのスロットデータがそろっていることを知っています。このインテントには確認プロンプトが設定されています。そのため、Amazon Lex は、インテントを達成する前にユーザーの確認を求める以下のレスポンスを送信します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-45.png)
クライアントはレスポンス内のメッセージをそのまま表示し、ユーザーの応答を待ちます。
1. ユーザー: 「はい」
1. クライアント は以下の [PostText](API_runtime_PostText.md) リクエストを Amazon Lex に送信します。
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "yes",
"sessionAttributes": {
"Price": "25"
}
}
```
1. Amazon Lex は、現在のインテントの確認のコンテキストで `inputText` を解釈して、Amazon Lexは、注文を進めることをユーザーが望んでいることを理解します。Amazon Lex は今回は、以下のイベントを送信することで、インテントを達成するために Lambda 関数を呼び出します。Lambda 関数に送信するイベントで `invocationSource` を `FulfillmentCodeHook` に設定しています。Amazon Lex はまた、`confirmationStatus` から `Confirmed` に設定します。
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "Confirmed"
}
}
```
次の点に注意してください。
+ `invocationSource` – Amazon Lex は今回は、この値を `FulfillmentCodeHook` に設定して、インテントを達成するように Lambda 関数に指示しています。
+ `confirmationStatus` – `Confirmed` に設定されます。
1. 今回、Lambda 関数は `OrderFlowers` インテントを達成し、次のレスポンスを返します。
```
{
"sessionAttributes": {
"Price": "25"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
}
}
}
```
次の点に注意してください。
+ `dialogAction.type` を設定する – Lambda 関数はこの値を `Close` に設定し、ユーザーの応答を想定しないことを Amazon Lex に指示しています。
+ `dialogAction.fulfillmentState` – Fulfilled に設定されていて、ユーザーに伝える適切なメッセージ (`message`) が含まれています。
1. Amazon Lex は `fulfillmentState` を確認し、以下のレスポンスをクライアントに返します。
Amazon Lex は以下のメッセージをクライアントに返しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs-1-details-48.png)
以下の点に注意してください。
+ `dialogState` – Amazon Lex はこの値を `fulfilled` に設定しています。
+ `message` – Lambda 関数が提供したのと同じメッセージです。
クライアントはそのメッセージを表示します。
1. ここで、ボットをもう一度テストします。新しい (ユーザー) コンテキストを確立するには、テストウィンドウの [**Clear**] リンクを選択します。ここでは、`OrderFlowers` インテントに対して無効なスロットデータを指定します。Lambda 関数は今回は、データ検証を実行し、無効なスロットデータ値を null にリセットし、有効なデータをユーザーに求めるように Amazon Lex に依頼します。例えば、以下のことを試してみます。
+ 花の種類として「Jasmine」 (サポートされている花の種類ではない)
+ 花をピックアップする日付として「昨日」
+ 注文した後で、注文の確認に対して「はい」と応答する代わりに、花の種類を入力します。それに対して、Lambda 関数は、花の注文の現在の合計はそのままにして、セッション属性内の `Price` を更新します。
Lambda 関数はフルフィルメントアクティビティも実行します。
**次のステップ**
[ステップ 6: インテント設定を更新して発話を追加する (コンソール)](gs-bp-utterance.md)
# ステップ 6: インテント設定を更新して発話を追加する (コンソール)
`OrderFlowers` ボットには、2 つの発話のみが設定されています。これは、機械学習モデルを構築して、ユーザーのインテントを認識し応答するための制限された情報を Amazon Lex に提供します。次のテストウィンドウに「I want to order flowers」と入力してみてください。Amazon Lex は、このテキストを認識しないため、「I didn't understand you, what would you like to do?」と応答します。発話を追加することで、機械学習モデルを改善できます。
![\[認識されなかった発話を示すテストウィンドウ\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-120.png)
発話を追加するたびに Amazon Lex でユーザーに応答する方法に関する情報が増えます。正確な発話を追加する必要はありません。Amazon Lex は、提供されたサンプルから一般化を行い、正確な一致および類似する入力の両方を認識します。
**発話を追加するには (コンソール)**
1. 次の画像のように、インテントエディタの **[サンプル発話]** セクションに「I want flowers」と入力して発話をインテントに追加し、この新しい発話の横にあるプラスアイコンをクリックします。
![\[新しい発話を示すインテントエディタ。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-130.png)
1. ボットを構築して変更を反映します。[**Build**] を選択し、再度 [**Build**] を選択します。
1. ボットをテストし、新しい発話が認識されたことを確認します。次の画像のように、テストウィンドウに「I want to order flowers」と入力します。Amazon Lex は、この句を認識し、「What type of flowers would you like to order?」と応答します。
![\[新しい発話を認識するインテントエディタ。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-140.png)
**次のステップ**
[ステップ 7 (オプション): クリーンアップする (コンソール)](gs-bp-cleaning-up.md)
# ステップ 7 (オプション): クリーンアップする (コンソール)
次に、作成したリソースを削除し、アカウントをクリーンアップします。
削除できるのは、使用中ではないリソースだけです。通常は、以下の順序でリソースを削除する必要があります。
+ ボットを削除して、インテントのリソースを解放します。
+ インテントを削除して、スロットタイプのリソースを解放します。
+ 最後にスロットタイプを削除します。
**アカウントをクリーンアップするには (コンソール)**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。
1. ボットのリストで、[**OrderFlowers**] の横にあるチェックボックスをオンにし ます。
1. ボットを削除するには、[**Delete**] を選択し、確認ダイアログボックスで [**Continue**] を選択します。
1. 左のペインで [**Intents**] を選択します。
1. インテントのリストで、[**OrderFlowersIntent**] を選択します。
1. インテントを削除するには、[**Delete**] を選択し、確認ダイアログボックスで [**Continue**] を選択します。
1. 左のペインで、[**Slot types**] を選択します。
1. スロットタイプのリストで、[**Flowers**] を選択します。
1. スロットタイプを削除するには、[**Delete**] を選択し、確認ダイアログボックスで [**Continue**] を選択します。
これで、作成したすべてのAmazon Lex リソースが削除され、アカウントがクリーンアップされました。必要に応じて、[Lambda コンソール](https://console.aws.amazon.com/lambda)を使用して、この演習で使用した Lambda 関数を削除します。
# 演習 2: Amazon Lex のカスタムボットを作成する
この演習では、Amazon Lex コンソールを使用してピザを注文するカスタムボット (`OrderPizzaBot`) を作成します。このボットを設定するには、カスタムインテント (`OrderPizza`) の追加、カスタムスロットタイプの定義、スロットの定義を通じて、ピザの注文 (ピザのクラストやサイズなど) を処理します。スロットタイプとスロットの詳細については、「[Amazon Lex: 仕組み](how-it-works.md)」を参照してください。
**Topics**
+ [ステップ 1: Lambda 関数を作成する](gs2-prepare.md)
+ [ステップ 2: ボットを作成する](gs2-create-bot.md)
+ [ステップ 3: ボットを構築してテストする](gs2-build-and-test.md)
+ [ステップ 4 (オプション): クリーンアップする](gs2-clean-up.md)
# ステップ 1: Lambda 関数を作成する
最初に、ピザの注文を達成する Lambda 関数を作成します。この関数は、次のセクションで作成する Amazon Lex ボットで指定します。
**Lambda 関数を作成するには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) で AWS Lambda コンソールを開きます。
1. [**Create function**] を選択します。
1. [**Create function**] ページで、[**Author from scratch**] を選択します。
この演習では、事前に用意されたカスタムコードを使用して Lambda 関数を作成します。したがって、最初から関数を作成するオプションを選択します。
以下の操作を実行します。
1. 名前 (`PizzaOrderProcessor`) を入力します。
1. [**ランタイム**] で、最新バージョンの Node.js を選択します。
1. [**Role**] で、[**Create a new role from template(s)**] を選択します。
1. 新しいロール名 (`PizzaOrderProcessorRole`) を入力します。
1. [**関数の作成**] を選択してください。
1. [関数] ページで、以下の作業を行います。
[**Function code**] セクションで、[**Edit code inline**] を選択し、次の Node.js 関数コードをコピーしてウィンドウに貼り付けます。
```
'use strict';
// Close dialog with the customer, reporting fulfillmentState of Failed or Fulfilled ("Thanks, your pizza will arrive in 20 minutes")
function close(sessionAttributes, fulfillmentState, message) {
return {
sessionAttributes,
dialogAction: {
type: 'Close',
fulfillmentState,
message,
},
};
}
// --------------- Events -----------------------
function dispatch(intentRequest, callback) {
console.log(`request received for userId=${intentRequest.userId}, intentName=${intentRequest.currentIntent.name}`);
const sessionAttributes = intentRequest.sessionAttributes;
const slots = intentRequest.currentIntent.slots;
const crust = slots.crust;
const size = slots.size;
const pizzaKind = slots.pizzaKind;
callback(close(sessionAttributes, 'Fulfilled',
{'contentType': 'PlainText', 'content': `Okay, I have ordered your ${size} ${pizzaKind} pizza on ${crust} crust`}));
}
// --------------- Main handler -----------------------
// Route the incoming request based on intent.
// The JSON body of the request is provided in the event slot.
export const handler = (event, context, callback) => {
try {
dispatch(event,
(response) => {
callback(null, response);
});
} catch (err) {
callback(err);
}
};
```
1. **[保存]** を選択します。
## サンプルイベントデータを使用した Lambda 関数のテスト
コンソールで、サンプルイベントデータを使用して手動で Lambda 関数を呼び出すことで、この関数をテストします。
**Lambda 関数をテストするには:**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) で AWS Lambda コンソールを開きます。
1. **[Lambda function]** ページで、[Lambda function] (Lambda 関数) (`PizzaOrderProcessor).`) を選択します。
1. 関数のページで、テストイベントのリストから [**Configure test events**] を選択します。
1. [**Configure test event**] ページで、以下の操作を行います。
1. **Create new test event**を選択します。
1. [**Event name**] フィールドに、イベント名 (`PizzaOrderProcessorTest`) を入力します。
1. 次の Amazon Lex イベントをウィンドウ内にコピーします。
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "user-1",
"sessionAttributes": {},
"bot": {
"name": "PizzaOrderingApp",
"alias": "$LATEST",
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderPizza",
"slots": {
"size": "large",
"pizzaKind": "meat",
"crust": "thin"
},
"confirmationStatus": "None"
}
}
```
1. **[作成]** を選択します。
AWS Lambda はテストを作成し、関数ページに戻ります。**[Test]** (テスト) を選択すると、Lambda 関数が実行されます。
結果ボックスで、[**Details**] を選択します。コンソールの [**Execution result**] ペインに、次の出力が表示されます。
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Okay, I have ordered your large meat pizza on thin crust."
}
}
```
## 次のステップ
[ステップ 2: ボットを作成する](gs2-create-bot.md)
# ステップ 2: ボットを作成する
このステップでは、ピザの注文を処理するボットを作成します。
**Topics**
+ [ボットの作成](gs2-create-bot-create.md)
+ [インテントの作成](gs2-create-bot-intent.md)
+ [スロットタイプの作成](gs2-create-bot-slot-types.md)
+ [インテントの設定](gs2-create-bot-configure-intent.md)
+ [ボットの設定](gs2-create-bot-configure-bot.md)
# ボットの作成
必要最低限の情報を使用して `PizzaOrderingBot` ボットを作成します。後で、このボットにインテント (ユーザーが実行するアクション) を追加します。
**ボットを作成するには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。
1. ボットを作成します。
1. 初めてボットを作成する場合は、[**Get Started**] を選択します。それ以外の場合は、[**Bots**]、[**Create**] の順に選択します。
1. [**Create your Lex bot**] ページで、[**Custom bot**] を選択して、以下の情報を指定します。
+ **Bot name**: PizzaOrderingBot
+ **言語**: ボットの言語とロケールを選択します。
+ **Output voice**: Salli
+ **Session timeout**: 5 分
+ **COPPA**: 適切なレスポンスを選択します。
+ **ユーザーの発話ストレージ: 適切なレスポンスを選択します。**
1. **[作成]** を選択します。
コンソールから Amazon Lex に新しいボットを作成するためのリクエストが送信されます。Amazon Lex でボットバージョンが `$LATEST` に設定されます。ボットの作成後に、次の画像に示すように、Amazon Lex に **[エディタ]** タブが表示されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-20.png)
+ ボットバージョンの [**Latest**] は、コンソールでボット名の横に表示されます。Amazon Lex の新しいリソースのバージョンは `$LATEST` になります。詳細については、「[バージョニングとエイリアス](versioning-aliases.md)」を参照してください。
+ インテントやスロットタイプはまだ作成していないため、何も表示されません。
+ [**Build**] および [**Publish**] は、ボットレベルのアクティビティです。ボット全体を設定した後で、これらのアクティビティについて詳しく説明します。
## 次のステップ
[インテントの作成](gs2-create-bot-intent.md)
# インテントの作成
次に、ユーザーが実行するアクションである `OrderPizza` インテントを必要最小限の情報で作成します。インテントのスロットタイプを追加し、後でインテントを設定します。
**インテントを作成するには**
1. Amazon Lex コンソールで、**[Intents]** (インテント) の横にあるプラス記号 (\$1) を選択し、**[Create new intent]** (新しいインテントの作成) を選択します。
1. [**Create intent**] ダイアログボックスに、インテントの名前 (`OrderPizza`) を入力し、[**Add**] を選択します。
コンソールは `OrderPizza` インテントを作成するために Amazon Lex にリクエストを送信します。この例では、スロットタイプの作成後にインテントのスロットを作成します。
## 次のステップ
[スロットタイプの作成](gs2-create-bot-slot-types.md)
# スロットタイプの作成
`OrderPizza` インテントで使用するスロットタイプ (パラメータ値) を作成します。
**スロットタイプを作成するには**
1. 左のメニューで、[**Slot types**] の横にあるプラス記号 (\$1) を選択します。
1. [**Add slot type**] ダイアログボックスで、以下を追加します。
+ [**Slot type name**] – Crusts
+ [**Description**] – Available crusts
+ [**Restrict to Slot values and Synonyms**] を選択します。
+ **[Value]** (値) - タイプ **thick**。タブを押して、**[Synonym]** フィールドに「**stuffed**」と入力します。プラス記号 (\$1) を選択します。「**thin**」と入力し、再びプラス記号 (\$1) を選択します。
ダイアログは以下の画像のようになります。
![\[スロットタイプの編集ダイアログボックス。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-25a.png)
1. [**Add slot to intent**] を選択します。
1. [**Intent**] ページで、[**Required**] を選択します。スロット名を「**slotOne**」から「**crust**」に変更します。プロンプトを **What kind of crust would you like?** に変更します。
1. 次の表の値を使用して [Step 1](#slotTypeStart)〜[Step 4](#slotTypeFinish) を繰り返します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/gs2-create-bot-slot-types.html)
## 次のステップ
[インテントの設定](gs2-create-bot-configure-intent.md)
# インテントの設定
ユーザーのピザ注文のリクエストを処理するように `OrderPizza` インテントを設定します。
**インテントを設定するには**
+ [**OrderPizza**] 設定ページで、次のようにインテントを設定します。
+ **Sample utterances** – 以下の文字列を入力します。中括弧 \$1\$1 にはスロット名が入ります。
+ ピザを注文したいです
+ ピザを注文します
+ \$1pizzaKind\$1 ピザを注文します
+ \$1size\$1 \$1pizzaKind\$1 ピザを注文します
+ \$1size\$1 \$1crust\$1 クラストの \$1pizzaKind\$1 ピザをください
+ ピザをください
+ \$1pizzaKind\$1 ピザをください
+ \$1size\$1 \$1pizzaKind\$1 ピザをください
+ **Lambda initialization and validation** – デフォルト設定のままにします。
+ **Confirmation prompt** – デフォルト設定のままにします。
+ **フルフィルメント** - 以下のタスクを実行します。
+ **AWS Lambda 関数** を選択します。
+ **PizzaOrderProcessor** を選択します。
+ **[Add permission to Lambda function]** (Lambda 関数に許可を追加する) ダイアログボックスが表示されている場合は、**[OK]** を選択して `OrderPizza` インテントに Lambda 関数 `PizzaOrderProcessor` を呼び出すアクセス許可を付与します。
+ [**None**] は選択したままにします。
インテントは次のようになります。
![\[インテントエディタ。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-70c.png)
## 次のステップ
[ボットの設定](gs2-create-bot-configure-bot.md)
# ボットの設定
`PizzaOrderingBot` ボットのエラー処理を設定します。
1. `PizzaOrderingBot` ボットに移動します。**[エディタ]** を選択し、次の画像のように **[エラー処理]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-80.png)
1. [**Editor**] タブを使用してボットのエラー処理を設定します。
+ [**Clarification Prompts**] (明確化プロンプト) で指定する情報は、ボットの [[clarificationPrompt](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-clarificationPrompt)] 設定にマッピングされます。
Amazon Lex がユーザーのインテントを判断できない場合、サービスはこのメッセージを付けてレスポンスを返します。
+ [**Hang-up phrase**] (中断フレーズ) で指定する情報は、ボットの [[abortStatement](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-abortStatement)] 設定にマッピングされます。
一連のリクエストを受信した後に、サービスがユーザーのインテントを判断できない場合、Amazon Lex はこのメッセージを付けてレスポンスを返します。
デフォルト値はそのままにしておきます。
## 次のステップ
[ステップ 3: ボットを構築してテストする](gs2-build-and-test.md)
# ステップ 3: ボットを構築してテストする
ボットを構築およびテストして、ボットが動作することを確認します。
**ボットを構築してテストするには**
1. `PizzaOrderingBot` ボットを構築するには、[**Build**] を選択します。
Amazon Lex はボットの機械学習モデルを構築します。ボットをテストする場合、コンソールではランタイム API を使用してユーザー入力を Amazon Lex に返します。Amazon Lex は機械学習モデルを使用してそのユーザー入力を解釈します。
構築が完了するまでには時間がかかることがあります。
1. ボットをテストするには、**[Test Bot]** (ボットのテスト) ウィンドウで、Amazon Lex ボットとの通信を開始します。
+ 例えば、次のように言うか、入力します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-110.png)
+ `OrderPizza` インテントで設定したサンプル発話を使用してボットをテストします。例えば、以下は `PizzaOrder` インテントに設定したサンプル発話の 1 つです。
```
I want a {size} {crust} crust {pizzaKind} pizza
```
これをテストするには、次のように入力します。
```
I want a large thin crust cheese pizza
```
「ピザを注文します」と入力すると、Amazon Lex はそのインテント (`OrderPizza`) を検出します。次に、Amazon Lex からスロット情報の入力を求められます。
すべてのスロット情報を指定すると、Amazon Lex はインテントに設定した Lambda 関数を呼び出します。
Lambda 関数はメッセージ (「かしこまりました。お客様の ... を注文いたしました」) を Amazon Lex に返し、Amazon Lex によって返信されます。
## レスポンスの検査
チャットウィンドウの下のペインで、Amazon Lex からのレスポンスを検査できます。このペインには、ボットとのやり取りに応じて変わるボットの状態に関する全体情報が表示されます。ペインの情報は、オペレーションの現在の状態を示します。
+ **Dialog State** – ユーザーとの会話の現在の状態。`ElicitIntent`、`ElicitSlot`、`ConfirmIntent`、`Fulfilled` のいずれかになります。
+ **Summary** – ダイアログの簡素化されたビューであり、処理対象のインテントのスロット値が表示されます。これにより、情報フローを追跡できます。インテント名、スロット総数と入力済みスロット数、すべてのスロットおよび関連値の一覧が表示されます。次の画像を参照してください。
![\[Amazon Lex コンソールのレスポンスの概要検査ペイン。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-115.png)
+ **Detail** – chatbot の未加工の JSON レスポンスを表示します。これにより、chatbot のテストとデバッグを行う際に、ボットとのやり取りやダイアログの現在の状態をより深く把握できます。チャットウィンドウに入力すると、検査ペインに [PostText](API_runtime_PostText.md) オペレーションからの JSON レスポンスが表示されます。チャットウィンドウに話しかけると、検査ペインに [PostContent](API_runtime_PostContent.md) オペレーションからのレスポンスヘッダーが表示されます。次の画像を参照してください。
![\[コンソールのレスポンス検査ペイン。\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs1-116.png)
## 次のステップ
[ステップ 4 (オプション): クリーンアップする](gs2-clean-up.md)
# ステップ 4 (オプション): クリーンアップする
作成したリソースを削除してアカウントをクリーンアップし、作成したリソースに対して料金が発生しないようにします。
削除できるのは、使用中ではないリソースだけです。例えば、インテントによって参照されているスロットは削除できません。ボットによって参照されているインテントは削除できません。
次の順序でリソースを削除します。
+ ボットを削除して、インテントのリソースを解放します。
+ インテントを削除して、スロットタイプのリソースを解放します。
+ 最後にスロットタイプを削除します。
**アカウントをクリーンアップするには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。
1. ボットのリストから [**PizzaOrderingBot**] を選択します。
1. ボットを削除するには、[**Delete**]、[**Continue**] の順に選択します。
1. 左のペインで [**Intents**] を選択します。
1. インテントのリストで、[**OrderPizza**] を選択します。
1. インテントを削除するには、[**Delete**]、[**Continue**] の順に選択します。
1. 左のメニューで、[**Slot types**] を選択します。
1. スロットタイプのリストで、[**Crusts**] を選択します。
1. スロットタイプを削除するには、[**Delete**]、[**Continue**] の順に選択します。
1. [`Sizes`] と [`PizzaKind`] の各スロットタイプで、「[Step 8](#chooseSlots)」と「[Step 9](#deleteSlots)」を繰り返します。
これで、作成したすべてのリソースが削除され、アカウントがクリーンアップされました。
## 次のステップ
+ [バージョンを発行してエイリアスを作成する](https://docs.aws.amazon.com/lex/latest/dg/gettingstarted-ex3.html)
+ [を使用して Amazon Lex ボットを作成する AWS Command Line Interface](https://docs.aws.amazon.com/lex/latest/dg/gs-cli.html)
# 演習 3: バージョンを発行してエイリアスを作成する
「開始方法」の演習 1 と 2 で、ボットを作成してテストしました。この演習では、以下のことを行います。
+ ボットの新しいバージョンを発行します。Amazon Lex では、`$LATEST` バージョンのスナップショットを作成して新しいバージョンを発行します。
+ 新しいバージョンを指すエイリアスを作成します。
バージョニングとエイリアスの詳細については、「[バージョニングとエイリアス](versioning-aliases.md)」を参照してください。
以下の手順に従って、この演習で作成したボットのバージョンを発行します。
1. Amazon Lex コンソールで、作成したボットの 1 つを選択します。
コンソールで、ボット名の横にボットバージョンとして `$LATEST` と表示されていることを確認します。
1. **[発行]** を選択します。
1. **[Publish *botname*]** (ボット名の発行) ウィザードで、エイリアス (**BETA**) を指定し、[**発行**] を選択します。
1. 次の画像のように、Amazon Lex コンソールでボット名の横に新しいバージョンが表示されていることを確認します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lex/latest/dg/images/gs2-final.png)
これでバージョンとエイリアスが発行されてボットが動作するようになったので、ボットをデプロイできます (モバイルアプリケーションでデプロイするか、ボットを Facebook Messenger と統合します)。例については、「[Amazon Lex ボットと Facebook Messenger の統合](fb-bot-association.md)」を参照してください。
# ステップ 4: ご利用開始にあたって (AWS CLI)
このステップでは、 AWS CLI を使用して Amazon Lex ボットを作成、テスト、変更します。以下の演習を行うには、CLI の使い方を知っている必要があります。また、テキストエディタが必要です。詳細については、「[ステップ 2: をセットアップする AWS Command Line Interface](gs-set-up-cli.md)」を参照してください。
+ 演習 1 - Amazon Lex ボットを作成してテストします。この演習では、カスタムスロットタイプ、インテント、およびボットを作成するために必要なすべての JSON オブジェクトを提供します。詳細については、「[Amazon Lex: 仕組み](how-it-works.md)」を参照してください。
+ 演習 2 - 演習 1 で作成したボットを更新し、新しいサンプル発話を追加します。Amazon Lex でサンプル発話を使用し、ボットの機械学習モデルを構築します。
+ 演習 3 - 演習 1 で作成したボットを更新し、ユーザー入力を検証してインテントを達成するための Lambda 関数を追加します。
+ 演習 4 - 演習 1 で作成したスロットタイプ、インテント、およびボットリソースのバージョンを発行します。バージョンは、リソースの変更できないスナップショットです。
+ 演習 5 - 演習 1 で作成したボットのエイリアスを作成します。
+ 演習 6 - 演習 1 で作成したスロットタイプ、インテント、ボットおよび演習 5 で作成したエイリアスを削除し、アカウントをクリーンアップします。
**Topics**
+ [演習 1: Amazon Lex ボットを作成する (AWS CLI)](gs-cli-create.md)
+ [演習 2: 新しい発話を追加する (AWS CLI)](gs-cli-update-utterance.md)
+ [演習 3: Lambda 関数を追加する (AWS CLI)](gs-cli-update-lambda.md)
+ [演習 4: バージョンを発行する (AWS CLI)](gs-cli-publish.md)
+ [演習 5: エイリアスを作成する (AWS CLI)](gs-cli-create-alias.md)
+ [演習 6: クリーンアップする (AWS CLI)](gs-cli-clean-up.md)
# 演習 1: Amazon Lex ボットを作成する (AWS CLI)
通常、ボットを作成するときは、以下のことを行います。
1. スロットタイプを作成し、ボットで扱う情報を定義します。
1. インテントを作成し、ボットでサポートするユーザーアクションを定義します。前に作成したカスタムスロットタイプを使用し、インテントに必要なスロット (パラメータ) を定義します。
1. 定義したインテントを使用するボットを作成します。
この演習では、CLI を使用して新しい Amazon Lex ボットを作成してテストします。ボットの作成には、用意されている JSON 構造を使用します。この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**Topics**
+ [ステップ 1: サービスにリンクされたロールを作成する (AWS CLI)](gs-create-role.md)
+ [ステップ 2: カスタムスロットタイプを作成する (AWS CLI)](gs-create-flower-types.md)
+ [ステップ 3: インテントを作成する (AWS CLI)](gs-cli-create-order-flowers.md)
+ [ステップ 4: ボットを作成する (AWS CLI)](gs-cli-create-order-flowers-bot.md)
+ [ステップ 5: ボットをテストする (AWS CLI)](gs-create-test.md)
# ステップ 1: サービスにリンクされたロールを作成する (AWS CLI)
Amazon Lex は AWS Identity and Access Management 、ボットに代わって AWS サービスを呼び出すサービスにリンクされたロールを引き受けます。ロールは、アカウント内で Amazon Lex ユースケースにリンクされ、アクセス権限が事前に定義されています。詳細については、「[Amazon Lex のサービスリンクロールの使用](using-service-linked-roles.md)」を参照してください。
コンソールで Amazon Lex ボットを作成済みである場合、サービスにリンクされたロールは自動的に作成されています。「[ステップ 2: カスタムスロットタイプを作成する (AWS CLI)](gs-create-flower-types.md)」へ進んでください。
**サービスリンクロールの作成 (AWS CLI)**
1. で AWS CLI、次のコマンドを入力します。
```
aws iam create-service-linked-role --aws-service-name lex.amazonaws.com
```
1. 次のコマンドを使用してポリシーをチェックします。
```
aws iam get-role --role-name AWSServiceRoleForLexBots
```
レスポンスは次のとおりです。
## 次のステップ
[ステップ 2: カスタムスロットタイプを作成する (AWS CLI)](gs-create-flower-types.md)
# ステップ 2: カスタムスロットタイプを作成する (AWS CLI)
カスタムスロットタイプを作成し、注文できる花の種類を列挙値とします。次のステップで `OrderFlowers` インテントを作成するときに、このタイプを使用します。*スロットタイプ*は、インテントのスロット (パラメータ) に指定できる値を定義します。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**カスタムスロットタイプを作成するには (AWS CLI)**
1. **FlowerTypes.json** という名前のテキストファイルを作成します。このテキストファイル内に [FlowerTypes.json](gs-cli-create-flower-types-json.md) の JSON コードをコピーします。
1. を使用して [PutSlotType](API_PutSlotType.md)オペレーションを呼び出し AWS CLI 、スロットタイプを作成します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws lex-models put-slot-type \
--region region \
--name FlowerTypes \
--cli-input-json file://FlowerTypes.json
```
サーバーからのレスポンスは次のとおりです。
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"checksum": "checksum",
"version": "$LATEST",
"lastUpdatedDate": timestamp,
"createdDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## 次のステップ
[ステップ 3: インテントを作成する (AWS CLI)](gs-cli-create-order-flowers.md)
# FlowerTypes.json
次のコードは、`FlowerTypes` カスタムスロットタイプを作成するために必要な JSON データです。
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"description": "Types of flowers to pick up"
}
```
# ステップ 3: インテントを作成する (AWS CLI)
`OrderFlowersBot` ボットのインテントを作成し、3 つのスロット (パラメータ) を指定します。スロットを使用することで、ボットはインテントを達成できます。
+ `FlowerType` は、注文できる花の種類を指定するカスタムスロットタイプです。
+ `AMAZON.DATE` および `AMAZON.TIME` は、花の配送日時をユーザーから取得するための組み込みスロットタイプです。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**`OrderFlowers` インテントを作成するには (AWS CLI)**
1. **OrderFlowers.json** という名前のテキストファイルを作成します。このテキストファイル内に [OrderFlowers.json](gs-cli-create-order-flowers-json.md) の JSON コードをコピーします。
1. で AWS CLI、 [PutIntent](API_PutIntent.md)オペレーションを呼び出してインテントを作成します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers.json
```
サーバーは以下のように応答します。
## 次のステップ
[ステップ 4: ボットを作成する (AWS CLI)](gs-cli-create-order-flowers-bot.md)
# OrderFlowers.json
次のコードは、`OrderFlowers` インテントを作成するために必要な JSON データです。
```
{
"confirmationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}. Does this sound okay?",
"contentType": "PlainText"
}
]
},
"name": "OrderFlowers",
"rejectionStatement": {
"messages": [
{
"content": "Okay, I will not place your order.",
"contentType": "PlainText"
}
]
},
"sampleUtterances": [
"I would like to pick up flowers",
"I would like to order some flowers"
],
"slots": [
{
"slotType": "FlowerTypes",
"name": "FlowerType",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What type of flowers would you like to order?",
"contentType": "PlainText"
}
]
},
"priority": 1,
"slotTypeVersion": "$LATEST",
"sampleUtterances": [
"I would like to order {FlowerType}"
],
"description": "The type of flowers to pick up"
},
{
"slotType": "AMAZON.DATE",
"name": "PickupDate",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What day do you want the {FlowerType} to be picked up?",
"contentType": "PlainText"
}
]
},
"priority": 2,
"description": "The date to pick up the flowers"
},
{
"slotType": "AMAZON.TIME",
"name": "PickupTime",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "Pick up the {FlowerType} at what time on {PickupDate}?",
"contentType": "PlainText"
}
]
},
"priority": 3,
"description": "The time to pick up the flowers"
}
],
"fulfillmentActivity": {
"type": "ReturnIntent"
},
"description": "Intent to order a bouquet of flowers for pick up"
}
```
# ステップ 4: ボットを作成する (AWS CLI)
`OrderFlowersBot` ボットには、1 つのインテント (前のステップで作成した `OrderFlowers` インテント) があります。この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更してください。
**`OrderFlowersBot` ボットを作成するには (AWS CLI)**
1. **OrderFlowersBot.json** という名前のテキストファイルを作成します。このテキストファイル内に [OrderFlowersBot.json](gs-cli-create-order-flowers-bot-json.md) の JSON コードをコピーします。
1. で AWS CLI、 [PutBot](API_PutBot.md)オペレーションを呼び出してボットを作成します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot.json
```
サーバーからのレスポンスは次のとおりです。ボットを作成または更新すると、`status` フィールドは `BUILDING` に設定されます。これは、ボットの使用準備が整っていないことを示します。ボットの使用準備が整ったことを確認するには、次のステップで [GetBot](API_GetBot.md) オペレーションを使用します。
1. 新しいボットの使用準備が整っているかどうかを確認するには、次のコマンドを実行します。`status` フィールドから `READY` が返されるまで、このコマンドを繰り返します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST"
```
レスポンス内で `status` フィールドを探します。
```
{
"status": "READY",
...
}
```
## 次のステップ
[ステップ 5: ボットをテストする (AWS CLI)](gs-create-test.md)
# OrderFlowersBot.json
次のコードは、Amazon Lex ボット `OrderFlowers` の構築に必要な JSON データを示しています。
```
{
"intents": [
{
"intentVersion": "$LATEST",
"intentName": "OrderFlowers"
}
],
"name": "OrderFlowersBot",
"locale": "en-US",
"abortStatement": {
"messages": [
{
"content": "Sorry, I'm not able to assist at this time",
"contentType": "PlainText"
}
]
},
"clarificationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "I didn't understand you, what would you like to do?",
"contentType": "PlainText"
}
]
},
"voiceId": "Salli",
"childDirected": false,
"idleSessionTTLInSeconds": 600,
"description": "Bot to order flowers on the behalf of a user"
}
```
# ステップ 5: ボットをテストする (AWS CLI)
ボットをテストするには、テキストベースまたは音声ベースのテストを使用できます。
**Topics**
+ [テキスト入力を使用してテストする (AWS CLI)](gs-create-test-text.md)
+ [音声入力を使用してボットをテストする (AWS CLI)](gs-create-test-speech.md)
# テキスト入力を使用してテストする (AWS CLI)
テキスト入力でボットが正しく動作することを確認するには、[PostText](API_runtime_PostText.md) オペレーションを使用します。この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[ランタイム Service Quotas](gl-limits.md#gl-limits-runtime)」を参照してください。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**テキストを使用してボットをテストするには (AWS CLI)**
1. で AWS CLI、`OrderFlowersBot`ボットとの会話を開始します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "i would like to order flowers"
```
Amazon Lex は、ユーザーのインテントを認識し、次のレスポンスを返すことで会話を開始します。
```
{
"slotToElicit": "FlowerType",
"slots": {
"PickupDate": null,
"PickupTime": null,
"FlowerType": null
},
"dialogState": "ElicitSlot",
"message": "What type of flowers would you like to order?",
"intentName": "OrderFlowers"
}
```
1. 以下のコマンドを実行して、ボットとの会話を終了します。
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "roses"
```
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "tuesday"
```
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot --bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "10:00 a.m."
```
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "yes"
```
注文を確認すると、Amazon Lex はフルフィルメントレスポンスを送信して会話を完了します。
```
{
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
},
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers"
}
```
## 次のステップ
[音声入力を使用してボットをテストする (AWS CLI)](gs-create-test-speech.md)
# 音声入力を使用してボットをテストする (AWS CLI)
音声ファイルを使用してボットをテストするには、[PostContent](API_runtime_PostContent.md) オペレーションを使用します。音声ファイルは、Amazon Polly テキスト読み上げ機能のオペレーションを使用して生成します。
この演習のコマンドを実行するには、Amazon Lex および Amazon Polly コマンドが実行されるリージョンを確認しておく必要があります。Amazon Lex のリージョンのリストについては「[ランタイム Service Quotas](gl-limits.md#gl-limits-runtime)」を参照してください。Amazon Polly でサポートされているリージョンとエンドポイントの一覧については、*Amazon Web Services 全般のリファレンス*の「[AWS リージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region)」を参照してください。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**音声入力を使用してボットをテストするには (AWS CLI)**
1. で AWS CLI、Amazon Polly を使用してオーディオファイルを作成します。例は、Unix、Linux、および macOS 用にフォーマットされています。Windows の場合は、各行末のバックスラッシュ (\$1) Unix 連結文字をキャレット (^) に置き換えてください。
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "i would like to order flowers" \
--voice-id "Salli" \
IntentSpeech.mpg
```
1. 音声ファイルを Amazon Lex に送信するには、次のコマンドを実行します。Amazon Lex は、レスポンスの音声を指定の出力ファイルに保存します。
```
aws lex-runtime post-content \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--content-type "audio/l16; rate=16000; channels=1" \
--input-stream IntentSpeech.mpg \
IntentOutputSpeech.mpg
```
Amazon Lex は、レスポンスで最初のスロットをリクエストします。音声レスポンスは指定の出力ファイルに保存されます。
```
{
"contentType": "audio/mpeg",
"slotToElicit": "FlowerType",
"dialogState": "ElicitSlot",
"intentName": "OrderFlowers",
"inputTranscript": "i would like to order some flowers",
"slots": {
"PickupDate": null,
"PickupTime": null,
"FlowerType": null
},
"message": "What type of flowers would you like to order?"
}
```
1. バラの花束を注文するには、次の音声ファイルを作成して Amazon Lex に送信します。
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "roses" \
--voice-id "Salli" \
FlowerTypeSpeech.mpg
```
```
aws lex-runtime post-content \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--content-type "audio/l16; rate=16000; channels=1" \
--input-stream FlowerTypeSpeech.mpg \
FlowerTypeOutputSpeech.mpg
```
1. 配達日を設定するには、次の音声ファイルを作成して Amazon Lex に送信します:
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "tuesday" \
--voice-id "Salli" \
DateSpeech.mpg
```
```
aws lex-runtime post-content \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--content-type "audio/l16; rate=16000; channels=1" \
--input-stream DateSpeech.mpg \
DateOutputSpeech.mpg
```
1. 配送時間を設定するには、次の音声ファイルを作成して Amazon Lex に送信します:
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "10:00 a.m." \
--voice-id "Salli" \
TimeSpeech.mpg
```
```
aws lex-runtime post-content \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--content-type "audio/l16; rate=16000; channels=1" \
--input-stream TimeSpeech.mpg \
TimeOutputSpeech.mpg
```
1. 配達を確認するには、次の音声ファイルを作成して Amazon Lex に送信します。
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "yes" \
--voice-id "Salli" \
ConfirmSpeech.mpg
```
```
aws lex-runtime post-content \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--content-type "audio/l16; rate=16000; channels=1" \
--input-stream ConfirmSpeech.mpg \
ConfirmOutputSpeech.mpg
```
配達を確認すると、Amazon Lex からインテントの達成を確認するレスポンスが送信されます。
```
{
"contentType": "text/plain;charset=utf-8",
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers",
"inputTranscript": "yes",
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
}
}
```
## 次のステップ
[演習 2: 新しい発話を追加する (AWS CLI)](gs-cli-update-utterance.md)
# 演習 2: 新しい発話を追加する (AWS CLI)
ユーザーからのリクエストを認識するために Amazon Lex が使用する機械学習モデルを向上するには、別のサンプル発話をボットに追加します。
新しい発話を追加するには 4 つのステップを使用します。
1. [GetIntent](API_GetIntent.md) オペレーションを使用して Amazon Lex からインテントを取得します。
1. インテントを更新します。
1. [PutIntent](API_PutIntent.md) オペレーションを使用して、更新したインテントを Amazon Lex に送り返します。
1. [GetBot](API_GetBot.md) オペレーションと [PutBot](API_PutBot.md) オペレーションを使用して、このインテントを使用するすべてのボットを再構築します。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
`GetIntent` オペレーションからのレスポンスには、インテントの特定のリビジョンを識別する `checksum` というフィールドが含まれています。[PutIntent](API_PutIntent.md) オペレーションを使用してインテントを更新するときに、このチェックサムの値を指定する必要があります。指定しないと、次のエラーメッセージが表示されます。
```
An error occurred (PreconditionFailedException) when calling
the PutIntent operation: Intent intent name already exists.
If you are trying to update intent name you must specify the
checksum.
```
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**`OrderFlowers` インテントを更新するには (AWS CLI)**
1. で AWS CLI、Amazon Lex からインテントを取得します。Amazon Lex は **OrderFlowers-V2.json.** というファイルにこの出力を送信します。
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V2.json
```
1. テキストエディタで **OrderFlowers-V2.json** を開きます。
1. `createdDate`、`lastUpdatedDate`、`version` の各フィールドを見つけて削除します。
1. `sampleUtterances` フィールドに以下を追加します。
```
I want to order flowers
```
1. ファイルを保存します。
1. 次のコマンドを使用して、更新したインテントを Amazon Lex に送信します。
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V2.json
```
Amazon Lex から次のレスポンスが送信されます。
インテントを更新したので、このインテントを使用するすべてのボットを再構築します。
**`OrderFlowersBot` ボットを再構築するには (AWS CLI)**
1. で AWS CLI、`OrderFlowersBot`ボットの定義を取得し、次のコマンドを使用してファイルに保存します。
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V2.json
```
1. テキストエディタで **OrderFlowersBot-V2.json** を開きます。`createdDate`、`lastUpdatedDate`、`status`、`version` の各フィールドを削除します。
1. テキストエディタで、ボットの定義に次の行を追加します。
```
"processBehavior": "BUILD",
```
1. で AWS CLI、 に対して次のコマンドを実行して、ボットの新しいリビジョンを構築します。
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V2.json
```
サーバーからのレスポンスは次のとおりです。
## 次のステップ
[演習 3: Lambda 関数を追加する (AWS CLI)](gs-cli-update-lambda.md)
# 演習 3: Lambda 関数を追加する (AWS CLI)
ユーザー入力を検証し、ユーザーのインテントを達成する Lambda 関数をボットに追加します。
Lambda 表現を追加するには 5 つのステップを使用します。
1. Lambda の [AddPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html) 関数を使用して `OrderFlowers` インテントを有効にし、Lambda の [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html) オペレーションを呼び出します。
1. [GetIntent](API_GetIntent.md) オペレーションを使用して Amazon Lex からインテントを取得します。
1. Lambda 関数を追加してインテントを更新します。
1. [PutIntent](API_PutIntent.md) オペレーションを使用して、更新したインテントを Amazon Lex に送り返します。
1. [GetBot](API_GetBot.md) オペレーションと [PutBot](API_PutBot.md) オペレーションを使用して、このインテントを使用するすべてのボットを再構築します。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
`InvokeFunction` アクセス権限を追加する前に Lambda 関数をインテントに追加すると、次のエラーメッセージが表示されます。
```
An error occurred (BadRequestException) when calling the
PutIntent operation: Lex is unable to access the Lambda
function Lambda function ARN in the context of intent
intent ARN. Please check the resource-based policy on
the function.
```
`GetIntent` オペレーションからのレスポンスには、インテントの特定のリビジョンを識別する `checksum` というフィールドが含まれています。[PutIntent](API_PutIntent.md) オペレーションを使用してインテントを更新するときに、このチェックサムの値を指定する必要があります。指定しないと、次のエラーメッセージが表示されます。
```
An error occurred (PreconditionFailedException) when calling
the PutIntent operation: Intent intent name already exists.
If you are trying to update intent name you must specify the
checksum.
```
この演習では、「[演習 1: 設計図を使用して Amazon Lex ボットを作成する (コンソール)](gs-bp.md)」の Lambda 関数を使用します。この Lambda 関数を作成する手順については、「[ステップ 3: Lambda 関数を作成する (コンソール)](gs-bp-create-lambda-function.md)」を参照してください。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更してください。
**Lambda 関数をインテントに追加するには**
1. で AWS CLI、イン`OrderFlowers`テントの `InvokeFunction` アクセス許可を追加します。
```
aws lambda add-permission \
--region region \
--function-name OrderFlowersCodeHook \
--statement-id LexGettingStarted-OrderFlowersBot \
--action lambda:InvokeFunction \
--principal lex.amazonaws.com \
--source-arn "arn:aws:lex:region:account ID:intent:OrderFlowers:*"
--source-account account ID
```
Lambda から次のレスポンスが送信されます。
```
{
"Statement": "{\"Sid\":\"LexGettingStarted-OrderFlowersBot\",
\"Resource\":\"arn:aws:lambda:region:account ID:function:OrderFlowersCodeHook\",
\"Effect\":\"Allow\",
\"Principal\":{\"Service\":\"lex.amazonaws.com\"},
\"Action\":[\"lambda:InvokeFunction\"],
\"Condition\":{\"StringEquals\":
{\"AWS:SourceAccount\": \"account ID\"},
{\"AWS:SourceArn\":
\"arn:aws:lex:region:account ID:intent:OrderFlowers:*\"}}}"
}
```
1. Amazon Lex からインテントを取得します。Amazon Lex は **OrderFlowers-V3.json** というファイルにこの出力を送信します。
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V3.json
```
1. テキストエディターで **OrderFlowers-V3.json** ファイルを開きます。
1. `createdDate`、`lastUpdatedDate`、`version` の各フィールドを見つけて削除します。
1. `fulfillmentActivity` フィールドを更新します。
```
"fulfillmentActivity": {
"type": "CodeHook",
"codeHook": {
"uri": "arn:aws:lambda:region:account ID:function:OrderFlowersCodeHook",
"messageVersion": "1.0"
}
}
```
1. ファイルを保存します。
1. で AWS CLI、更新されたインテントを Amazon Lex に送信します。
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V3.json
```
インテントを更新したので、ボットを再構築します。
**`OrderFlowersBot` ボットを再構築するには**
1. で AWS CLI、`OrderFlowersBot`ボットの定義を取得し、ファイルに保存します。
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V3.json
```
1. テキストエディタで **OrderFlowersBot-V3.json** を開きます。`createdDate`、`lastUpdatedDate`、`status`、`version` の各フィールドを削除します。
1. テキストエディタで、ボットの定義に次の行を追加します。
```
"processBehavior": "BUILD",
```
1. で AWS CLI、ボットの新しいリビジョンを構築します。
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V3.json
```
サーバーからのレスポンスは次のとおりです。
## 次のステップ
[演習 4: バージョンを発行する (AWS CLI)](gs-cli-publish.md)
# 演習 4: バージョンを発行する (AWS CLI)
次に演習 1 で作成したボットのバージョンを作成します。*バージョン*は、ボットのスナップショットです。一度作成したバージョンは変更できません。ボットのバージョンで更新できるのは `$LATEST` バージョンのみです。バージョンの詳細については、「[バージョニングとエイリアス](versioning-aliases.md)」を参照してください。
ボットのバージョンを発行する前に、そのバージョンで使用しているインテントを発行する必要があります。同様に、これらのインテントで参照しているスロットタイプを発行する必要があります。通常、ボットのバージョンを発行するには、以下の操作を行ないます。
1. [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md) オペレーションを使用してスロットタイプのバージョンを発行します。
1. [CreateIntentVersion](API_CreateIntentVersion.md) オペレーションを使用してインテントのバージョンを発行します。
1. [CreateBotVersion](API_CreateBotVersion.md) オペレーションを使用してボットのバージョンを発行します。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**Topics**
+ [ステップ 1: スロットタイプを発行する (AWS CLI)](gs-cli-publish-slot-type.md)
+ [ステップ 2: インテントを発行する (AWS CLI)](gs-cli-publish-intent.md)
+ [ステップ 3: ボットを発行する (AWS CLI)](gs-cli-publish-bot.md)
# ステップ 1: スロットタイプを発行する (AWS CLI)
スロットタイプを使用するインテントのバージョンを発行する前に、そのスロットタイプのバージョンを発行する必要があります。この例では、`FlowerTypes` を発行します。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**スロットタイプを発行するには (AWS CLI)**
1. で AWS CLI、スロットタイプの最新バージョンを取得します。
```
aws lex-models get-slot-type \
--region region \
--name FlowerTypes \
--slot-type-version "\$LATEST"
```
Amazon Lex からのレスポンスは次のとおりです。`$LATEST` バージョンの最新リビジョンのチェックサムを書き留めます。
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"checksum": "checksum",
"version": "$LATEST",
"lastUpdatedDate": timestamp,
"createdDate": timestamp,
"description": "Types of flowers to pick up"
}
```
1. スロットタイプのバージョンを発行します。前のステップで書き留めたチェックサムを使用します。
```
aws lex-models create-slot-type-version \
--region region \
--name FlowerTypes \
--checksum "checksum"
```
Amazon Lex からのレスポンスは次のとおりです。次のステップのためにバージョン番号を書き留めます。
```
{
"version": "1",
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"createdDate": timestamp,
"lastUpdatedDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## 次のステップ
[ステップ 2: インテントを発行する (AWS CLI)](gs-cli-publish-intent.md)
# ステップ 2: インテントを発行する (AWS CLI)
インテントを発行する前に、そのインテントで参照しているすべてのスロットタイプを発行する必要があります。スロットタイプは、`$LATEST` バージョンではなく、番号が付いたバージョンであることが必要です。
まず、`OrderFlowers` インテントを更新し、前のステップで発行した `FlowerTypes` スロットタイプのバージョンを使用します。次に、`OrderFlowers` インテントの新しいバージョンを発行します。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**インテントのバージョンを発行するには (AWS CLI)**
1. で AWS CLI、イン`OrderFlowers`テント`$LATEST`のバージョンを取得し、ファイルに保存します。
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4.json
```
1. テキストエディタで、**OrderFlowers\$1V4.json** ファイルを開きます。`createdDate`、`lastUpdatedDate`、`version` の各フィールドを削除します。`FlowerTypes` スロットタイプを見つけ、そのバージョンを前のステップで書き留めたバージョン番号に変更します。以下は、**OrderFlowers\$1V4.json** ファイルの中で変更箇所を示す部分です。
```
{
"slotType": "FlowerTypes",
"name": "FlowerType",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What type of flowers?",
"contentType": "PlainText"
}
]
},
"priority": 1,
"slotTypeVersion": "version",
"sampleUtterances": []
},
```
1. で AWS CLI、インテントのリビジョンを保存します。
```
aws lex-models put-intent \
--name OrderFlowers \
--cli-input-json file://OrderFlowers_V4.json
```
1. インテントの最新リビジョンのチェックサムを取得します。
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4a.json
```
以下は、レスポンスの中でインテントのチェックサムを示す部分です。次のステップのために、これを書き留めます。
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "$LATEST",
```
1. インテントの新しいバージョンを発行します。
```
aws lex-models create-intent-version \
--region region \
--name OrderFlowers \
--checksum "checksum"
```
以下は、レスポンスの中でインテントの新しいバージョンを示す部分です。次のステップのためにバージョン番号を書き留めます。
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "version",
```
## 次のステップ
[ステップ 3: ボットを発行する (AWS CLI)](gs-cli-publish-bot.md)
# ステップ 3: ボットを発行する (AWS CLI)
ボットで使用しているすべてのスロットタイプとインテントを発行したら、次にボットを発行できます。
`OrderFlowersBot` ボットを更新し、前のステップで更新した `OrderFlowers` インテントを使用します。次に、`OrderFlowersBot` ボットの新しいバージョンを発行します。
**注記**
次の AWS CLI 例は、Unix、Linux、macOS 用にフォーマットされています。Windows の場合は、`"\$LATEST"` を `$LATEST` に変更し、各行末のバックスラッシュ (\$1) 連結文字をキャレット (^) に置き換えてください。
**ボットのバージョンを発行するには (AWS CLI)**
1. で AWS CLI、`OrderFlowersBot`ボット`$LATEST`のバージョンを取得し、ファイルに保存します。
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot_V4.json
```
1. テキストエディタで、**OrderFlowersBot\$1V4.json** ファイルを開きます。`createdDate`、`lastUpdatedDate`、`status`、`version` の各フィールドを削除します。`OrderFlowers` インテントを見つけ、そのバージョンを前のステップで書き留めたバージョン番号に変更します。以下は、**OrderFlowersBot\$1V4.json** の中で変更箇所を示す部分です。
```
"intents": [
{
"intentVersion": "version",
"intentName": "OrderFlowers"
}
```
1. で AWS CLI、ボットの新しいリビジョンを保存します。`put-bot` の呼び出しによって返されるバージョン番号をメモしておきます。
```
aws lex-models put-bot \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot_V4.json
```
1. ボットの最新リビジョンのチェックサムを取得します。ステップ 3 で返されたバージョン番号を使用します。
```
aws lex-models get-bot \
--region region \
--version-or-alias version \
--name OrderFlowersBot > OrderFlowersBot_V4a.json
```
以下は、レスポンス内のボットのチェックサムを示す部分です。次のステップのために、これを書き留めます。
```
"name": "OrderFlowersBot",
"locale": "en-US",
"checksum": "checksum",
```
1. ボットの新しいバージョンを発行します。
```
aws lex-models create-bot-version \
--region region \
--name OrderFlowersBot \
--checksum "checksum"
```
以下は、レスポンス内でボットの新しいバージョンを示す部分です。
```
"checksum": "checksum",
"abortStatement": {
...
},
"version": "1",
"lastUpdatedDate": timestamp,
```
## 次のステップ
[演習 5: エイリアスを作成する (AWS CLI)](gs-cli-create-alias.md)
# 演習 5: エイリアスを作成する (AWS CLI)
エイリアスはボットの特定バージョンを参照するポインタです。エイリアスを使用すると、クライアントアプリケーションで使用しているバージョンを簡単に更新できます。詳細については「[バージョニングとエイリアス](versioning-aliases.md)」をご覧ください。この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**エイリアスを作成するには (AWS CLI)**
1. で AWS CLI、 `OrderFlowersBot` で作成したボットのバージョンを取得します[演習 4: バージョンを発行する (AWS CLI)](gs-cli-publish.md)。
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias version > OrderFlowersBot_V5.json
```
1. テキストエディタで **OrderFlowersBot\$1v5.json** を開きます。バージョン番号を見つけて書き留めます。
1. で AWS CLI、ボットエイリアスを作成します。
```
aws lex-models put-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot \
--bot-version version
```
サーバーからのレスポンスは次のとおりです。
```
{
"name": "PROD",
"createdDate": timestamp,
"checksum": "checksum",
"lastUpdatedDate": timestamp,
"botName": "OrderFlowersBot",
"botVersion": "1"
}}
```
## 次のステップ
[演習 6: クリーンアップする (AWS CLI)](gs-cli-clean-up.md)
# 演習 6: クリーンアップする (AWS CLI)
作成したリソースを削除し、アカウントをクリーンアップします。
削除できるのは、使用中ではないリソースだけです。通常、以下の順序でリソースを削除します。
1. エイリアスを削除して、ボットのリソースを解放します。
1. ボットを削除して、インテントのリソースを解放します。
1. インテントを削除して、スロットタイプのリソースを解放します。
1. スロットタイプを削除します。
この演習のコマンドを実行するには、コマンドが実行されるリージョンを確認しておく必要があります。リージョンのリストについては、「[モデル構築のクォータ](gl-limits.md#gl-limits-model-building)」を参照してください。
**アカウントをクリーンアップするには (AWS CLI)**
1. AWS CLI コマンドラインで、エイリアスを削除します。
```
aws lex-models delete-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot
```
1. AWS CLI コマンドラインで、ボットを削除します。
```
aws lex-models delete-bot \
--region region \
--name OrderFlowersBot
```
1. AWS CLI コマンドラインで、インテントを削除します。
```
aws lex-models delete-intent \
--region region \
--name OrderFlowers
```
1. AWS CLI コマンドラインから、スロットタイプを削除します。
```
aws lex-models delete-slot-type \
--region region \
--name FlowerTypes
```
これで、作成したすべてのリソースが削除され、アカウントがクリーンアップされました。