Pemberitahuan akhir dukungan: Pada 15 September 2025, AWS akan menghentikan dukungan untuk Amazon Lex V1. Setelah 15 September 2025, Anda tidak lagi dapat mengakses konsol Amazon Lex V1 atau sumber daya Amazon Lex V1. Jika Anda menggunakan Amazon Lex V2, lihat [panduan Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) sebagai gantinya.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Langkah 3: Memulai (Konsol)
Cara termudah untuk mempelajari cara menggunakan Amazon Lex adalah dengan menggunakan konsol. Untuk memulai, kami membuat latihan berikut, yang semuanya menggunakan konsol:
+ Latihan 1 — Buat bot Amazon Lex menggunakan cetak biru, bot yang telah ditentukan sebelumnya yang menyediakan semua konfigurasi bot yang diperlukan. Anda hanya melakukan pekerjaan minimum untuk menguji end-to-end pengaturan.
Selain itu, Anda menggunakan cetak biru fungsi Lambda, yang disediakan oleh, AWS Lambda untuk membuat fungsi Lambda. Fungsinya adalah hook kode yang menggunakan kode yang telah ditentukan sebelumnya yang kompatibel dengan bot Anda.
+ Latihan 2 — Buat bot khusus dengan membuat dan mengonfigurasi bot secara manual. Anda juga membuat fungsi Lambda sebagai hook kode. Kode sampel disediakan.
+ Latihan 3 — Publikasikan bot, lalu buat versi baru. Sebagai bagian dari latihan ini, Anda membuat alias yang menunjuk ke versi bot.
**Topics**
+ [Latihan 1: Membuat Bot Amazon Lex Menggunakan Blueprint (Konsol)](gs-bp.md)
+ [Latihan 2: Buat Bot Amazon Lex Kustom](getting-started-ex2.md)
+ [Latihan 3: Publikasikan Versi dan Buat Alias](gettingstarted-ex3.md)
# Latihan 1: Membuat Bot Amazon Lex Menggunakan Blueprint (Konsol)
Dalam latihan ini, Anda melakukan hal berikut:
+ Buat bot Amazon Lex pertama Anda, dan uji di konsol Amazon Lex.
Untuk latihan ini, Anda menggunakan **OrderFlowers**cetak biru. Untuk informasi tentang cetak biru, lihat. [Amazon Lex dan AWS Lambda Cetak Biru](lex-lambda-blueprints.md)
+ Buat AWS Lambda fungsi dan uji di konsol Lambda. Saat memproses permintaan, bot Anda memanggil fungsi Lambda ini. Untuk latihan ini, Anda menggunakan Lambda blueprint (**lex-order-flowers-python**) yang disediakan di konsol AWS Lambda untuk membuat fungsi Lambda Anda. Kode cetak biru menggambarkan bagaimana Anda dapat menggunakan fungsi Lambda yang sama untuk melakukan inisialisasi dan validasi, dan untuk memenuhi intent. `OrderFlowers`
+ Perbarui bot untuk menambahkan fungsi Lambda sebagai pengait kode untuk memenuhi maksud. Uji end-to-end pengalamannya.
Bagian berikut menjelaskan apa yang dilakukan cetak biru.
## Amazon Lex Bot: Ikhtisar Cetak Biru
Anda menggunakan **OrderFlowers**cetak biru untuk membuat bot Amazon Lex. Untuk informasi lebih lanjut tentang struktur bot, lihat. [Amazon Lex: Cara Kerjanya](how-it-works.md) Bot sudah dikonfigurasi sebelumnya sebagai berikut:
+ **Niat** — OrderFlowers
+ **Jenis slot** — Satu jenis slot khusus yang disebut `FlowerTypes` dengan nilai enumerasi:`roses`,, `lilies` dan. `tulips`
+ **Slot** — Maksudnya membutuhkan informasi berikut (yaitu, slot) sebelum bot dapat memenuhi maksud.
+ `PickupTime`(Tipe bawaan AMAZON.TIME)
+ `FlowerType`(tipe FlowerTypes kustom)
+ `PickupDate`(Tipe bawaan AMAZON.DATE)
+ **Ucapan** - Contoh ucapan berikut menunjukkan maksud pengguna:
+ “Aku ingin mengambil bunga.”
+ “Saya ingin memesan beberapa bunga.”
+ **Prompts** — Setelah bot mengidentifikasi intent, bot menggunakan prompt berikut untuk mengisi slot:
+ Prompt untuk `FlowerType` slot — “Jenis bunga apa yang ingin Anda pesan?”
+ Prompt untuk `PickupDate` slot — “Hari apa Anda ingin \$1FlowerType\$1 diambil?”
+ Prompt untuk `PickupTime` slot — “Pada jam berapa Anda ingin \$1FlowerType\$1 diambil?”
+ Pernyataan konfirmasi — “Oke, \$1FlowerType\$1 Anda akan siap untuk diambil oleh \$1PickupTime\$1 di \$1PickupDate\$1. Apakah ini terdengar baik-baik saja?”
## AWS Lambda Fungsi: Ringkasan Cetak Biru
Fungsi Lambda dalam latihan ini melakukan tugas inisialisasi dan validasi dan pemenuhan. Oleh karena itu, setelah membuat fungsi Lambda, Anda memperbarui konfigurasi intent dengan menentukan fungsi Lambda yang sama sebagai hook kode untuk menangani tugas inisialisasi dan validasi dan pemenuhan.
+ Sebagai pengait kode inisialisasi dan validasi, fungsi Lambda melakukan validasi dasar. Misalnya, jika pengguna menyediakan waktu untuk pengambilan yang berada di luar jam kerja normal, fungsi Lambda mengarahkan Amazon Lex untuk meminta ulang pengguna untuk waktu tersebut.
+ Sebagai bagian dari hook kode pemenuhan, fungsi Lambda mengembalikan pesan ringkasan yang menunjukkan bahwa urutan bunga telah ditempatkan (yaitu, maksud terpenuhi).
**Langkah Selanjutnya**
[Langkah 1: Buat Amazon Lex Bot (Konsol)](gs-bp-create-bot.md)
# Langkah 1: Buat Amazon Lex Bot (Konsol)
Untuk latihan ini, buat bot untuk memesan bunga, yang disebut OrderFlowersBot.
Untuk membuat bot Amazon Lex (konsol)
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Jika ini adalah bot pertama Anda, pilih **Memulai**; jika tidak, pada halaman **Bots**, pilih **Buat**.
1. Pada halaman **Create your Lex bot**, berikan informasi berikut, lalu pilih **Create**.
+ Pilih **OrderFlowers**cetak biru.
+ Tinggalkan nama bot default (OrderFlowers).
+ Untuk **COPPA**, pilih**No**.
+ Untuk **penyimpanan ucapan Pengguna**, pilih respons yang sesuai.
1. Pilih **Buat**. Konsol membuat permintaan yang diperlukan ke Amazon Lex untuk menyimpan konfigurasi. Konsol kemudian menampilkan jendela editor bot.
1. Tunggu konfirmasi bahwa bot Anda dibangun.
1. Uji botnya.
**catatan**
Anda dapat menguji bot dengan mengetik teks ke jendela pengujian, atau, untuk browser yang kompatibel, dengan memilih tombol mikrofon di jendela uji dan berbicara.
Gunakan contoh teks berikut untuk terlibat dalam percakapan dengan bot untuk memesan bunga:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/OrderFlowers-NoLambda.png)
Dari input ini, bot menyimpulkan `OrderFlowers` maksud dan meminta data slot. Saat Anda memberikan semua data slot yang diperlukan, bot memenuhi intent (`OrderFlowers`) dengan mengembalikan semua informasi ke aplikasi klien (dalam hal ini, konsol). Konsol menampilkan informasi di jendela pengujian.
Secara khusus:
+ Dalam pernyataan “Hari apa Anda ingin mawar diambil? , "istilah “mawar” muncul karena prompt untuk `pickupDate` slot dikonfigurasi menggunakan substitusi,. `{FlowerType}` Verifikasi ini di konsol.
+ Pernyataan “Oke, mawar Anda akan siap...” adalah prompt konfirmasi yang Anda konfigurasikan.
+ Pernyataan terakhir (” `FlowerType:roses...` “) hanyalah data slot yang dikembalikan ke klien, dalam hal ini, di jendela pengujian. Pada latihan berikutnya, Anda menggunakan fungsi Lambda untuk memenuhi maksud, dalam hal ini Anda mendapatkan pesan yang menunjukkan bahwa pesanan terpenuhi.
**Langkah Selanjutnya**
[Langkah 2 (Opsional): Tinjau Detail Alur Informasi (Konsol)](gs-bp-details-two-runtime-apis.md)
# Langkah 2 (Opsional): Tinjau Detail Alur Informasi (Konsol)
Bagian ini menjelaskan aliran informasi antara klien dan Amazon Lex untuk setiap masukan pengguna dalam percakapan contoh kami.
Contoh menggunakan jendela pengujian konsol untuk percakapan dengan bot.
**Untuk membuka jendela uji Amazon Lex**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Pilih bot untuk diuji.
1. Dari sisi kanan konsol, pilih **Uji chatbot**.
Untuk melihat aliran informasi untuk konten yang diucapkan atau diketik, pilih topik yang sesuai.
**Topics**
+ [Langkah 2a (Opsional): Tinjau Detail Alur Informasi Lisan (Konsol)](gs-bp-details-postcontent-flow.md)
+ [Langkah 2b (Opsional): Tinjau Detail Alur Informasi yang Diketik (Konsol)](gs-bp-details-part1.md)
# Langkah 2a (Opsional): Tinjau Detail Alur Informasi Lisan (Konsol)
Bagian ini menjelaskan aliran informasi antara klien dan Amazon Lex ketika klien menggunakan pidato untuk mengirim permintaan. Untuk informasi selengkapnya, lihat [PostContent](API_runtime_PostContent.md).
1. Pengguna berkata: Saya ingin memesan beberapa bunga.
1. Klien (konsol) mengirimkan [PostContent](API_runtime_PostContent.md) permintaan berikut ke 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 permintaan dan badan memberikan informasi ke Amazon Lex:
+ Request URI — Menyediakan nama bot (`OrderFlowers`), bot alias (`$LATEST`), dan nama pengguna (string acak yang mengidentifikasi pengguna). `content`menunjukkan bahwa ini adalah permintaan `PostContent` API (bukan `PostText` permintaan).
+ Minta header
+ `x-amz-lex-session-attributes`— Nilai yang dikodekan base64 mewakili “\$1\$1”. Ketika klien membuat permintaan pertama, tidak ada atribut sesi.
+ `Content-Type`— Mencerminkan format audio.
+ Badan permintaan - Aliran audio input pengguna (“Saya ingin memesan beberapa bunga.”).
**catatan**
Jika pengguna memilih untuk mengirim teks (“Saya ingin memesan beberapa bunga”) ke `PostContent` API alih-alih berbicara, badan permintaan adalah input pengguna. `Content-Type`Header diatur sesuai:
```
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. Dari aliran input, Amazon Lex mendeteksi intent ()`OrderFlowers`. Kemudian memilih salah satu slot maksud (dalam hal ini,`FlowerType`) dan salah satu permintaan elisitasi nilainya, dan kemudian mengirimkan respons dengan header berikut:
```
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==
```
Nilai header memberikan informasi berikut:
+ `x-amz-lex-input-transcript`— Menyediakan transkrip audio (input pengguna) dari permintaan
+ `x-amz-lex-message`— Menyediakan transkrip audio Amazon Lex dikembalikan sebagai tanggapan
+ `x-amz-lex-slots`— Versi slot dan nilai yang dikodekan base64:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`— Versi atribut sesi yang dikodekan base64 (\$1\$1)
Klien memutar audio di badan respons.
1. Pengguna mengatakan: mawar
1. Klien (konsol) mengirimkan [PostContent](API_runtime_PostContent.md) permintaan berikut ke 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")
```
Badan permintaan adalah aliran audio input pengguna (mawar). `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex menafsirkan aliran input dalam konteks maksud saat ini (ingat bahwa ia telah meminta pengguna ini untuk informasi yang berkaitan dengan slot). `FlowerType` Amazon Lex pertama kali memperbarui nilai slot untuk maksud saat ini. Kemudian memilih slot lain (`PickupDate`), bersama dengan salah satu pesan prompt (Kapan Anda ingin mengambil mawar?) , dan mengembalikan respons dengan header berikut:
```
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=
```
Nilai header memberikan informasi berikut:
+ `x-amz-lex-slots`— Versi slot dan nilai yang dikodekan base64:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`— Versi atribut sesi yang dikodekan base64 (\$1\$1)
Klien memutar audio di badan respons.
1. Pengguna mengatakan: besok
1. Klien (konsol) mengirimkan [PostContent](API_runtime_PostContent.md) permintaan berikut ke 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")
```
Badan permintaan adalah aliran audio input pengguna (“besok”) `sessionAttributes` .Tetap kosong.
1. Amazon Lex menafsirkan aliran input dalam konteks maksud saat ini (ingat bahwa ia telah meminta pengguna ini untuk informasi yang berkaitan dengan slot). `PickupDate` Amazon Lex memperbarui nilai slot (`PickupDate`) untuk maksud saat ini. Kemudian memilih slot lain untuk mendapatkan nilai untuk (`PickupTime`) dan salah satu permintaan elisitasi nilai (Kapan Anda ingin mengambil mawar pada 2017-03-18?) , dan mengembalikan respons dengan header berikut:
```
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
```
Nilai header memberikan informasi berikut:
+ `x-amz-lex-slots`— Versi slot dan nilai yang dikodekan base64:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`— Versi atribut sesi yang dikodekan base64 (\$1\$1)
Klien memutar audio di badan respons.
1. Pengguna mengatakan: 6 sore
1. Klien (konsol) mengirimkan [PostContent](API_runtime_PostContent.md) permintaan berikut ke 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")
```
Badan permintaan adalah aliran audio input pengguna (“6 pm”). `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex menafsirkan aliran input dalam konteks maksud saat ini (ingat bahwa ia telah meminta pengguna ini untuk informasi yang berkaitan dengan slot). `PickupTime` Ini pertama kali memperbarui nilai slot untuk maksud saat ini.
Sekarang Amazon Lex mendeteksi bahwa ia memiliki informasi untuk semua slot. Namun, `OrderFlowers` intent dikonfigurasi dengan pesan konfirmasi. Oleh karena itu, Amazon Lex memerlukan konfirmasi eksplisit dari pengguna sebelum dapat melanjutkan untuk memenuhi maksud. Ini mengirimkan respons dengan header berikut yang meminta konfirmasi sebelum memesan bunga:
```
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
```
Nilai header memberikan informasi berikut:
+ `x-amz-lex-slots`— Versi slot dan nilai yang dikodekan base64:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`— Versi atribut sesi yang dikodekan base64 (\$1\$1)
Klien memutar audio di badan respons.
1. Pengguna mengatakan: Ya
1. Klien (konsol) mengirimkan [PostContent](API_runtime_PostContent.md) permintaan berikut ke 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")
```
Badan permintaan adalah aliran audio input pengguna (“Ya”). `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex menafsirkan aliran input dan memahami bahwa pengguna ingin melanjutkan pesanan. `OrderFlowers`Maksud dikonfigurasi dengan `ReturnIntent` sebagai aktivitas pemenuhan. Ini mengarahkan Amazon Lex untuk mengembalikan semua data maksud ke klien. Amazon Lex mengembalikan respons dengan berikut:
```
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==
```
Header `x-amz-lex-dialog-state` respons diatur ke`ReadyForFulfillment`. Klien kemudian dapat memenuhi niat tersebut.
1. Sekarang, uji ulang botnya. Untuk membuat konteks (pengguna) baru, pilih tautan **Hapus** di konsol. Berikan data untuk `OrderFlowers` maksud, dan sertakan beberapa data yang tidak valid. Contoh:
+ Melati sebagai jenis bunga (bukan salah satu jenis bunga yang didukung)
+ Kemarin sebagai hari ketika Anda ingin mengambil bunga
Perhatikan bahwa bot menerima nilai-nilai ini karena Anda tidak memiliki kode untuk menginisialisasi dan memvalidasi data pengguna. Di bagian selanjutnya, Anda menambahkan fungsi Lambda untuk melakukan ini. Perhatikan hal berikut tentang fungsi Lambda:
+ Ini memvalidasi data slot setelah setiap input pengguna. Itu memenuhi niat di akhir. Artinya, bot memproses pesanan bunga dan mengembalikan pesan ke pengguna alih-alih hanya mengembalikan data slot ke klien. Untuk informasi selengkapnya, lihat [Menggunakan Fungsi Lambda](using-lambda.md).
+ Ini juga menetapkan atribut sesi. Untuk informasi selengkapnya tentang atribut sesi, lihat[PostText](API_runtime_PostText.md).
Setelah Anda menyelesaikan bagian Memulai, Anda dapat melakukan latihan tambahan ([Contoh Tambahan: Membuat Amazon Lex Bots](additional-exercises.md)). [Pesan Perjalanan](ex-book-trip.md)menggunakan atribut sesi untuk berbagi informasi lintas maksud untuk terlibat dalam percakapan dinamis dengan pengguna.
**Langkah Selanjutnya**
[Langkah 3: Buat Fungsi Lambda (Konsol)](gs-bp-create-lambda-function.md)
# Langkah 2b (Opsional): Tinjau Detail Alur Informasi yang Diketik (Konsol)
Bagian ini menjelaskan aliran informasi antara klien dan Amazon Lex di mana klien menggunakan `PostText` API untuk mengirim permintaan. Untuk informasi selengkapnya, lihat [PostText](API_runtime_PostText.md).
1. Jenis pengguna: Saya ingin memesan beberapa bunga
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke 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 permintaan dan badan memberikan informasi ke Amazon Lex:
+ Request URI — Menyediakan nama bot (`OrderFlowers`), bot alias (`$LATEST`), dan nama pengguna (string acak yang mengidentifikasi pengguna). Trailing `text` menunjukkan bahwa itu adalah permintaan `PostText` API (dan bukan`PostContent`).
+ Request body - Termasuk input pengguna (`inputText`) dan kosong`sessionAttributes`. Ketika klien membuat permintaan pertama, tidak ada atribut sesi. Fungsi Lambda memulai mereka nanti.
1. Dari`inputText`, Amazon Lex mendeteksi intent ()`OrderFlowers`. Maksud ini tidak memiliki kait kode apa pun (yaitu, fungsi Lambda) untuk inisialisasi dan validasi input atau pemenuhan pengguna.
Amazon Lex memilih salah satu slot intent (`FlowerType`) untuk memperoleh nilai. Ini juga memilih salah satu prompt elisitasi nilai untuk slot (semua bagian dari konfigurasi maksud), dan kemudian mengirimkan respons berikut kembali ke klien. Konsol menampilkan pesan dalam respons kepada pengguna.
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-10.png)
Klien menampilkan pesan dalam respons.
1. Jenis pengguna: mawar
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
`inputText`Dalam badan permintaan menyediakan masukan pengguna. `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex pertama kali menafsirkan `inputText` dalam konteks maksud saat ini—layanan mengingat bahwa ia telah meminta pengguna tertentu untuk informasi tentang slot. `FlowerType` Amazon Lex pertama kali memperbarui nilai slot untuk maksud saat ini dan memilih slot lain (`PickupDate`) bersama dengan salah satu pesan cepatnya — hari apa Anda ingin mawar diambil? — `` untuk slot.
Kemudian, Amazon Lex mengembalikan respons berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-20.png)
Klien menampilkan pesan dalam respons.
1. Jenis pengguna: besok
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
`inputText`Dalam badan permintaan menyediakan masukan pengguna. `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex pertama kali menafsirkan `inputText` dalam konteks maksud saat ini—layanan mengingat bahwa ia telah meminta pengguna tertentu untuk informasi tentang slot. `PickupDate` Amazon Lex memperbarui nilai slot (`PickupDate`) untuk maksud saat ini. Ini memilih slot lain untuk memperoleh nilai untuk (). `PickupTime` Ini mengembalikan salah satu petunjuk elisitasi nilai—mengirimkan mawar pada jam berapa pada 2017-01-05? - `` untuk klien.
Amazon Lex kemudian mengembalikan respons berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-30.png)
Klien menampilkan pesan dalam respons.
1. Jenis pengguna: 6 sore
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
`inputText`Dalam badan permintaan menyediakan masukan pengguna. `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex pertama kali menafsirkan `inputText` dalam konteks maksud saat ini—layanan mengingat bahwa ia telah meminta pengguna tertentu untuk informasi tentang slot. `PickupTime` Amazon Lex pertama kali memperbarui nilai slot untuk maksud saat ini. Sekarang Amazon Lex mendeteksi bahwa ia memiliki informasi untuk semua slot.
`OrderFlowers`Maksud dikonfigurasi dengan pesan konfirmasi. Oleh karena itu, Amazon Lex memerlukan konfirmasi eksplisit dari pengguna sebelum dapat melanjutkan untuk memenuhi maksud. Amazon Lex mengirimkan pesan berikut kepada klien yang meminta konfirmasi sebelum memesan bunga:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-40.png)
Klien menampilkan pesan dalam respons.
1. Jenis pengguna: Ya
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
`inputText`Dalam badan permintaan menyediakan masukan pengguna. `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex menafsirkan `inputText` dalam konteks mengkonfirmasikan maksud saat ini. Ia memahami bahwa pengguna ingin melanjutkan pesanan. `OrderFlowers`Maksud dikonfigurasi `ReturnIntent` sebagai aktivitas pemenuhan (tidak ada fungsi Lambda untuk memenuhi maksud). Oleh karena itu, Amazon Lex mengembalikan data slot berikut ke klien.
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex mengatur `dialogState` ke`ReadyForFulfillment`. Klien kemudian dapat memenuhi niat tersebut.
1. Sekarang uji bot lagi. Untuk melakukan itu, Anda harus memilih tautan **Hapus** di konsol untuk membuat konteks (pengguna) baru. Sekarang saat Anda memberikan data untuk maksud pesanan bunga, cobalah untuk memberikan data yang tidak valid. Contoh:
+ Melati sebagai jenis bunga (bukan salah satu jenis bunga yang didukung).
+ Kemarin sebagai hari ketika Anda ingin mengambil bunga.
Perhatikan bahwa bot menerima nilai-nilai ini karena Anda tidak memiliki kode apa pun ke data initialize/validate pengguna. Di bagian selanjutnya, Anda menambahkan fungsi Lambda untuk melakukan ini. Perhatikan hal berikut tentang fungsi Lambda:
+ Fungsi Lambda memvalidasi data slot setelah setiap input pengguna. Itu memenuhi niat di akhir. Artinya, bot memproses pesanan bunga dan mengembalikan pesan ke pengguna alih-alih hanya mengembalikan data slot ke klien. Untuk informasi selengkapnya, lihat [Menggunakan Fungsi Lambda](using-lambda.md).
+ Fungsi Lambda juga menetapkan atribut sesi. Untuk informasi selengkapnya tentang atribut sesi, lihat[PostText](API_runtime_PostText.md).
Setelah Anda menyelesaikan bagian Memulai, Anda dapat melakukan latihan tambahan ([Contoh Tambahan: Membuat Amazon Lex Bots](additional-exercises.md)). [Pesan Perjalanan](ex-book-trip.md)menggunakan atribut sesi untuk berbagi informasi lintas maksud untuk terlibat dalam percakapan dinamis dengan pengguna.
**Langkah Selanjutnya**
[Langkah 3: Buat Fungsi Lambda (Konsol)](gs-bp-create-lambda-function.md)
# Langkah 3: Buat Fungsi Lambda (Konsol)
Buat fungsi Lambda (menggunakan **lex-order-flowers-python**cetak biru) dan lakukan pemanggilan pengujian menggunakan contoh data peristiwa di konsol. AWS Lambda
Anda kembali ke konsol Amazon Lex dan menambahkan fungsi Lambda sebagai pengait kode untuk memenuhi `OrderFlowers` maksud `OrderFlowersBot` yang Anda buat di bagian sebelumnya.
**Untuk membuat fungsi Lambda (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Pilih **Buat fungsi**.
1. Pada halaman **Buat fungsi**, pilih **Gunakan cetak biru**. Ketik **lex-** kotak teks filter dan kemudian tekan `Enter` untuk menemukan cetak biru, pilih cetak biru. `lex-order-flowers-python`
Cetak biru fungsi Lambda disediakan di Node.js dan Python. Untuk latihan ini, gunakan cetak biru berbasis Python.
1. Pada halaman **Informasi dasar**, lakukan hal berikut.
+ Ketik nama fungsi Lambda ()`OrderFlowersCodeHook`.
+ Untuk peran eksekusi, pilih **Buat peran baru dengan izin Lambda dasar**.
+ Tinggalkan nilai default lainnya.
1. Pilih **Buat fungsi**.
1. Jika Anda menggunakan lokal selain bahasa Inggris (AS) (en-US), perbarui nama maksud seperti yang dijelaskan dalam. [Memperbarui Cetak Biru untuk Lokal Tertentu](lex-lambda-blueprints.md#blueprint-update-locale)
1. Uji fungsi Lambda.
1. Pilih **Pilih acara pengujian**, **Konfigurasikan peristiwa pengujian**.
1. Pilih **Amazon Lex Order Flowers** dari daftar **template Acara**. Contoh acara ini cocok dengan request/response model Amazon Lex (lihat[Menggunakan Fungsi Lambda](using-lambda.md)). Beri nama acara pengujian (`LexOrderFlowersTest`).
1. Pilih **Buat**.
1. Pilih **Uji** untuk menguji kait kode.
1. Verifikasi bahwa fungsi Lambda berhasil berjalan. Respons dalam hal ini cocok dengan model respons Amazon Lex.
**Langkah Selanjutnya**
[Langkah 4: Tambahkan Fungsi Lambda sebagai Code Hook (Console)](gs-bp-create-integrate.md)
# Langkah 4: Tambahkan Fungsi Lambda sebagai Code Hook (Console)
Di bagian ini, Anda memperbarui konfigurasi OrderFlowers intent untuk menggunakan fungsi Lambda sebagai berikut:
+ Pertama gunakan fungsi Lambda sebagai hook kode untuk melakukan pemenuhan maksud. `OrderFlowers` Anda menguji bot dan memverifikasi bahwa Anda menerima pesan pemenuhan dari fungsi Lambda. Amazon Lex memanggil fungsi Lambda hanya setelah Anda memberikan data untuk semua slot yang diperlukan untuk memesan bunga.
+ Konfigurasikan fungsi Lambda yang sama sebagai hook kode untuk melakukan inisialisasi dan validasi. Anda menguji dan memverifikasi bahwa fungsi Lambda melakukan validasi (saat Anda memberikan data slot).
**Untuk menambahkan fungsi Lambda sebagai hook kode (konsol)**
1. Di konsol Amazon Lex, pilih **OrderFlowers**bot. Konsol menunjukkan **OrderFlowers**maksud. Pastikan versi intent disetel ke `$LATEST` karena ini adalah satu-satunya versi yang dapat kita modifikasi.
1. Tambahkan fungsi Lambda sebagai hook kode pemenuhan dan ujilah.
1. Di Editor, pilih **AWS Lambda fungsi** sebagai **Pemenuhan**, dan pilih fungsi Lambda yang Anda buat di langkah sebelumnya (). `OrderFlowersCodeHook` Pilih **OK** untuk memberikan izin Amazon Lex untuk menjalankan fungsi Lambda.
Anda mengonfigurasi fungsi Lambda ini sebagai pengait kode untuk memenuhi maksud. Amazon Lex memanggil fungsi ini hanya setelah memiliki semua data slot yang diperlukan dari pengguna untuk memenuhi maksud.
1. Tentukan **pesan Selamat Tinggal**.
1. Pilih **Build**.
1. Uji bot menggunakan percakapan sebelumnya.
Pernyataan terakhir “Terima kasih, pesanan Anda untuk mawar...” adalah respons dari fungsi Lambda yang Anda konfigurasikan sebagai pengait kode. Di bagian sebelumnya, tidak ada fungsi Lambda. Sekarang Anda menggunakan fungsi Lambda untuk benar-benar memenuhi maksud. `OrderFlowers`
1. Tambahkan fungsi Lambda sebagai pengait kode inisialisasi dan validasi, dan uji.
Contoh kode fungsi Lambda yang Anda gunakan dapat melakukan validasi dan pemenuhan input pengguna. Peristiwa masukan yang diterima fungsi Lambda memiliki field (`invocationSource`) yang digunakan kode untuk menentukan bagian kode mana yang akan dijalankan. Untuk informasi selengkapnya, lihat [Peristiwa Input Fungsi Lambda dan Format Respons](lambda-input-response-format.md).
1. Pilih versi \$1LATEST dari `OrderFlowers` intent. Itu adalah satu-satunya versi yang dapat Anda perbarui.
1. **Di Editor, pilih **Inisialisasi dan validasi di Opsi**.**
1. Sekali lagi, pilih fungsi Lambda yang sama.
1. Pilih **Build**.
1. Uji botnya.
Anda sekarang siap untuk berkomunikasi dengan Amazon Lex seperti pada gambar berikut. Untuk menguji bagian validasi, pilih waktu 6 sore, dan fungsi Lambda Anda mengembalikan respons (“Jam kerja kami adalah dari jam 10 pagi sampai jam 5 sore.”), dan meminta Anda lagi. Setelah Anda memberikan semua data slot yang valid, fungsi Lambda memenuhi pesanan.
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Langkah Selanjutnya**
[Langkah 5 (Opsional): Tinjau Detail Alur Informasi (Konsol)](gs-bp-details-after-lambda.md)
# Langkah 5 (Opsional): Tinjau Detail Alur Informasi (Konsol)
Bagian ini menjelaskan aliran informasi antara klien dan Amazon Lex untuk setiap input pengguna, termasuk integrasi fungsi Lambda.
**catatan**
Bagian ini mengasumsikan bahwa klien mengirimkan permintaan ke Amazon Lex menggunakan API `PostText` runtime dan menampilkan detail permintaan dan respons yang sesuai. Untuk contoh aliran informasi antara klien dan Amazon Lex di mana klien menggunakan `PostContent` API, lihat[Langkah 2a (Opsional): Tinjau Detail Alur Informasi Lisan (Konsol)](gs-bp-details-postcontent-flow.md).
Untuk informasi selengkapnya tentang API `PostText` runtime dan detail tambahan tentang permintaan dan tanggapan yang ditampilkan dalam langkah-langkah berikut, lihat[PostText](API_runtime_PostText.md).
1. Pengguna: Saya ingin memesan beberapa bunga.
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke 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 permintaan dan badan memberikan informasi ke Amazon Lex:
+ Request URI — Menyediakan nama bot (`OrderFlowers`), bot alias (`$LATEST`), dan nama pengguna (string acak yang mengidentifikasi pengguna). Trailing `text` menunjukkan bahwa itu adalah permintaan `PostText` API (dan bukan`PostContent`).
+ Request body - Termasuk input pengguna (`inputText`) dan kosong`sessionAttributes`. Ketika klien membuat permintaan pertama, tidak ada atribut sesi. Fungsi Lambda memulai mereka nanti.
1. Dari`inputText`, Amazon Lex mendeteksi intent ()`OrderFlowers`. Maksud ini dikonfigurasi dengan fungsi Lambda sebagai hook kode untuk inisialisasi dan validasi data pengguna. Oleh karena itu, Amazon Lex memanggil fungsi Lambda itu dengan meneruskan informasi berikut sebagai data peristiwa:
```
{
"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"
}
}
```
Untuk informasi selengkapnya, lihat [Format Peristiwa Masukan](lambda-input-response-format.md#using-lambda-input-event-format).
Selain informasi yang dikirim klien, Amazon Lex juga menyertakan data tambahan berikut:
+ `messageVersion`- Saat ini Amazon Lex hanya mendukung versi 1.0.
+ `invocationSource`— Menunjukkan tujuan pemanggilan fungsi Lambda. Dalam hal ini, itu adalah untuk melakukan inisialisasi dan validasi data pengguna. Saat ini, Amazon Lex tahu bahwa pengguna belum menyediakan semua data slot untuk memenuhi maksud tersebut.
+ `currentIntent`informasi dengan semua nilai slot diatur ke null.
1. Pada saat ini, semua nilai slot adalah nol. Tidak ada fungsi Lambda untuk memvalidasi. Fungsi Lambda mengembalikan respons berikut ke Amazon Lex:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Untuk informasi tentang format respons, lihat[Format Respons](lambda-input-response-format.md#using-lambda-response-format).
Perhatikan hal-hal berikut:
+ `dialogAction.type`— Dengan menetapkan nilai ini`Delegate`, fungsi Lambda mendelegasikan tanggung jawab untuk memutuskan tindakan selanjutnya ke Amazon Lex.
**catatan**
Jika fungsi Lambda mendeteksi apa pun dalam validasi data pengguna, fungsi ini menginstruksikan Amazon Lex apa yang harus dilakukan selanjutnya, seperti yang ditunjukkan pada beberapa langkah berikutnya.
1. Menurut`dialogAction.type`, Amazon Lex memutuskan tindakan selanjutnya. Karena tidak ada slot yang diisi, ia memutuskan untuk memperoleh nilai untuk slot. `FlowerType` Ini memilih salah satu petunjuk elisitasi nilai (“Jenis bunga apa yang ingin Anda pesan?”) untuk slot ini dan mengirimkan respons berikut kembali ke klien:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-10.png)
Klien menampilkan pesan dalam respons.
1. Pengguna: mawar
1. Klien mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
Di badan permintaan, `inputText` menyediakan input pengguna. `sessionAttributes`Sisa-sisa kosong.
1. Amazon Lex pertama kali menafsirkan `inputText` dalam konteks maksud saat ini. Layanan ingat bahwa mereka telah meminta pengguna tertentu untuk informasi tentang `FlowerType` slot. Ini memperbarui nilai slot dalam maksud saat ini dan memanggil fungsi Lambda dengan data peristiwa berikut:
```
{
"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"
}
}
```
Perhatikan hal-hal berikut:
+ `invocationSource`— terus menjadi `DialogCodeHook` (kami hanya memvalidasi data pengguna).
+ `currentIntent.slots`— Amazon Lex telah memperbarui `FlowerType` slot ke mawar.
1. Menurut `invocationSource` nilai`DialogCodeHook`, fungsi Lambda melakukan validasi data pengguna. Ini mengenali `roses` sebagai nilai slot yang valid (dan ditetapkan `Price` sebagai atribut sesi) dan mengembalikan respons berikut ke Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Perhatikan hal-hal berikut:
+ `sessionAttributes`— Fungsi Lambda telah menambahkan `Price` (mawar) sebagai atribut sesi.
+ `dialogAction.type`- diatur ke`Delegate`. Data pengguna valid sehingga fungsi Lambda mengarahkan Amazon Lex untuk memilih tindakan berikutnya.
1. Menurut`dialogAction.type`, Amazon Lex memilih tindakan berikutnya. Amazon Lex tahu itu membutuhkan lebih banyak data slot sehingga memilih slot yang tidak terisi berikutnya (`PickupDate`) dengan prioritas tertinggi sesuai dengan konfigurasi maksud. Amazon Lex memilih salah satu pesan prompt elisitasi nilai — “Hari apa Anda ingin mawar diambil?” —untuk slot ini sesuai dengan konfigurasi maksud, dan kemudian mengirimkan respons berikut kembali ke klien:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-20.png)
Klien hanya menampilkan pesan dalam tanggapan - “Hari apa Anda ingin mawar diambil?.”
1. Pengguna: besok
1. Klien mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
Di badan permintaan, `inputText` berikan input pengguna dan klien meneruskan atribut sesi kembali ke layanan.
1. Amazon Lex ingat konteksnya — bahwa itu memunculkan data untuk slot. `PickupDate` Dalam konteks ini, ia tahu `inputText` nilainya untuk `PickupDate` slot. Amazon Lex kemudian memanggil fungsi Lambda dengan mengirimkan acara berikut:
```
{
"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 telah memperbarui `currentIntent.slots` dengan menetapkan `PickupDate` nilai. Perhatikan juga bahwa layanan melewati apa `sessionAttributes` adanya ke fungsi Lambda.
1. Sesuai `invocationSource` nilai`DialogCodeHook`, fungsi Lambda melakukan validasi data pengguna. Ini mengakui nilai `PickupDate` slot valid dan mengembalikan respons berikut ke Amazon Lex:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Perhatikan hal-hal berikut:
+ `sessionAttributes`- Tidak ada perubahan.
+ `dialogAction.type`- diatur ke`Delegate`. Data pengguna valid, dan fungsi Lambda mengarahkan Amazon Lex untuk memilih tindakan berikutnya.
1. Menurut`dialogAction.type`, Amazon Lex memilih tindakan berikutnya. Amazon Lex tahu itu membutuhkan lebih banyak data slot sehingga memilih slot yang tidak terisi berikutnya (`PickupTime`) dengan prioritas tertinggi sesuai dengan konfigurasi maksud. Amazon Lex memilih salah satu pesan prompt (“Kirim mawar kapan pada 2017-01-05?”) untuk slot ini sesuai dengan konfigurasi maksud dan mengirimkan respons berikut kembali ke klien:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-30.png)
Klien menampilkan pesan dalam tanggapan - “Kirimkan mawar pada jam berapa pada 2017-01-05?”
1. Pengguna: 4 sore
1. Klien mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke 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"
}
}
```
Di badan permintaan, `inputText` berikan masukan pengguna. Klien melewati `sessionAttributes` permintaan.
1. Amazon Lex memahami konteksnya. Ia mengerti bahwa itu memunculkan data untuk slot. `PickupTime` Dalam konteks ini, ia tahu bahwa `inputText` nilainya adalah untuk `PickupTime` slot. Amazon Lex kemudian memanggil fungsi Lambda dengan mengirimkan acara berikut:
```
{
"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 telah memperbarui `currentIntent.slots` dengan menetapkan `PickupTime` nilai.
1. Menurut `invocationSource` nilai`DialogCodeHook`, fungsi Lambda melakukan validasi data pengguna. Ini mengakui nilai `PickupDate` slot valid dan mengembalikan respons berikut ke Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Perhatikan hal-hal berikut:
+ `sessionAttributes`— Tidak ada perubahan atribut sesi.
+ `dialogAction.type`- diatur ke`Delegate`. Data pengguna valid sehingga fungsi Lambda mengarahkan Amazon Lex untuk memilih tindakan berikutnya.
1. Saat ini Amazon Lex tahu ia memiliki semua data slot. Maksud ini dikonfigurasi dengan prompt konfirmasi. Oleh karena itu, Amazon Lex mengirimkan respons berikut kepada pengguna yang meminta konfirmasi sebelum memenuhi maksud:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-45.png)
Klien hanya menampilkan pesan dalam respons dan menunggu respons pengguna.
1. Pengguna: Ya
1. Klien mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke 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 menafsirkan `inputText` dalam konteks mengkonfirmasikan maksud saat ini. Amazon Lex memahami bahwa pengguna ingin melanjutkan pesanan. Kali ini Amazon Lex memanggil fungsi Lambda untuk memenuhi maksud dengan mengirimkan peristiwa berikut, yang menyetel ke jika `invocationSource` dikirimkan `FulfillmentCodeHook` ke fungsi Lambda. Amazon Lex juga menetapkan `confirmationStatus` untuk`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"
}
}
```
Perhatikan hal-hal berikut:
+ `invocationSource`— Kali ini Amazon Lex menetapkan nilai ini`FulfillmentCodeHook`, mengarahkan fungsi Lambda untuk memenuhi maksud.
+ `confirmationStatus`- diatur ke`Confirmed`.
1. Kali ini, fungsi Lambda memenuhi `OrderFlowers` intent, dan mengembalikan respons berikut:
```
{
"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"
}
}
}
```
Perhatikan hal-hal berikut:
+ Menetapkan `dialogAction.type` — Fungsi Lambda menetapkan nilai ini`Close`, mengarahkan Amazon Lex agar tidak mengharapkan respons pengguna.
+ `dialogAction.fulfillmentState`— diatur ke Fulled dan termasuk yang sesuai `message` untuk disampaikan kepada pengguna.
1. Amazon Lex mengulas `fulfillmentState` dan mengirimkan tanggapan berikut kembali ke klien.
Amazon Lex kemudian mengembalikan yang berikut ini ke klien:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs-1-details-48.png)
Perhatikan bahwa:
+ `dialogState`— Amazon Lex menetapkan nilai ini ke`fulfilled`.
+ `message`— adalah pesan yang sama dengan fungsi Lambda yang disediakan.
Klien menampilkan pesan.
1. Sekarang uji bot lagi. Untuk membuat konteks (pengguna) baru, pilih tautan **Hapus** di jendela pengujian. Sekarang berikan data slot yang tidak valid untuk maksud tersebut. `OrderFlowers` Kali ini fungsi Lambda melakukan validasi data, mengatur ulang nilai data slot yang tidak valid ke null, dan meminta Amazon Lex untuk meminta pengguna untuk data yang valid. Misalnya, coba yang berikut ini:
+ Melati sebagai jenis bunga (bukan salah satu jenis bunga yang didukung).
+ Kemarin sebagai hari ketika Anda ingin mengambil bunga.
+ Setelah melakukan pemesanan, masukkan jenis bunga lain alih-alih menjawab “ya” untuk mengonfirmasi pesanan. Sebagai tanggapan, fungsi Lambda memperbarui atribut `Price` dalam sesi, menjaga total pesanan bunga berjalan.
Fungsi Lambda juga melakukan aktivitas pemenuhan.
**Langkah Selanjutnya**
[Langkah 6: Perbarui Konfigurasi Intent untuk Menambahkan Ucapan (Konsol)](gs-bp-utterance.md)
# Langkah 6: Perbarui Konfigurasi Intent untuk Menambahkan Ucapan (Konsol)
`OrderFlowers`Bot dikonfigurasi hanya dengan dua ucapan. Ini memberikan informasi terbatas bagi Amazon Lex untuk membuat model pembelajaran mesin yang mengenali dan merespons maksud pengguna. Coba ketik “Saya ingin memesan bunga”, seperti pada jendela pengujian berikut. Amazon Lex tidak mengenali teks, dan menjawab dengan “Saya tidak mengerti Anda, apa yang ingin Anda lakukan?” Anda dapat meningkatkan model pembelajaran mesin dengan menambahkan lebih banyak ucapan.
![\[Jendela uji menunjukkan ucapan yang terlewat.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-120.png)
Setiap ucapan yang Anda tambahkan memberi Amazon Lex informasi lebih lanjut tentang cara merespons pengguna Anda. Anda tidak perlu menambahkan ucapan yang tepat, Amazon Lex menggeneralisasi dari sampel yang Anda berikan untuk mengenali kecocokan persis dan input serupa.
**Untuk menambahkan ucapan (konsol)**
1. Tambahkan ucapan “Saya ingin bunga” ke maksud dengan mengetikkannya di bagian **Sample ujaran dari editor maksud, seperti pada gambar berikut, lalu mengklik ikon plus di sebelah ucapan** baru.
![\[Editor maksud dengan ucapan baru.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-130.png)
1. Bangun bot Anda untuk mengambil perubahan. Pilih **Build**, lalu pilih **Build** lagi.
1. Uji bot Anda untuk mengonfirmasi bahwa ia mengenali ucapan baru. Di jendela uji, seperti pada gambar berikut, ketik “Saya ingin memesan bunga.” Amazon Lex mengenali frasa tersebut dan merespons dengan “Jenis bunga apa yang ingin Anda pesan?”.
![\[Editor maksud mengenali ucapan baru.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-140.png)
**Langkah Selanjutnya**
[Langkah 7 (Opsional): Bersihkan (Konsol)](gs-bp-cleaning-up.md)
# Langkah 7 (Opsional): Bersihkan (Konsol)
Sekarang, hapus sumber daya yang Anda buat dan bersihkan akun Anda.
Anda hanya dapat menghapus sumber daya yang tidak digunakan. Secara umum, Anda harus menghapus sumber daya dalam urutan berikut:
+ Hapus bot untuk membebaskan sumber daya maksud.
+ Hapus maksud untuk membebaskan sumber daya jenis slot.
+ Hapus jenis slot terakhir.
**Untuk membersihkan akun Anda (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Dari daftar bot, pilih kotak centang di sebelah **OrderFlowers**.
1. Untuk menghapus bot, pilih **Hapus**, lalu pilih **Lanjutkan** di kotak dialog konfirmasi.
1. Di panel kiri, pilih **Maksud**.
1. Dalam daftar maksud, pilih **OrderFlowersIntent**.
1. Untuk menghapus maksud, pilih **Hapus**, lalu pilih **Lanjutkan** di kotak dialog konfirmasi.
1. Di panel kiri, pilih **jenis Slot**.
1. Dalam daftar jenis slot, pilih **Bunga**.
1. Untuk menghapus jenis slot, pilih **Hapus**, lalu pilih **Lanjutkan** di kotak dialog konfirmasi.
Anda telah menghapus semua sumber daya Amazon Lex yang Anda buat dan bersihkan akun Anda. Jika diinginkan, Anda dapat menggunakan [konsol Lambda](https://console.aws.amazon.com/lambda) untuk menghapus fungsi Lambda yang digunakan dalam latihan ini.
# Latihan 2: Buat Bot Amazon Lex Kustom
Dalam latihan ini, Anda menggunakan konsol Amazon Lex untuk membuat bot khusus yang memesan pizza (`OrderPizzaBot`). Anda mengonfigurasi bot dengan menambahkan maksud khusus (`OrderPizza`), menentukan jenis slot khusus, dan menentukan slot yang diperlukan untuk memenuhi pesanan pizza (kerak pizza, ukuran, dan sebagainya). Untuk informasi lebih lanjut tentang jenis slot dan slot, lihat[Amazon Lex: Cara Kerjanya](how-it-works.md).
**Topics**
+ [Langkah 1: Buat Fungsi Lambda](gs2-prepare.md)
+ [Langkah 2: Buat Bot](gs2-create-bot.md)
+ [Langkah 3: Bangun dan Uji Bot](gs2-build-and-test.md)
+ [Langkah 4 (Opsional): Bersihkan](gs2-clean-up.md)
# Langkah 1: Buat Fungsi Lambda
Pertama, buat fungsi Lambda yang memenuhi pesanan pizza. Anda menentukan fungsi ini di bot Amazon Lex Anda, yang Anda buat di bagian berikutnya.
**Untuk membuat fungsi Lambda**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Pilih **Buat fungsi**.
1. Pilih halaman **Buat fungsi**, pilih **Penulis dari scratch**.
Karena Anda menggunakan kode khusus yang diberikan kepada Anda dalam latihan ini untuk membuat fungsi Lambda, Anda memilih penulis fungsi dari awal.
Lakukan hal-hal berikut:
1. Ketik nama (`PizzaOrderProcessor`).
1. Untuk **Runtime**, pilih versi terbaru dari Node.js.
1. Untuk **Peran**, pilih **Buat peran baru dari templat**.
1. Masukkan nama peran baru (`PizzaOrderProcessorRole`).
1. Pilih **Buat fungsi**.
1. Di halaman fungsi, lakukan hal berikut:
Di bagian **Kode fungsi**, pilih **Edit kode sebaris**, lalu salin kode fungsi Node.js berikut dan tempel di jendela.
```
'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. Pilih **Simpan**.
## Uji Fungsi Lambda Menggunakan Contoh Data Peristiwa
Di konsol, uji fungsi Lambda dengan menggunakan data peristiwa sampel untuk memanggilnya secara manual.
**Untuk menguji fungsi Lambda:**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Pada halaman **fungsi Lambda, pilih fungsi** Lambda (`PizzaOrderProcessor).`
1. Pada halaman fungsi, dalam daftar peristiwa pengujian, pilih **Konfigurasi peristiwa pengujian**.
1. Pada halaman **Configure test event**, lakukan hal berikut:
1. Pilih **Buat peristiwa pengujian baru**.
1. Di bidang **Nama acara**, masukkan nama untuk acara (`PizzaOrderProcessorTest`).
1. Salin acara Amazon Lex berikut ke jendela.
```
{
"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. Pilih **Buat**.
AWS Lambda membuat tes dan Anda kembali ke halaman fungsi. Pilih **Uji** dan Lambda menjalankan fungsi Lambda Anda.
Di kotak hasil, pilih **Detail**. Konsol menampilkan output berikut di panel **Hasil eksekusi**.
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Okay, I have ordered your large meat pizza on thin crust."
}
}
```
## Langkah Selanjutnya
[Langkah 2: Buat Bot](gs2-create-bot.md)
# Langkah 2: Buat Bot
Pada langkah ini, Anda membuat bot untuk menangani pesanan pizza.
**Topics**
+ [Buat Bot](gs2-create-bot-create.md)
+ [Buat Intent](gs2-create-bot-intent.md)
+ [Buat Jenis Slot](gs2-create-bot-slot-types.md)
+ [Konfigurasikan Intent](gs2-create-bot-configure-intent.md)
+ [Konfigurasikan Bot](gs2-create-bot-configure-bot.md)
# Buat Bot
Buat `PizzaOrderingBot` bot dengan informasi minimum yang dibutuhkan. Anda menambahkan maksud, tindakan yang ingin dilakukan pengguna, untuk bot nanti.
**Untuk membuat bot**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Buat bot.
1. Jika Anda membuat bot pertama Anda, pilih **Memulai**. Jika tidak, pilih **Bot**, lalu pilih **Buat**.
1. Pada halaman **Create your Lex bot**, pilih **Custom bot** dan berikan informasi berikut:
+ **Nama bot**: PizzaOrderingBot
+ **Bahasa**: Pilih bahasa dan lokal untuk bot Anda.
+ **Suara keluaran**: Salli
+ Batas **waktu sesi**: 5 menit.
+ **COPPA**: Pilih respons yang sesuai.
+ **Penyimpanan ucapan pengguna: Pilih respons yang sesuai.**
1. Pilih **Buat**.
Konsol mengirimkan Amazon Lex permintaan untuk membuat bot baru. Amazon Lex menetapkan versi bot ke`$LATEST`. Setelah membuat bot, Amazon Lex menunjukkan tab **Editor** bot, seperti pada gambar berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-20.png)
+ Versi bot, **Terbaru**, muncul di sebelah nama bot di konsol. Sumber daya Amazon Lex baru memiliki `$LATEST` versi. Untuk informasi selengkapnya, lihat [Pembuatan Versi dan Alias](versioning-aliases.md).
+ Karena Anda belum membuat maksud atau jenis slot apa pun, tidak ada yang terdaftar.
+ **Bangun** dan **Publikasikan** adalah aktivitas tingkat bot. Setelah mengonfigurasi seluruh bot, Anda akan mempelajari lebih lanjut tentang aktivitas ini.
## Langkah Selanjutnya
[Buat Intent](gs2-create-bot-intent.md)
# Buat Intent
Sekarang, buat `OrderPizza` maksud, tindakan yang ingin dilakukan pengguna, dengan informasi minimum yang diperlukan. Anda menambahkan jenis slot untuk intent dan kemudian mengonfigurasi intent nanti.
**Untuk membuat maksud**
1. Di konsol Amazon Lex, pilih tanda plus (\$1) di sebelah **Maksud**, lalu pilih **Buat maksud baru**.
1. **Di kotak dialog **Create intent**, ketikkan nama intent (`OrderPizza`), lalu pilih Tambah.**
Konsol mengirimkan permintaan ke Amazon Lex untuk membuat `OrderPizza` intent. Dalam contoh ini Anda membuat slot untuk maksud setelah Anda membuat jenis slot.
## Langkah Selanjutnya
[Buat Jenis Slot](gs2-create-bot-slot-types.md)
# Buat Jenis Slot
Buat jenis slot, atau nilai parameter, yang digunakan `OrderPizza` intent.
**Untuk membuat jenis slot**
1. Di menu sebelah kiri, pilih tanda plus (\$1) di sebelah **jenis Slot**.
1. Dalam kotak dialog **Add slot type**, tambahkan yang berikut ini:
+ **Nama jenis slot** — Kerak
+ **Deskripsi** - Kerak yang tersedia
+ Pilih **Batasi Nilai Slot dan Sinonim**
+ **Nilai** — Jenis**thick**. Tekan tab dan di jenis bidang **Sinonim**. **stuffed** Pilih tanda plus (\$1). Ketik **thin** dan kemudian pilih tanda plus (\$1) lagi.
Dialog akan terlihat seperti gambar berikut:
![\[Kotak dialog jenis slot edit.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-25a.png)
1. Pilih **Tambahkan slot ke intent.**
1. Pada halaman **Intent**, pilih **Required**. Ubah nama slot dari **slotOne** menjadi**crust**. Ubah prompt ke **What kind of crust would you like?**
1. [Step 1](#slotTypeStart)Ulangi [Step 4](#slotTypeFinish) menggunakan nilai-nilai dalam tabel berikut:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/gs2-create-bot-slot-types.html)
## Langkah Selanjutnya
[Konfigurasikan Intent](gs2-create-bot-configure-intent.md)
# Konfigurasikan Intent
Konfigurasikan `OrderPizza` maksud untuk memenuhi permintaan pengguna untuk memesan pizza.
**Untuk mengonfigurasi maksud**
+ Pada halaman **OrderPizza**konfigurasi, konfigurasikan intent sebagai berikut:
+ **Contoh ucapan - Ketik** string berikut. Kurung kurawal \$1\$1 melampirkan nama slot.
+ Saya ingin memesan pizza silahkan
+ Saya ingin memesan pizza
+ Saya ingin memesan pizza \$1PizzaKind\$1
+ Saya ingin memesan pizza \$1size\$1 \$1PizzaKind\$1
+ Saya ingin pizza \$1size\$1 \$1crust\$1 crust \$1PizzaKind\$1
+ Bisakah saya mendapatkan pizza tolong
+ Bisakah saya mendapatkan pizza \$1PizzaKind\$1
+ Bisakah saya mendapatkan pizza \$1size\$1 \$1PizzaKind\$1
+ **Inisialisasi dan validasi Lambda** - Tinggalkan pengaturan default.
+ **Prompt konfirmasi** - Tinggalkan pengaturan default.
+ **Pemenuhan** - Lakukan tugas-tugas berikut:
+ Pilih **AWS Lambda fungsi**.
+ Pilih **PizzaOrderProcessor**.
+ Jika kotak dialog **Tambahkan izin ke fungsi Lambda** ditampilkan, pilih **OK** untuk memberikan izin `OrderPizza` maksud untuk memanggil fungsi Lambda`PizzaOrderProcessor`.
+ Biarkan **Tidak ada** yang dipilih.
Maksudnya akan terlihat seperti berikut:
![\[Editor niat.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-70c.png)
## Langkah Selanjutnya
[Konfigurasikan Bot](gs2-create-bot-configure-bot.md)
# Konfigurasikan Bot
Konfigurasikan penanganan kesalahan untuk `PizzaOrderingBot` bot.
1. Arahkan ke `PizzaOrderingBot` bot. Pilih **Editor**. Lalu pilih **Error Handling**, seperti pada gambar berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-80.png)
1. Gunakan tab **Editor** untuk mengonfigurasi penanganan kesalahan bot.
+ [Informasi yang Anda berikan di **Clarification Prompts** memetakan ke konfigurasi ClarificationPrompt bot.](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-clarificationPrompt)
Jika Amazon Lex tidak dapat menentukan maksud pengguna, layanan akan menampilkan respons dengan pesan ini.
+ [Informasi yang Anda berikan dalam frase **Hang-up** memetakan ke konfigurasi AbortStatement bot.](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-abortStatement)
Jika layanan tidak dapat menentukan maksud pengguna setelah sejumlah permintaan berturut-turut yang ditetapkan, Amazon Lex mengembalikan respons dengan pesan ini.
Tinggalkan default.
## Langkah Selanjutnya
[Langkah 3: Bangun dan Uji Bot](gs2-build-and-test.md)
# Langkah 3: Bangun dan Uji Bot
Pastikan bot berfungsi, dengan membangun dan mengujinya.
**Untuk membangun dan menguji bot**
1. Untuk membangun `PizzaOrderingBot` bot, pilih **Build**.
Amazon Lex membuat model pembelajaran mesin untuk bot. Saat Anda menguji bot, konsol menggunakan API runtime untuk mengirim input pengguna kembali ke Amazon Lex. Amazon Lex kemudian menggunakan model pembelajaran mesin untuk menafsirkan input pengguna.
Butuh beberapa waktu untuk menyelesaikan pembangunan.
1. Untuk menguji bot, di jendela **Test Bot**, mulailah berkomunikasi dengan bot Amazon Lex Anda.
+ Misalnya, Anda dapat mengatakan atau mengetik yang berikut ini:
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-110.png)
+ Gunakan contoh ucapan yang Anda konfigurasikan dalam `OrderPizza` intent untuk menguji bot. Misalnya, berikut ini adalah salah satu contoh ucapan yang Anda konfigurasikan untuk maksud tersebut`PizzaOrder`:
```
I want a {size} {crust} crust {pizzaKind} pizza
```
Untuk mengujinya, ketik yang berikut ini:
```
I want a large thin crust cheese pizza
```
Saat Anda mengetik “Saya ingin memesan pizza,” Amazon Lex mendeteksi intent ()`OrderPizza`. Kemudian, Amazon Lex meminta informasi slot.
Setelah Anda memberikan semua informasi slot, Amazon Lex memanggil fungsi Lambda yang Anda konfigurasikan untuk maksud tersebut.
Fungsi Lambda mengembalikan pesan (“Oke, saya telah memesan...”) ke Amazon Lex, yang Amazon Lex kembalikan kepada Anda..
## Memeriksa Respon
Di bawah jendela obrolan terdapat panel yang memungkinkan Anda memeriksa respons dari Amazon Lex. Panel memberikan informasi komprehensif tentang keadaan bot Anda yang berubah saat Anda berinteraksi dengan bot Anda. Isi panel menunjukkan kepada Anda keadaan operasi saat ini.
+ **Status Dialog** — Keadaan percakapan saat ini dengan pengguna. Bisa jadi`ElicitIntent`,`ElicitSlot`, `ConfirmIntent` atau`Fulfilled`.
+ **Ringkasan** - Menampilkan tampilan dialog yang disederhanakan yang menunjukkan nilai slot untuk maksud yang dipenuhi sehingga Anda dapat melacak arus informasi. Ini menunjukkan nama maksud, jumlah slot dan jumlah slot yang diisi, dan daftar semua slot dan nilai yang terkait. Lihat gambar berikut:
![\[Panel inspeksi ringkasan respons konsol Amazon Lex.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-115.png)
+ **Detail** - Menunjukkan respons JSON mentah dari chatbot untuk memberi Anda pandangan yang lebih dalam tentang interaksi bot dan status dialog saat ini saat Anda menguji dan men-debug chatbot Anda. Jika Anda mengetik di jendela obrolan, panel inspeksi menunjukkan respons JSON dari operasi. [PostText](API_runtime_PostText.md) Jika Anda berbicara dengan jendela obrolan, panel inspeksi menunjukkan header respons dari operasi. [PostContent](API_runtime_PostContent.md) Lihat gambar berikut:
![\[Panel inspeksi respons konsol.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs1-116.png)
## Langkah Selanjutnya
[Langkah 4 (Opsional): Bersihkan](gs2-clean-up.md)
# Langkah 4 (Opsional): Bersihkan
Hapus sumber daya yang Anda buat dan bersihkan akun Anda untuk menghindari biaya lebih banyak untuk sumber daya yang Anda buat.
Anda hanya dapat menghapus sumber daya yang tidak digunakan. Misalnya, Anda tidak dapat menghapus jenis slot yang direferensikan oleh maksud. Anda tidak dapat menghapus maksud yang direferensikan oleh bot.
Hapus sumber daya dalam urutan berikut:
+ Hapus bot untuk membebaskan sumber daya maksud.
+ Hapus maksud untuk membebaskan sumber daya jenis slot.
+ Hapus jenis slot terakhir.
**Untuk membersihkan akun Anda**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Dari daftar bot, pilih **PizzaOrderingBot**.
1. Untuk menghapus bot, pilih **Hapus**, lalu pilih **Lanjutkan**.
1. Di panel kiri, pilih **Maksud**.
1. Dalam daftar maksud, pilih **OrderPizza**.
1. Untuk menghapus maksud, pilih **Hapus**, lalu pilih **Lanjutkan**.
1. Di menu sebelah kiri, pilih **jenis Slot**.
1. Dalam daftar jenis slot, pilih **Kerak**.
1. Untuk menghapus jenis slot, pilih **Hapus**, lalu pilih **Lanjutkan**.
1. Ulangi [Step 8](#chooseSlots) dan [Step 9](#deleteSlots) untuk jenis `Sizes` dan `PizzaKind` slot.
Anda telah menghapus semua sumber daya yang Anda buat dan membersihkan akun Anda.
## Langkah Berikutnya
+ [Publikasikan Versi dan Buat Alias](https://docs.aws.amazon.com/lex/latest/dg/gettingstarted-ex3.html)
+ [Buat bot Amazon Lex dengan AWS Command Line Interface](https://docs.aws.amazon.com/lex/latest/dg/gs-cli.html)
# Latihan 3: Publikasikan Versi dan Buat Alias
Dalam Memulai Latihan 1 dan 2, Anda membuat bot dan mengujinya. Dalam latihan ini, Anda melakukan hal berikut:
+ Publikasikan versi baru bot. Amazon Lex mengambil salinan snapshot dari `$LATEST` versi tersebut untuk menerbitkan versi baru.
+ Buat alias yang menunjuk ke versi baru.
Untuk informasi selengkapnya tentang pembuatan versi dan alias, lihat. [Pembuatan Versi dan Alias](versioning-aliases.md)
Lakukan hal berikut untuk mempublikasikan versi bot yang Anda buat untuk latihan ini:
1. Di konsol Amazon Lex, pilih salah satu bot yang Anda buat.
Verifikasi bahwa konsol menunjukkan `$LATEST` sebagai versi bot di sebelah nama bot.
1. Pilih **Terbitkan**.
1. Pada *botname* wizard **Publish**, tentukan alias**BETA**, lalu pilih **Publish**.
1. Verifikasi bahwa konsol Amazon Lex menunjukkan versi baru di sebelah nama bot, seperti pada gambar berikut.
![\[\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/gs2-final.png)
Sekarang Anda memiliki bot yang berfungsi dengan versi yang diterbitkan dan alias, Anda dapat menyebarkan bot (di aplikasi seluler Anda atau mengintegrasikan bot dengan Facebook Messenger). Sebagai contoh, lihat [Mengintegrasikan Amazon Lex Bot dengan Facebook Messenger](fb-bot-association.md).