Aviso de fim do suporte: em 15 de setembro de 2025, o suporte para o Amazon Lex V1 AWS será interrompido. Após 15 de setembro de 2025, você não poderá mais acessar o console do Amazon Lex V1 nem os respectivos recursos. Se você estiver usando o Amazon Lex V2, consulte o [guia do Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) em vez disso.
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Conceitos básicos do Amazon Lex
O Amazon Lex fornece operações de API que você pode integrar com os aplicativos existentes. Para obter uma lista das operações compatíveis, consulte [Referência da API](API_Reference.md). Você pode usar qualquer uma das opções a seguir:
+ AWS SDK — Ao usar o, SDKs suas solicitações para o Amazon Lex são automaticamente assinadas e autenticadas usando as credenciais que você fornece. Esta é a escolha recomendada para a criação de suas aplicações.
+ AWS CLI — Você pode usar o AWS CLI para acessar qualquer recurso do Amazon Lex sem precisar escrever nenhum código.
+ Console da AWS: o console é a maneira mais fácil de começar a testar e usar o Amazon Lex
Se você é novo no Amazon Lex, recomendamos que leia [Amazon Lex: como funciona](how-it-works.md) antes de continuar.
**Topics**
+ [Etapa 1: configurar uma AWS conta e criar um usuário administrador](gs-account.md)
+ [Etapa 2: Configurar o AWS Command Line Interface](gs-set-up-cli.md)
+ [Etapa 3: Conceitos básicos (console)](gs-console.md)
+ [Etapa 4: Conceitos básicos (AWS CLI)](gs-cli.md)
# Etapa 1: configurar uma AWS conta e criar um usuário administrador
Antes de usar o Amazon Lex pela primeira vez, conclua as seguintes tarefas:
1. [Inscreva-se para AWS](#gs-account-create)
1. [Criar um usuário](#gs-account-user)
## Inscreva-se para AWS
Se você já tiver uma AWS conta, pule essa tarefa.
Quando você se inscreve no Amazon Web Services (AWS), sua AWS conta é automaticamente cadastrada em todos os serviços AWS, incluindo o Amazon Lex. A cobrança incorrerá apenas pelos serviços utilizados.
Com o Amazon Lex, você paga apenas pelos recursos que usa. Se você for um cliente novo da AWS , poderá começar a usar o Amazon Lex gratuitamente. Para mais informações, consulte [Nível de uso gratuito da AWS](https://aws.amazon.com/free/).
Se você já tiver uma AWS conta, vá para a próxima tarefa. Se ainda não possuir uma conta da AWS , use o procedimento a seguir para criar uma.
**Para criar uma AWS conta**
1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
Anote o ID AWS da sua conta porque você precisará dele para a próxima tarefa.
## Criar um usuário
Serviços em AWS, como o Amazon Lex, exigem que você forneça credenciais ao acessá-los para que o serviço possa determinar se você tem permissões para acessar os recursos de propriedade desse serviço. O console requer sua senha. No entanto, não recomendamos que você acesse AWS usando as credenciais da sua AWS conta. Em vez disso, recomendamos o uso de:
+ Use AWS Identity and Access Management (IAM) para criar um usuário
+ Adicione o usuário a um grupo do IAM com permissões de administrador
+ Conceda permissões de administrador ao usuário do que você criou.
Em seguida, você pode acessar AWS usando um URL especial e as credenciais do usuário.
Os exercícios de conceitos básicos deste guia pressupõem que você tenha um usuário (`adminuser`) com privilégios de administrador. Siga o procedimento para criar `adminuser` na conta.
**Para criar um usuário administrador e fazer login no console**
1. Crie um usuário administrador chamado `adminuser`, em sua conta da AWS . Para obter instruções, consulte [Criar seu primeiro grupo de administradores e usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) no *Guia do usuário do IAM*.
1. Como usuário, você pode fazer login no Console de gerenciamento da AWS usando um URL especial. Para obter mais informações, consulte [Como os usuários fazem login em sua conta](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_how-users-sign-in.html) no *Guia do usuário do IAM*.
Para mais informações sobre IAM, consulte o seguinte:
+ [AWS Identity and Access Management (IAM)](https://aws.amazon.com/iam/)
+ [Começando a usar o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html)
+ [Guia do usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
## Próxima etapa
[Etapa 2: Configurar o AWS Command Line Interface](gs-set-up-cli.md)
# Etapa 2: Configurar o AWS Command Line Interface
Se você preferir usar o Amazon Lex com o AWS Command Line Interface (AWS CLI), faça o download e configure-o.
**Importante**
Você não precisa AWS CLI executar as etapas dos exercícios de introdução. No entanto, alguns dos últimos exercícios neste guia usam a AWS CLI. Se você preferir começar usando o console, ignore esta etapa e vá para [Etapa 3: Conceitos básicos (console)](gs-console.md). Mais tarde, quando precisar do AWS CLI, volte aqui para configurá-lo.
**Para configurar o AWS CLI**
1. Faça download e configure a AWS CLI. Para obter instruções, consulte os seguintes tópicos no *Manual do usuário do AWS Command Line Interface *:
+ [Configurando o AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
+ [Configurando a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Adicione um perfil nomeado para o usuário administrador ao final do arquivo de AWS CLI configuração. Você usa esse perfil ao executar AWS CLI comandos. Para obter mais informações sobre perfis nomeados, consulte [Perfis nomeados](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) no *Guia do usuário da AWS Command Line Interface *.
```
[profile adminuser]
aws_access_key_id = adminuser access key ID
aws_secret_access_key = adminuser secret access key
region = aws-region
```
Para obter uma lista das AWS regiões disponíveis, consulte [Regiões e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html) no *Referência geral da Amazon Web Services*.
1. Verifique a configuração digitando o comando de ajuda na solicitação de comando:
```
aws help
```
##
[Etapa 3: Conceitos básicos (console)](gs-console.md)
# Etapa 3: Conceitos básicos (console)
A maneira mais fácil de aprender a usar o Amazon Lex é usar o console. Para começar, criamos os seguintes exercícios que usam o console:
+ Exercício 1: Criar um bot do Amazon Lex usando um esquema, um bot predefinido que fornece toda a configuração de bot necessária. Você faz apenas um mínimo de trabalho para testar a end-to-end configuração.
Além disso, você usa o blueprint da função Lambda, fornecido por AWS Lambda, para criar uma função Lambda. A função é um hook de código que usa um código predefinido compatível com o bot.
+ Exercício 2: criar um bot personalizado criando e configurando manualmente um bot. Você também pode criar uma função do Lambda como um hook de código. Um código de exemplo é fornecido.
+ Exercício 3: publicar um bot e, em seguida, criar uma nova versão. Como parte deste exercício, você criará um alias que aponte para a versão do bot.
**Topics**
+ [Exercício 1: Criar um bot do Amazon Lex usando um esquema (Console).](gs-bp.md)
+ [Exercício 2: criar um bot personalizado do Amazon Lex](getting-started-ex2.md)
+ [Exercício 3: publique uma versão e crie um alias](gettingstarted-ex3.md)
# Exercício 1: Criar um bot do Amazon Lex usando um esquema (Console).
Neste exercício, você faz o seguinte:
+ Crie seu primeiro bot do Amazon Lex e teste-o no console do Amazon Lex.
Para este exercício, você usa o **OrderFlowers**modelo. Para obter mais informações sobre esquemas, consulte [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).
+ Crie uma AWS Lambda função e teste-a no console Lambda. Ao processar uma solicitação, seu bot chama a função do Lambda. Para este exercício, você usa um blueprint do Lambda (**lex-order-flowers-python**) fornecido no AWS Lambda console para criar sua função do Lambda. O código de esquema ilustra como você pode usar a mesma função do Lambda para realizar a inicialização e validação, e cumprir a intenção `OrderFlowers`.
+ Atualize o bot para adicionar a função do Lambda como o hook de código para cumprir a intenção. Teste a end-to-end experiência.
As seções a seguir explicam o que os esquemas fazem.
## Bot do Amazon Lex: visão geral do esquema
Você usa o **OrderFlowers**blueprint para criar um bot do Amazon Lex. Para obter mais informações sobre a estrutura de um bot, consulte. [Amazon Lex: como funciona](how-it-works.md) O bot é pré-configurado da seguinte forma:
+ **Intenção** — OrderFlowers
+ **Tipos de slot** – Um tipo de slot personalizado chamado `FlowerTypes` com valores de enumeração: `roses`, `lilies` e `tulips`.
+ **Slots** – a intenção requer as seguintes informações (slots) antes de o bot cumprir a intenção.
+ `PickupTime` (tipo integrado AMAZON.TIME)
+ `FlowerType`(tipo FlowerTypes personalizado)
+ `PickupDate` (tipo integrado AMAZON.DATE)
+ **Utterance**: a seguinte amostra de declaração indica a intenção do usuário:
+ "Gostaria de escolher flores."
+ "Gostaria de pedir algumas flores."
+ **Prompts** – Após o bot identificar a intenção, ele usa os seguintes prompts para preencher slots:
+ Prompt do slot `FlowerType` – "Que tipo de flores você deseja pedir?"
+ Solicite a `PickupDate` vaga — “Em que dia você quer que o \$1FlowerType\$1 seja retirado?”
+ Solicitar o `PickupTime` slot — “A que horas você deseja que o \$1FlowerType\$1 seja retirado?”
+ Declaração de confirmação — “Ok, seu \$1FlowerType\$1 estará pronto para retirada até \$1PickupTime\$1 em \$1PickupDate\$1. Tudo bem?"
## AWS Lambda Função: Resumo do plano
A função do Lambda neste exercício executa a inicialização e a validação e as tarefas de atendimento. Portanto, após criar a função do Lambda, você deve atualizar a configuração da intenção especificando a mesma função do Lambda como um hook de código para lidar com a inicialização e a validação e as tarefas de atendimento.
+ Como hook de inicialização e validação, a função do Lambda executa uma validação básica. Por exemplo, se o usuário fornecer uma hora de retirada fora do horário comercial normal, a função do Lambda direcionará o Amazon Lex para solicitar que o usuário insira o horário novamente.
+ Como parte do hook de código de atendimento, a função do Lambda retorna uma mensagem resumida indicando que o pedido de flores foi feito (ou seja, a intenção é atendida).
**Próxima etapa**
[Etapa 1: criar um bot Amazon Lex (console)](gs-bp-create-bot.md)
# Etapa 1: criar um bot Amazon Lex (console)
Para este exercício, crie um bot para pedir flores, chamado OrderFlowersBot.
Para criar um bot Amazon Lex (console)
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Se este for o seu primeiro bot, selecione **Get Started (Conceitos básicos)**; caso contrário, na página **Bots**, escolha **Criar**.
1. Na página **Create your Lex bot**, forneça as informações a seguir e escolha **Create**.
+ Escolha o esquema **OrderFlowers**.
+ Deixe o nome padrão do bot (OrderFlowers).
+ Em **COPPA**, selecione **No**.
+ Para **Armazenamento de declarações do usuário**, escolha a resposta apropriada.
1. Escolha **Criar**. O console faz as solicitações necessárias ao Amazon Lex para salvar a configuração. Em seguida, o console exibe a janela do editor de bot.
1. Aguarde a confirmação de criação do bot.
1. Teste o bot.
**nota**
Você pode testar o bot digitando o texto na janela de teste ou, em navegadores compatíveis, selecionando o botão de microfone na janela de teste e falando.
Use o texto de exemplo a seguir para começar uma conversa com o bot e encomendar flores:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/OrderFlowers-NoLambda.png)
Nesta entrada, o bot infere a intenção `OrderFlowers` e solicita os dados de slot. Quando você fornecer todas os dados de slot necessários, o bot cumprirá a intenção (`OrderFlowers`) retornando todas as informações para o aplicativo cliente (neste caso, o console). O console mostra as informações na janela de teste.
Especificamente:
+ Na instrução "Em que dia você deseja que as rosas sejam entregues?", o termo "rosas" aparece porque a solicitação para o slot `pickupDate` é configurada usando substituições, `{FlowerType}`. Verifique isso no console.
+ A instrução "Está bem, as rosas estarão prontas..." é a solicitação de confirmação que você configurou.
+ A última instrução ("`FlowerType:roses...`") contém apenas os dados do slot que são retornados ao cliente, neste caso, na janela de teste. No próximo exercício, você usará uma função do Lambda para atender à intenção. Nesse caso, você recebe uma mensagem indicando que o pedido foi atendido.
**Próxima etapa**
[Etapa 2 (opcional): revisar os detalhes do fluxo de informações (console)](gs-bp-details-two-runtime-apis.md)
# Etapa 2 (opcional): revisar os detalhes do fluxo de informações (console)
Esta seção explica o fluxo de informações entre um cliente e o Amazon Lex para cada entrada do usuário em nossa conversa de exemplo.
O exemplo usa a janela de teste do console para a conversa com o bot.
**Para abrir a janela de teste do Amazon Lex**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Escolha o bot a ser testado.
1. No lado direito do console, escolha **Testar chatbot**.
Para ver o fluxo de informações do conteúdo falado ou digitado, escolha o tópico apropriado.
**Topics**
+ [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md)
+ [Etapa 2b (opcional): revisar os detalhes do fluxo de informações digitado (console)](gs-bp-details-part1.md)
# Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex quando o cliente usa fala para enviar solicitações. Para obter mais informações, consulte [PostContent](API_runtime_PostContent.md).
1. O usuário diz: Eu gostaria de encomendar flores.
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI da solicitação fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). `content` indica que esta é uma solicitação da API `PostContent` (não uma solicitação `PostText`).
+ Cabeçalhos de solicitação
+ `x-amz-lex-session-attributes`: o valor codificado em base64 representa "\$1\$1". Quando o cliente faz a primeira solicitação, não há atributos de sessão.
+ `Content-Type` – reflete o formato de áudio.
+ Corpo da solicitação – o stream de áudio de entrada do usuário ("Eu gostaria de encomendar flores.").
**nota**
Se o usuário escolher enviar texto ("Eu gostaria de encomendar flores") para a API `PostContent` em vez falar, o corpo da solicitação será a entrada do usuário. O cabeçalho `Content-Type` é definido adequadamente:
```
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. No fluxo de entrada, o Amazon Lex detecta a intenção (`OrderFlowers`). Em seguida, ele escolhe um dos slots da intenção (neste caso, o `FlowerType`) e um de seus prompts de seleção de valor e envia uma resposta com os seguintes cabeçalhos:
```
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==
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-input-transcript` – fornece a transcrição do áudio (entrada do usuário) da solicitação
+ `x-amz-lex-message`: fornece a transcrição do áudio que Amazon Lex retornou na resposta
+ `x-amz-lex-slots` – a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: rosas
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário (rosas). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `FlowerType`). Primeiro, o Amazon Lex atualiza o valor de slot para a intenção atual. Em seguida, ele escolhe outro slot (`PickupDate`), juntamente com uma das mensagens de solicitação (Quando você deseja pegar as rosas?) e retorna uma resposta com os seguintes cabeçalhos:
```
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=
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: amanhã
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("amanhã"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `PickupDate`). O Amazon Lex atualiza o valor de slot (`PickupDate`) para a intenção atual. Em seguida, ele escolhe outro slot para escolher o valor para (`PickupTime`) e um dos prompts de seleção de valor (Quando você deseja receber as rosas em 18/03/2017?), e retorna uma resposta com os seguintes cabeçalhos:
```
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
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: 18h
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("18h"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `PickupTime`). Primeiro, ele atualiza o valor do slot para a intenção atual.
Agora, o Amazon Lex detecta que tem informações de todos os slots. No entanto, a intenção `OrderFlowers` é configurada com uma mensagem de confirmação. Portanto, o Amazon Lex precisa de uma confirmação explícita do usuário para poder prosseguir para o atendimento da intenção. Ele envia uma resposta com os seguintes cabeçalhos solicitando a confirmação antes de encomendar as flores:
```
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
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: Sim
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("Sim"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada e entende que o usuário deseja prosseguir com o pedido. A intenção `OrderFlowers` é configurada com `ReturnIntent` como a atividade de cumprimento. Isso orienta o Amazon Lex a retornar todos os dados de intenção ao cliente. O Amazon Lex retorna uma resposta com o seguinte:
```
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==
```
O cabeçalho de resposta `x-amz-lex-dialog-state` é definido como `ReadyForFulfillment`. O cliente pode, então, cumprir a intenção.
1. Agora, teste novamente o bot. Para estabelecer um novo contexto (usuário), escolha o link **Clear** no console. Forneça os dados para a intenção `OrderFlowers` e inclua alguns dados inválidos. Por exemplo:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados)
+ Ontem como o dia em que você deseja receber as flores
Observe que o bot aceita esses valores, pois você não tem nenhum código para inicializar e validar os dados do usuário. Na próxima seção, adicione uma função do Lambda para fazer isso. Observe o seguinte sobre a função do Lambda:
+ Ela valida dados de slot após cada entrada do usuário. Ela cumpre a intenção no final. Ou seja, o bot processa o pedido de flores e retorna uma mensagem para o usuário, em vez de simplesmente retornar dados do slot para o cliente. Para obter mais informações, consulte [Uso de funções do Lambda](using-lambda.md).
+ Ela também define os atributos da sessão. Para mais informações sobre atributos de sessão, consulte [PostText](API_runtime_PostText.md).
Ao concluir a seção Conceitos básicos, você pode fazer os exercícios adicionais ([Exemplos adicionais: criação de bots do Amazon Lex](additional-exercises.md)). O [Reservar uma viagem](ex-book-trip.md) usa atributos de sessão para compartilhar informações entre intenções para iniciar uma conversa dinâmica com o usuário.
**Próxima etapa**
[Etapa 3: Crie uma função do Lambda (console)](gs-bp-create-lambda-function.md)
# Etapa 2b (opcional): revisar os detalhes do fluxo de informações digitado (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex, em que o cliente usa a API `PostText` para enviar solicitações. Para obter mais informações, consulte [PostText](API_runtime_PostText.md).
1. O usuário digita: Eu gostaria de encomendar flores.
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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": {}
}
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI de solicitação: fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). O `text` final indica que esta é uma solicitação de API `PostText` (e não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio. Quando o cliente faz a primeira solicitação, não há atributos de sessão. A função do Lambda as inicia posteriormente.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (`OrderFlowers`). Essa intenção não tem nenhum hook de código (ou seja, as funções do Lambda) para inicialização e validação do atendimento ou da entrada do usuário.
O Amazon Lex escolhe um dos slots (`FlowerType`) da intenção para obter o valor. Ele também seleciona uma das solicitações de escolha de valor para o slot (tudo parte da configuração de intenção) e, em seguida, envia a resposta a seguir de volta para o cliente. O console exibe a mensagem na resposta para o usuário.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-10.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: rosas
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `FlowerType`). O Amazon Lex atualiza o valor de slot para a intenção atual e escolhe outro slot (`PickupDate`) junto com um de seus prompts de mensagens, “Em que dia você deseja que as rosas sejam entregues?”, `` para o slot.
Em seguida, o Amazon Lex retorna a seguinte resposta:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-20.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: amanhã
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `PickupDate`). O Amazon Lex atualiza o valor de slot (`PickupDate`) para a intenção atual. Ele escolhe outro slot para obter o valor para (`PickupTime`). Ele retorna uma das solicitações de escolha de valor, “Entregar as rosas a que horas em 05/01/2017?” `` para o cliente.
Em seguida, o Amazon Lex retorna a seguinte resposta:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-30.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: 18h
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `PickupTime`). Primeiro, o Amazon Lex atualiza o valor de slot para a intenção atual. Agora, o Amazon Lex detecta que tem informações de todos os slots.
A intenção `OrderFlowers` é configurada com uma mensagem de confirmação. Portanto, o Amazon Lex precisa de uma confirmação explícita do usuário para poder prosseguir para o atendimento da intenção. O Amazon Lex envia a seguinte mensagem para o cliente solicitando confirmação antes de encomendar as flores:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-40.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: Sim
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. Ele entende que o usuário deseja prosseguir com o pedido. A intenção `OrderFlowers` é configurada com `ReturnIntent` como a atividade de cumprimento (não há função do Lambda para cumprir a intenção). Portanto, o Amazon Lex retorna os dados do slot ao cliente.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-50.png)
O Amazon Lex definiu `dialogState` como `ReadyForFulfillment`. O cliente pode, então, cumprir a intenção.
1. Agora teste o bot novamente. Para isso, selecione o link **Clear** no console para estabelecer um novo contexto (de usuário). Agora, conforme você fornece dados para a intenção de encomenda de flores, tente fornecer dados inválidos. Por exemplo:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados).
+ Ontem como o dia em que você deseja receber as flores.
Observe que o bot aceita esses valores porque você não tem nenhum código para os dados initialize/validate do usuário. Na próxima seção, adicione uma função do Lambda para fazer isso. Observe o seguinte sobre a função do Lambda:
+ A função do Lambda valida os dados do slot depois de cada entrada do usuário. Ela cumpre a intenção no final. Ou seja, o bot processa o pedido de flores e retorna uma mensagem para o usuário, em vez de simplesmente retornar dados de slot para o cliente. Para obter mais informações, consulte [Uso de funções do Lambda](using-lambda.md).
+ A função do Lambda também define os atributos da sessão. Para mais informações sobre atributos de sessão, consulte [PostText](API_runtime_PostText.md).
Ao concluir a seção Conceitos básicos, você pode fazer os exercícios adicionais ([Exemplos adicionais: criação de bots do Amazon Lex](additional-exercises.md)). O [Reservar uma viagem](ex-book-trip.md) usa atributos de sessão para compartilhar informações entre intenções para iniciar uma conversa dinâmica com o usuário.
**Próxima etapa**
[Etapa 3: Crie uma função do Lambda (console)](gs-bp-create-lambda-function.md)
# Etapa 3: Crie uma função do Lambda (console)
Crie uma função Lambda (usando o **lex-order-flowers-python**blueprint) e execute a invocação de teste usando dados de eventos de amostra no console. AWS Lambda
Você retorna ao console do Amazon Lex e adiciona a função do Lambda como o hook de código para atender à intenção `OrderFlowers` no `OrderFlowersBot` que criou na seção anterior.
**Para criar a função do Lambda (console)**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Escolha a opção **Criar função**.
1. Na página **Create function (Criar função)**, selecione **Usar um blueprint (Usar um esquema)**. Digite **lex-** na caixa de texto do filtro e pressione `Enter` para localizar o esquema e selecione o esquema `lex-order-flowers-python`.
Os esquemas da função do Lambda são fornecidos em Node.js e em Python. Para este exercício, use o esquema baseado em Python.
1. Na página **Basic information (Informações básicas)**, faça o seguinte:
+ Digite o nome de uma função do Lambda (`OrderFlowersCodeHook`).
+ Em Perfil de execução, escolha **Criar um novo perfil com as permissões básicas do Lambda**.
+ Deixe os outros valores padrão.
1. Escolha a opção **Criar função**.
1. Se você estiver usando uma localidade diferente do inglês (EUA) (en-US), atualize os nomes das intenções conforme descrito em [Atualização de um esquema para uma localidade específica](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testar a função do Lambda.
1. Selecione **Select a test event (Selecionar um evento de teste)**, **Configure test events (Configurar eventos de teste)**.
1. Selecione **Amazon Lex Order Flowers (Flores do pedido do Amazon Lex)** da lista **Event template (Modelo do evento)**. Esse exemplo de evento corresponde ao request/response modelo Amazon Lex (consulte[Uso de funções do Lambda](using-lambda.md)). Dê um nome ao evento de teste (`LexOrderFlowersTest`).
1. Escolha **Criar**.
1. Selecione **Testar** para testar o hook de código.
1. Verifique se a função do Lambda foi executada com êxito. A resposta, neste caso, corresponde ao modelo de resposta do Amazon Lex.
**Próxima etapa**
[Etapa 4: Adicione a função do Lambda como hook de código (console)](gs-bp-create-integrate.md)
# Etapa 4: Adicione a função do Lambda como hook de código (console)
Nesta seção, você atualiza a configuração da OrderFlowers intenção de usar a função Lambda da seguinte forma:
+ Primeiro, use a função do Lambda como um hook de código para executar o cumprimento da intenção `OrderFlowers`. Você pode testar o bot e verificar se recebeu uma mensagem de cumprimento da função do Lambda. O Amazon Lex invoca a função do Lambda somente depois de você fornecer dados para todos os slots necessários para encomendar flores.
+ Configure a mesma função do Lambda como um hook de código para executar a inicialização e a validação. Teste e verifique se a função do Lambda executa a validação (conforme você fornece dados de slot).
**Para adicionar a função do Lambda como um hook de código (console)**
1. No console do Amazon Lex, selecione o **OrderFlowers**bot. O console mostra a **OrderFlowers**intenção. Verifique se a versão da intenção está definida como `$LATEST`, pois essa é a única versão que podemos modificar.
1. Adicione a função do Lambda como o hook de código de atendimento e teste-a.
1. No Editor, escolha **função AWS Lambda ** como **Atendimento** e selecione a função do Lambda que você criou na etapa anterior (`OrderFlowersCodeHook`). Escolha **OK** para ter permissão do Amazon Lex para invocar a função do Lambda.
Você está configurando essa função do Lambda como um hook de código para cumprir a intenção. O Amazon Lex invoca essa função apenas após ter todos os dados de slot necessários do usuário para cumprir a intenção.
1. Especifique uma **Goodbye message**.
1. Escolha **Criar**.
1. Teste o bot usando a conversa anterior.
A última declaração "Obrigado, seu pedido de rosas..." é uma resposta da função do Lambda que você configurou como um hook de código. Na seção anterior, não havia função do Lambda. Agora, você está usando uma função do Lambda para realmente cumprir a intenção `OrderFlowers`.
1. Adicione a função do Lambda como um hook de código de inicialização e validação e teste.
O exemplo de código da função do Lambda que você está usando pode executar a validação e o atendimento da entrada do usuário. O evento de entrada que a função do Lambda recebe tem um campo (`invocationSource`) que o código usa para determinar qual parte do código executar. Para obter mais informações, consulte [Evento de entrada de função do Lambda e formato de resposta](lambda-input-response-format.md).
1. Selecione a versão \$1LATEST da intenção `OrderFlowers`. Essa é a única versão que você pode atualizar.
1. No Editor, escolha **Initialization and validation** em **Options**.
1. Novamente, selecione a mesma função do Lambda.
1. Escolha **Criar**.
1. Teste o bot.
Agora você está pronto para conversar com o Amazon Lex do seguinte modo. Para testar a parte da validação, escolha 6 PM, e a função do Lambda retornará uma resposta ("Our business hours are from 10 AM to 5 PM.”), e enviará prompts à você novamente. Depois de fornecer todos os dados de slot válidos, a função do Lambda atende a ordem.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Próxima etapa**
[Etapa 5 (opcional): Revise os detalhes do fluxo de informações (console)](gs-bp-details-after-lambda.md)
# Etapa 5 (opcional): Revise os detalhes do fluxo de informações (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex para cada entrada do usuário, incluindo a integração da função do Lambda.
**nota**
A seção supõe que o cliente envia solicitações ao Amazon Lex usando a API de runtime `PostText` e mostra os detalhes da solicitação e da resposta adequadamente. Para obter um exemplo do fluxo de informações entre o cliente e o Amazon Lex no qual o cliente usa a API `PostContent`, consulte [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md).
Para obter mais informações sobre a API de runtime `PostText` e detalhes adicionais sobre as solicitações e respostas mostradas nas etapas a seguir, consulte [PostText](API_runtime_PostText.md).
1. Usuário: "Eu gostaria de encomendar flores."
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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": {}
}
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI de solicitação: fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). O `text` final indica que esta é uma solicitação de API `PostText` (e não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio. Quando o cliente faz a primeira solicitação, não há atributos de sessão. A função do Lambda as inicia posteriormente.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (`OrderFlowers`). Essa intenção é configurada com uma função do Lambda como um hook de código para inicialização e validação dos dados do usuário. Portanto, o Amazon Lex invoca aquela função do Lambda especificando as seguintes informações como dados de evento:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Formato de eventos de entrada](lambda-input-response-format.md#using-lambda-input-event-format).
Além das informações enviadas pelo cliente, o Amazon Lex também inclui os seguintes dados adicionais:
+ `messageVersion`: atualmente, o Amazon Lex oferece suporte apenas à versão 1.0.
+ `invocationSource`: indica o objetivo da invocação da função do Lambda. Nesse caso, é para executar os dados de inicialização e validação do usuário. Neste ponto, o Amazon Lex sabe que o usuário não forneceu todos os dados do slot para atender à intenção.
+ Informações `currentIntent` com todos os valores de slot definidos como nulo.
1. No momento, todos os valores de slot são nulos. Não há nada para a função do Lambda validar. A função do Lambda retorna a seguinte resposta para Amazon Lex:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Para obter mais informações sobre o formato de resposta, consulte [Formato de resposta](lambda-input-response-format.md#using-lambda-response-format).
Observe o seguinte:
+ `dialogAction.type`: ao definir esse valor para `Delegate`, a função do Lambda delega a responsabilidade de decidir a próxima ação a Amazon Lex.
**nota**
Se a função do Lambda detectar qualquer coisa na validação dos dados do usuário, ela instruirá o Amazon Lex sobre o que fazer em seguida, conforme mostrado nas próximas etapas.
1. De acordo com o `dialogAction.type`, o Amazon Lex decide a próxima ação. Como nenhum dos slots estão preenchidos, ele decide escolher o valor para o slot `FlowerType`. Ele seleciona uma das solicitações de escolha de valor ("What type of flowers would you like to order? (Que tipo de flores você deseja encomendar?)") para este slot e envia a resposta a seguir de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-10.png)
O cliente exibe a mensagem na resposta.
1. Usuário: rosas
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
No corpo da solicitação, o `inputText` fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. O Amazon Lex primeiro interpreta o `inputText` no contexto da intenção atual. O serviço lembra que havia solicitado ao usuário específico informações sobre o slot `FlowerType`. Ele atualiza o valor de slot na intenção atual e invoca a função do Lambda com os seguintes dados do evento:
```
{
"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"
}
}
```
Observe o seguinte:
+ `invocationSource` – continua sendo `DialogCodeHook` (estamos simplesmente validando os dados do usuário).
+ `currentIntent.slots`: o Amazon Lex atualizou o slot `FlowerType` para rosas.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ele reconhece `roses` como um valor de slot válido (e define `Price` como um atributo de sessão) e retorna a seguinte resposta ao Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Observe o seguinte:
+ `sessionAttributes`: a função do Lambda adicionou o `Price` (das rosas) como atributo de sessão.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
1. De acordo com o `dialogAction.type`, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (`PickupDate`) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona um dos prompts de mensagens ("Em que dia você quer que as rosas sejam retiradas?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-20.png)
O cliente simplesmente exibe a mensagem na resposta – "Em que dia você deseja receber as rosas?."
1. Usuário: amanhã
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
No corpo da solicitação, `inputText` fornece entradas do usuário e o cliente passa os atributos de sessão de volta ao serviço.
1. O Amazon Lex lembra do contexto para o qual estava escolhendo dados para o slot `PickupDate`. Nesse contexto, ele sabe que o valor `inputText` é para o slot `PickupDate`. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"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"
}
}
```
O Amazon Lex atualizou o `currentIntent.slots` definindo o valor `PickupDate`. Observe também que o serviço passa o `sessionAttributes` como é para a função do Lambda.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot `PickupDate` é válido e retorna a seguinte resposta a Amazon Lex:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Observe o seguinte:
+ `sessionAttributes` – sem alteração.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, e a função do Lambda direciona Amazon Lex para escolher a próxima ação.
1. De acordo com o `dialogAction.type`, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (`PickupTime`) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona uma das mensagens de aviso ("Entregar as rosas a que horas em 05/01/2017?") para esse slot de acordo com a configuração de intenção e envia a seguinte resposta de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-30.png)
O cliente exibe a mensagem na resposta: "Entregar as rosas em que horário em 05/01/2017?"
1. Usuário: 16h
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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"
}
}
```
No corpo da solicitação, `inputText` fornece entradas do usuário. O cliente passa o `sessionAttributes` na solicitação.
1. O Amazon Lex entende o contexto. Ele entende que estava escolhendo dados para o slot `PickupTime`. Neste contexto, ele sabe que o valor `inputText` é para o slot `PickupTime`. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"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"
}
}
```
O Amazon Lex atualizou o `currentIntent.slots` definindo o valor `PickupTime`.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot `PickupDate` é válido e retorna a seguinte resposta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Observe o seguinte:
+ `sessionAttributes` – nenhuma alteração no atributo de sessão.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
1. Neste ponto, o Amazon Lex sabe que tem todos os dados do slot. Essa intenção é configurada com um prompt de confirmação. Portanto, o Amazon Lex envia a seguinte resposta ao usuário solicitando confirmação antes de atender a intenção:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-45.png)
O cliente simplesmente exibe a mensagem na resposta e aguarda a resposta do usuário.
1. Usuário: Sim
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. O Amazon Lex entende que o usuário deseja prosseguir com o pedido. Dessa vez, o Amazon Lex invoca a função do Lambda para cumprir a intenção enviando o seguinte evento, que define o `invocationSource` como `FulfillmentCodeHook` caso ele envie para a função do Lambda. O Amazon Lex também define o `confirmationStatus` como `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"
}
}
```
Observe o seguinte:
+ `invocationSource`: dessa vez, o Amazon Lex define esse valor como `FulfillmentCodeHook`, direcionando a função do Lambda a atender à intenção.
+ `confirmationStatus`: é definido como `Confirmed`.
1. Dessa vez, a função do Lambda cumpre a intenção `OrderFlowers` e retorna a seguinte resposta:
```
{
"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"
}
}
}
```
Observe o seguinte:
+ Define o `dialogAction.type`: a função do Lambda define esse valor como `Close`, direcionando Amazon Lex para não esperar uma resposta do usuário.
+ `dialogAction.fulfillmentState` – é definido como Fulfilled e inclui uma `message` adequada para transmitir para o usuário.
1. Amazon Lex analisa o `fulfillmentState` e envia a resposta seguinte de volta para o cliente.
Em seguida, o Amazon Lex retorna o seguinte ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-48.png)
Observe que:
+ `dialogState`: o Amazon Lex define esse valor como `fulfilled`.
+ `message`: é a mesma mensagem que a função do Lambda forneceu.
O cliente exibe a mensagem.
1. Agora teste o bot novamente. Para estabelecer um novo contexto (de usuário), selecione o link **Clear** na janela de teste. Agora, forneça dados de slot inválidos para a intenção `OrderFlowers`. Desta vez, a função do Lambda executa a validação dos dados, redefine os valores dos dados do slot inválidos como nulos e pede ao Amazon Lex para solicitar dados válidos ao usuário. Por exemplo, tente o seguinte:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados).
+ Ontem como o dia em que você deseja receber as flores.
+ Após fazer o pedido, digite outro tipo de flor em vez de responder "sim" para confirmar o pedido. Em resposta, a função do Lambda atualiza o `Price` no atributo da sessão mantendo um total cumulativo de encomendas de flores.
A função do Lambda também executará a atividade de cumprimento.
**Próxima etapa**
[Etapa 6: Atualize a configuração de intenção para adicionar uma declaração (console)](gs-bp-utterance.md)
# Etapa 6: Atualize a configuração de intenção para adicionar uma declaração (console)
O bot `OrderFlowers` é configurado com apenas duas declarações. Isso fornece informações limitadas ao Amazon Lex para criar um modelo de Machine Learning que reconhece e responde à intenção do usuário. Tente digitar "Desejo pedir flores" na janela de teste. O Amazon Lex não reconhece o texto e responde com "Eu não entendi, o que você gostaria de fazer?" Você pode melhorar o modelo de Machine Learning adicionando mais declarações.
![\[A janela de teste mostra a declaração ausente.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-120.png)
Cada declaração que você adiciona fornece ao Amazon Lex mais informações sobre como responder aos usuários. Você não precisa adicionar uma declaração exata. O Amazon Lex generaliza a partir dos exemplos que você fornece para reconhecer correspondências exatas e entradas semelhantes.
**Para adicionar uma declaração (console)**
1. Adicione a declaração "Quero flores" à intenção digitando-o na seção **Amostra de declarações** do editor de intenção e, em seguida, clicando no ícone de mais (\$1) próximo a nova declaração.
![\[O editor de intenção com a nova declaração.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-130.png)
1. Crie seu bot para incorporar a alteração. Escolha **Build** e, em seguida, escolha **Build** novamente.
1. Teste o bot para confirmar se ele reconheceu a nova declaração. Na janela de teste, como na imagem a seguir, digite "Quero pedir flores". O Amazon Lex reconhece a frase e responde com "Que tipo de flores você gostaria de pedir?"
![\[O editor de intenção reconhece a nova declaração.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-140.png)
**Próxima etapa**
[Etapa 7 (opcional): Limpe (console)](gs-bp-cleaning-up.md)
# Etapa 7 (opcional): Limpe (console)
Agora, exclua os recursos que você criou e limpe sua conta.
Você só pode excluir os recursos que não estão em uso. Em geral, você deve excluir recursos na seguinte ordem:
+ Exclua bots para liberar recursos de intenção.
+ Exclua intenções para liberar recursos de tipo de slot.
+ Exclua tipos de slot por último.
**Para limpar sua conta (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Na lista de bots, escolha a caixa de seleção ao lado de **OrderFlowers**.
1. Para excluir o bot, escolha **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
1. No painel à esquerda, selecione **Intents**.
1. Na lista de intenções, escolha **OrderFlowersIntent**.
1. Para excluir a intenção, selecione **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
1. No painel esquerdo, escolha **Slot types**.
1. Na lista de tipos de slot, escolha **Flowers**.
1. Para excluir o tipo de slot, selecione **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
Você removeu todos os recursos Amazon Lex que criou e limpou sua conta. Se desejar, você pode usar o [console do Lambda](https://console.aws.amazon.com/lambda) para excluir a função do Lambda usada neste exercício.
# Exercício 2: criar um bot personalizado do Amazon Lex
Neste exercício, você usa o console do Amazon Lex para criar um bot personalizado para encomendar pizza (`OrderPizzaBot`). Você configura o bot adicionando uma intenção personalizada (`OrderPizza`), definindo tipos de slot personalizados e definindo os slots necessários para um pedido de pizza (massa da pizza, tamanho e assim por diante). Para obter mais informações sobre tipos de slot e slots, consulte [Amazon Lex: como funciona](how-it-works.md).
**Topics**
+ [Etapa 1: Criar uma função do Lambda](gs2-prepare.md)
+ [Etapa 2: criar um bot](gs2-create-bot.md)
+ [Etapa 3: crie e teste o bot](gs2-build-and-test.md)
+ [Etapa 4 (opcional): Limpeza](gs2-clean-up.md)
# Etapa 1: Criar uma função do Lambda
Primeiro, crie uma função do Lambda que atenda a um pedido de pizza. Essa função é específica no bot do Amazon Lex, que será criado na próxima seção.
**Criar uma função do Lambda**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Escolha a opção **Criar função**.
1. Na página **Create function**, selecione **Author from scratch**.
Como você está usando um código personalizado fornecido neste exercício para criar uma função do Lambda, selecione essa opção.
Faça o seguinte:
1. Digite o nome: (`PizzaOrderProcessor`).
1. Em **Runtime (Tempo de execução)**, selecione a versão mais recente do Node.js.
1. Em **Role**, selecione **Create new role from template(s)**.
1. Insira um novo nome de função (`PizzaOrderProcessorRole`).
1. Escolha a opção **Criar função**.
1. Na página function, faça o seguinte:
Na seção **Function code**, selecione **Edit code inline** e, em seguida, copie o código da função Node.js a seguir e cole-o na janela.
```
'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. Escolha **Salvar**.
## Testar a função do Lambda usando dados de eventos de exemplo
No console, teste a função do Lambda usando dados de eventos de exemplo para invocá-la manualmente.
**Para testar a função do Lambda:**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Na página da **função do Lambda, escolha a **função do Lambda (`PizzaOrderProcessor).`
1. Na página da função, na lista de eventos de teste, selecione **Configure test events**.
1. Na página **Configure test event**, faça o seguinte:
1. Selecione **Criar evento de teste**.
1. No campo **Event name**, insira um nome para o evento (`PizzaOrderProcessorTest`).
1. Copie o evento do Amazon Lex a seguir na janela.
```
{
"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. Escolha **Criar**.
AWS Lambda cria o teste e você volta para a página da função. Escolha **Testar** para que o Lambda execute a função do Lambda.
Na caixa de resultados, selecione **Details**. O console exibe a saída a seguir no painel **Execution result**.
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Okay, I have ordered your large meat pizza on thin crust."
}
}
```
## Próxima etapa
[Etapa 2: criar um bot](gs2-create-bot.md)
# Etapa 2: criar um bot
Nesta etapa, você cria um bot para lidar com os pedidos de pizza.
**Topics**
+ [Criar o bot](gs2-create-bot-create.md)
+ [Criar uma intenção](gs2-create-bot-intent.md)
+ [Criar tipos de slot](gs2-create-bot-slot-types.md)
+ [Configurar a intenção](gs2-create-bot-configure-intent.md)
+ [Configurar o bot do](gs2-create-bot-configure-bot.md)
# Criar o bot
Crie o bot `PizzaOrderingBot` com o mínimo de informações necessárias. Você adiciona uma intenção, uma ação que o usuário deseja executar, para o bot mais tarde.
**Para criar o bot**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Crie um bot.
1. Se você estiver criando seu primeiro bot, escolha **Get Started**. Caso contrário, escolha **Bots** e, em seguida, **Create**.
1. Na página **Create your Lex bot** escolha **Custom bot** e forneça as seguintes informações:
+ **Nome do bot**: PizzaOrderingBot
+ **Idioma**: escolha o idioma e a localidade do seu bot.
+ **Output voice**: Salli
+ **Session timeout **: 5 minutos.
+ **COPPA**: escolha a resposta apropriada.
+ **Armazenamento da declaração do usuário: escolha a resposta apropriada.**
1. Escolha **Criar**.
O console envia ao Amazon Lex uma solicitação para criar um novo bot. O Amazon Lex define a versão do bot como `$LATEST`. Depois de criar o bot, o Amazon Lex mostra a guia **Editor** do bot, como na imagem a seguir:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-20.png)
+ A versão **Latest** do bot encontra-se no console, ao lado do nome do bot. Os novos recursos do Amazon Lex têm `$LATEST` como versão. Para obter mais informações, consulte [Versionamento e aliases](versioning-aliases.md).
+ Como você não criou nenhuma intenção ou tipos de slots, não há nenhum listado.
+ **Build** e **Publish** são atividades no nível do bot. Depois de configurar todo o bot, você aprenderá mais sobre essas atividades.
## Próxima etapa
[Criar uma intenção](gs2-create-bot-intent.md)
# Criar uma intenção
Agora, crie a intenção `OrderPizza`, uma ação que o usuário deseja executar, com o mínimo de informações necessárias. Você adiciona tipos de slot para a intenção e, mais tarde, configura a intenção.
**Para criar uma intenção**
1. No console do Amazon Lex escolha o sinal de adição (\$1) ao lado de **Intenções** e, em seguida, escolha **Criar nova intenção**.
1. Na caixa de diálogo **Create intent**, digite o nome da intenção (`OrderPizza`) e escolha **Add**.
O console envia uma solicitação ao Amazon Lex para criar a intenção `OrderPizza`. Neste exemplo, você cria slots para a intenção depois de criar tipos de slots.
## Próxima etapa
[Criar tipos de slot](gs2-create-bot-slot-types.md)
# Criar tipos de slot
Crie tipos de slot ou valores de parâmetro que a intenção `OrderPizza` usa.
**Para criar tipos de slot**
1. No menu esquerdo, escolha o sinal de mais (\$1) ao lado de **Slot types**.
1. Na caixa de diálogo **Add slot type**, adicione o seguinte:
+ **Slot type name** – Massas
+ **Description** – Massas disponíveis
+ Escolha **Restrict to Slot values and Synonyms**
+ **Valor**: Type **thick**. Selecione a guia e, no campo **Synonym (Sinônimo)**, digite **stuffed**. Escolha o sinal de adição (\$1). Digite **thin** e, em seguida, escolha o sinal de adição (\$1) novamente.
A caixa de diálogo deve ter a seguinte aparência:
![\[A caixa de diálogo de edição do tipo de slot.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-25a.png)
1. Escolha **Add slot to intent**.
1. Na página **Intent**, escolha **Required**. Altere o nome do slot de **slotOne** para **crust**. Mude a solicitação para **What kind of crust would you like?**.
1. Repita [Step 1](#slotTypeStart) a [Step 4](#slotTypeFinish) usando os valores da seguinte tabela:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/gs2-create-bot-slot-types.html)
## Próxima etapa
[Configurar a intenção](gs2-create-bot-configure-intent.md)
# Configurar a intenção
Configure a intenção `OrderPizza` para atender à solicitação do usuário de pedir uma pizza.
**Para configurar uma intenção**
+ Na página **OrderPizza**de configuração, configure a intenção da seguinte forma:
+ **Amostra de declaraçõe**: digite as strings a seguir. As chaves \$1\$1 contém nomes de slot.
+ Quero pedir pizza
+ Quero pedir uma pizza
+ Quero pedir uma pizza de \$1pizzaKind\$1
+ Quero pedir uma pizza \$1size\$1 de \$1pizzaKind\$1
+ Quero uma pizza \$1size\$1 de \$1pizzaKind\$1 com massa \$1crust\$1
+ Posso pedir uma pizza
+ Posso pedir uma pizza de \$1pizzaKind\$1
+ Posso pedir uma pizza \$1size\$1 de \$1pizzaKind\$1
+ **Lambda initialization and validation** – Deixe a configuração padrão.
+ **Confirmation prompt** – Deixe a configuração padrão.
+ **Atendimento**: execute as seguintes tarefas:
+ Escolha **AWS Lambda function (Função do Lambda)**.
+ Selecione **PizzaOrderProcessor**.
+ Se a caixa de diálogo **Adicionar permissão à função do Lambda** for mostrada, escolha **OK** para dar à `OrderPizza` intenção a permissão para chamar a `PizzaOrderProcessor` função do Lambda.
+ Deixe **None** selecionado.
A intenção deve ter a seguinte aparência:
![\[O editor de intenção.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-70c.png)
## Próxima etapa
[Configurar o bot do](gs2-create-bot-configure-bot.md)
# Configurar o bot do
Configure a manipulação de erros para o bot `PizzaOrderingBot`.
1. Navegue até o bot `PizzaOrderingBot`. Escolha **Editor** e, em seguida, escolha **Tratamento de erros**, como na imagem a seguir:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-80.png)
1. Use a guia **Editor** para configurar a manipulação de erros do bot.
+ As informações que você fornece em **Clarification Prompts (Solicitações de esclarecimento)** são mapeadas para a configuração [clarificationPrompt](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-clarificationPrompt) do bot.
Quando o Amazon Lex não consegue determinar a intenção do usuário, o serviço retorna uma resposta com esta mensagem.
+ As informações que você fornece na frase **Hang-up (Encerramento)** são mapeadas para a configuração [abortStatement](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-abortStatement) do bot.
Se o serviço não puder determinar a intenção do usuário depois de um determinado número de solicitações consecutivas, o Amazon Lex retornará uma resposta com esta mensagem.
Deixe os valores padrão.
## Próxima etapa
[Etapa 3: crie e teste o bot](gs2-build-and-test.md)
# Etapa 3: crie e teste o bot
Crie e teste o bot para garantir que ele funciona.
**Para criar e testar o bot**
1. Para criar o bot `PizzaOrderingBot`, escolha **Build**.
O Amazon Lex compila um modelo de machine learning para o bot. Quando você testa o bot, o console usa a API de runtime para enviar a entrada do usuário de volta para o Amazon Lex. Em seguida, o Amazon Lex usa o modelo de machine learning para interpretar a entrada do usuário.
Pode levar algum tempo para concluir a criação.
1. Para testar o bot, na janela **Testar bot**, comece a se comunicar com o bot de do Amazon Lex.
+ Por exemplo, você pode dizer ou digitar:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-110.png)
+ Use a amostra de declarações que você configurou na intenção `OrderPizza` para testar o bot. Por exemplo, a amostra a seguir é uma das amostras de declarações que você configurou para a intenção `PizzaOrder`:
```
I want a {size} {crust} crust {pizzaKind} pizza
```
Para testá-la, digite o seguinte:
```
I want a large thin crust cheese pizza
```
Quando você digita "Quero encomendar uma pizza", o Amazon Lex detecta a intenção (`OrderPizza`). Em seguida, o Amazon Lex solicita informações de slot.
Depois que você fornece todas as informações do slot, o Amazon Lex invoca a função do Lambda que você configurou para a intenção.
A função do Lambda retorna uma mensagem ("OK, eu pedi sua...") para o Amazon Lex, que o Amazon Lex retorna para você.
## Inspeção da resposta
Abaixo da janela de chat, há um painel que permite inspecionar a resposta do Amazon Lex. O painel fornece informações completas sobre o estado do seu bot, que muda conforme você interage com ele. O conteúdo do painel mostra o estado atual da operação.
+ **Estado do diálogo**: o estado atual da conversa com o usuário. Ele pode ser `ElicitIntent`, `ElicitSlot`, `ConfirmIntent` ou `Fulfilled`.
+ **Resumo**: mostra uma visão simplificada da caixa de diálogo, que mostra os valores de slot para que a intenção seja cumprida, permitindo que você controle o fluxo de informações. Ele mostra o nome do método, o número de slots, o número de slots preenchidos e uma lista de slots e seus valores associados. Veja a imagem a seguir:
![\[O painel de inspeção do resumo da resposta do console do Amazon Lex.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-115.png)
+ **Detalhe**: mostra a resposta JSON bruta do chatbot para proporcionar uma visão mais detalhada da interação do bot e o estado atual da caixa de diálogo à medida que você testa e depura o chatbot. Se você digitar na janela de bate-papo, o painel de inspeção mostra a resposta JSON da operação [PostText](API_runtime_PostText.md). Se você falar com a janela de bate-papo, o painel de inspeção mostra o cabeçalho da resposta da operação [PostContent](API_runtime_PostContent.md). Veja a imagem a seguir:
![\[O painel de inspeção de resposta do console\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-116.png)
## Próxima etapa
[Etapa 4 (opcional): Limpeza](gs2-clean-up.md)
# Etapa 4 (opcional): Limpeza
Exclua os recursos que você criou e limpe sua conta para evitar mais cobranças pelos os recursos que você criou.
Você só pode excluir os recursos que não estão em uso. Por exemplo, você não pode excluir um tipo de slot que seja referenciado por uma intenção. Você não pode excluir uma intenção que seja referenciada por um bot.
Exclua recursos na seguinte ordem:
+ Exclua bots para liberar recursos de intenção.
+ Exclua intenções para liberar recursos de tipo de slot.
+ Exclua tipos de slot por último.
**Para limpar sua conta**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Na lista de bots, escolha **PizzaOrderingBot**.
1. Para excluir o bot, escolha **Delete** e, em seguida, escolha **Continue**.
1. No painel à esquerda, selecione **Intents**.
1. Na lista de intenções, escolha **OrderPizza**.
1. Para excluir a intenção, escolha **Delete** e, em seguida, escolha **Continue**.
1. No menu esquerdo, escolha **Slot types**.
1. Na lista de tipos de slot, escolha **Crusts**.
1. Para excluir o tipo de slot, escolha **Delete** e, em seguida, escolha **Continue**.
1. Repita [Step 8](#chooseSlots) e [Step 9](#deleteSlots) para os tipos de slot `Sizes` e `PizzaKind`.
Você removeu todos os recursos que criou e limpou sua conta.
## Próximas etapas
+ [Publique uma versão e crie um alias.](https://docs.aws.amazon.com/lex/latest/dg/gettingstarted-ex3.html)
+ [Crie um bot Amazon Lex com o AWS Command Line Interface](https://docs.aws.amazon.com/lex/latest/dg/gs-cli.html)
# Exercício 3: publique uma versão e crie um alias
Nos Exercícios 1 e 2 de Conceitos básicos, você criou e testou um bot. Neste exercício, você faz o seguinte:
+ Publique uma nova versão do bot. O Amazon Lex faz uma cópia de snapshot da versão `$LATEST` para publicar uma nova versão.
+ Crie um alias que aponte para a versão nova.
Para obter mais informações sobre versionamento e aliases, consulte [Versionamento e aliases](versioning-aliases.md).
Faça o seguinte para publicar uma versão de um bot criado neste exercício:
1. No console do Amazon Lex, escolha um dos bots que você criou.
Verifique se o console mostra o `$LATEST` como a versão do bot ao lado do nome do bot.
1. Selecione **Publish**.
1. No *botname* assistente de **publicação**, especifique o **BETA** alias e escolha **Publicar**.
1. Verifique se o console do Amazon Lex mostra a nova versão ao lado do nome do bot, como mostrado na imagem a seguir.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs2-final.png)
Agora que você tem um bot funcionando com versão publicada e um alias, pode implantá-lo (em sua aplicação móvel ou integrar o bot com o Facebook Messenger). Para ver um exemplo, consulte [Integração de um bot do Amazon Lex com o Facebook Messenger](fb-bot-association.md).
# Etapa 4: Conceitos básicos (AWS CLI)
Nesta etapa, você usa o AWS CLI para criar, testar e modificar um bot do Amazon Lex. Para concluir esses exercícios, você precisa estar familiarizado com o uso da CLI e tem um editor de texto. Para obter mais informações, consulte [Etapa 2: Configurar o AWS Command Line Interface](gs-set-up-cli.md).
+ Exercício 1: Criar e testar um bot do Amazon Lex. O exercício fornece todos os objetos JSON de que você precisa para criar um tipo de slot personalizado, uma intenção e um bot. Para obter mais informações, consulte [Amazon Lex: como funciona](how-it-works.md).
+ Exercício 2: atualize o bot que você criou no Exercício 1 para adicionar mais uma amostra de declaração. Amazon Lex usa amostra de declarações para criar o modelo de Machine Learning para o seu bot.
+ Exercício 3: atualize o bot que você criou no exercício 1 para adicionar uma função do Lambda para validar a entrada do usuário e atender à intenção.
+ Exercício 4: Publicar uma versão do tipo de slot, intenção e recursos do bot que você criou no Exercício 1. Uma versão é um snapshot de um recurso que não pode ser alterada.
+ Exercício 5: Criar um alias para o bot que você criou no Exercício 1.
+ Exercício 6: Limpar sua conta excluindo o tipo de slot, a intenção e o bot que você criou no Exercício 1, e o alias que você criou no Exercício 5.
**Topics**
+ [Exercício 1: Criar um bot do Amazon Lex (AWS CLI)](gs-cli-create.md)
+ [Exercício 2: Adicionar uma nova declaração (AWS CLI)](gs-cli-update-utterance.md)
+ [Exercício 3: Adicione uma função do Lambda (AWS CLI)](gs-cli-update-lambda.md)
+ [Exercício 4: Publicar uma versão (AWS CLI)](gs-cli-publish.md)
+ [Exercício 5: Criar um alias (AWS CLI)](gs-cli-create-alias.md)
+ [Exercício 6: Limpar (AWS CLI)](gs-cli-clean-up.md)
# Exercício 1: Criar um bot do Amazon Lex (AWS CLI)
Em geral, quando você cria bots, você:
1. Cria tipos de slot para definir as informações com as quais seu bot vai trabalhar.
1. Cria as intenções que definem as ações do usuário a que o bot oferece suporte. Use os tipos de slot personalizados que você criou anteriormente para definir os slots, ou parâmetros, que a sua intenção requer.
1. Crie um bot que usa as intenções que você definiu.
Neste exercício, você cria e testa um novo bot do Amazon Lex usando a CLI. Use as estruturas JSON que fornecemos para criar o bot. Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Topics**
+ [Etapa 1: Criar uma função vinculada a serviço (AWS CLI)](gs-create-role.md)
+ [Etapa 2: criar um tipo de slot personalizado (AWS CLI)](gs-create-flower-types.md)
+ [Etapa 3: Criar uma intenção (AWS CLI)](gs-cli-create-order-flowers.md)
+ [Etapa 4: Criar um bot (AWS CLI)](gs-cli-create-order-flowers-bot.md)
+ [Etapa 5: Testar um bot (AWS CLI)](gs-create-test.md)
# Etapa 1: Criar uma função vinculada a serviço (AWS CLI)
O Amazon Lex assume funções AWS Identity and Access Management vinculadas a serviços para chamar AWS serviços em nome de seus bots. As funções, que estão em sua conta, são vinculadas aos casos de uso do Amazon Lex e têm permissões predefinidas. Para obter mais informações, consulte [Uso de perfis vinculadas ao serviço para o Amazon Lex](using-service-linked-roles.md).
Se você já tiver criado um bot do Amazon Lex usando o console, a função vinculada a serviço terá sido criada automaticamente. Vá para [Etapa 2: criar um tipo de slot personalizado (AWS CLI)](gs-create-flower-types.md).
**Para criar uma função vinculada a serviço (AWS CLI)**
1. No AWS CLI, digite o seguinte comando:
```
aws iam create-service-linked-role --aws-service-name lex.amazonaws.com
```
1. Verifique a política usando o seguinte comando:
```
aws iam get-role --role-name AWSServiceRoleForLexBots
```
A resposta é:
## Próxima etapa
[Etapa 2: criar um tipo de slot personalizado (AWS CLI)](gs-create-flower-types.md)
# Etapa 2: criar um tipo de slot personalizado (AWS CLI)
Crie um tipo de slot personalizado com valores de enumeração para as flores que podem ser solicitadas. Você vai usar esse tipo na próxima etapa quando criar a intenção `OrderFlowers`. Um *tipo de slot* define os valores possíveis para um slot, ou parâmetro, da intenção.
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Para criar um tipo de slot personalizado (AWS CLI)**
1. Crie um arquivo de texto chamado **FlowerTypes.json**. Copie o seguinte código JSON de [FlowerTypes.json](gs-cli-create-flower-types-json.md) para o arquivo de texto.
1. Chame a [PutSlotType](API_PutSlotType.md) operação usando o AWS CLI para criar o tipo de slot. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws lex-models put-slot-type \
--region region \
--name FlowerTypes \
--cli-input-json file://FlowerTypes.json
```
A resposta do servidor é:
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"checksum": "checksum",
"version": "$LATEST",
"lastUpdatedDate": timestamp,
"createdDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Próxima etapa
[Etapa 3: Criar uma intenção (AWS CLI)](gs-cli-create-order-flowers.md)
# FlowerTypes.json
O código a seguir são os dados JSON necessários para criar o tipo de slot personalizado `FlowerTypes`:
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"description": "Types of flowers to pick up"
}
```
# Etapa 3: Criar uma intenção (AWS CLI)
Crie uma intenção para o bot `OrderFlowersBot` e forneça três slots, ou parâmetros. Os slots permitem que o bot cumpra a intenção:
+ `FlowerType` é um tipo de slot personalizado que especifica quais tipos de flores podem ser solicitados.
+ `AMAZON.DATE` e `AMAZON.TIME` são tipos de slot integrados usados para obter a data e a hora para entregar as flores do usuário.
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Para criar a intenção `OrderFlowers` (AWS CLI)**
1. Crie um arquivo de texto chamado **OrderFlowers.json**. Copie o seguinte código JSON de [OrderFlowers.json](gs-cli-create-order-flowers-json.md) para o arquivo de texto.
1. No AWS CLI, chame a [PutIntent](API_PutIntent.md) operação para criar a intenção. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers.json
```
O servidor responde com o seguinte:
## Próxima etapa
[Etapa 4: Criar um bot (AWS CLI)](gs-cli-create-order-flowers-bot.md)
# OrderFlowers.json
O código a seguir são os dados JSON necessários para criar a intenção `OrderFlowers`:
```
{
"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"
}
```
# Etapa 4: Criar um bot (AWS CLI)
O bot `OrderFlowersBot` tem uma intenção, a intenção `OrderFlowers` que você criou na etapa anterior. Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST`.
**Para criar o bot `OrderFlowersBot` (AWS CLI)**
1. Crie um arquivo de texto chamado **OrderFlowersBot.json**. Copie o seguinte código JSON de [OrderFlowersBot.json](gs-cli-create-order-flowers-bot-json.md) para o arquivo de texto.
1. No AWS CLI, chame a [PutBot](API_PutBot.md) operação para criar o bot. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot.json
```
A resposta do servidor é a seguinte. Quando você cria ou atualiza o bot, o campo `status` é definido como `BUILDING`. Isso indica que o bot não está pronto para uso. Para determinar quando o bot está pronto para uso, use a operação [GetBot](API_GetBot.md) na próxima etapa.
1. Para determinar se o seu novo bot está pronto para uso, execute o comando a seguir. Repita esse comando até que o campo `status` retorne `READY`. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST"
```
Procure pelo campo `status` na resposta:
```
{
"status": "READY",
...
}
```
## Próxima etapa
[Etapa 5: Testar um bot (AWS CLI)](gs-create-test.md)
# OrderFlowersBot.json
O código a seguir fornece os dados JSON necessários para criar o bot do Amazon Lex `OrderFlowers`:
```
{
"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"
}
```
# Etapa 5: Testar um bot (AWS CLI)
Para testar o bot, você pode usar um arquivo baseado em texto ou um teste com base em voz.
**Topics**
+ [Testar o bot usando entrada de texto (AWS CLI)](gs-create-test-text.md)
+ [Testar o bot usando entrada de fala (AWS CLI)](gs-create-test-speech.md)
# Testar o bot usando entrada de texto (AWS CLI)
Para verificar se o bot funciona corretamente com a entrada de texto, use a operação [PostText](API_runtime_PostText.md). Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Service Quotas de runtime](gl-limits.md#gl-limits-runtime).
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para usar texto para testar o bot (AWS CLI)**
1. No AWS CLI, inicie uma conversa com o `OrderFlowersBot` bot. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "i would like to order flowers"
```
O Amazon Lex reconhece a intenção do usuário e inicia uma conversa retornando a seguinte resposta:
```
{
"slotToElicit": "FlowerType",
"slots": {
"PickupDate": null,
"PickupTime": null,
"FlowerType": null
},
"dialogState": "ElicitSlot",
"message": "What type of flowers would you like to order?",
"intentName": "OrderFlowers"
}
```
1. Execute os seguintes comandos para concluir a conversa com o bot.
```
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"
```
Após a confirmação do pedido, o Amazon Lex envia uma resposta de atendimento para concluir a conversa:
```
{
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
},
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers"
}
```
## Próxima etapa
[Testar o bot usando entrada de fala (AWS CLI)](gs-create-test-speech.md)
# Testar o bot usando entrada de fala (AWS CLI)
Para testar o bot usando arquivos de áudio, use a operação [PostContent](API_runtime_PostContent.md) . Você gera os arquivos de áudio usando as operações do Amazon Polly. text-to-speech
Para executar os comandos neste exercício, você precisa saber em qual região os comandos do Amazon Lex e do Amazon Polly serão executados. Para obter uma lista das regiões para o Amazon Lex, consulte [Service Quotas de runtime](gl-limits.md#gl-limits-runtime). Para obter uma lista das regiões da Amazon Polly, consulte [AWS Regiões e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region) na *Referência geral da Amazon Web Services*.
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para usar uma entrada de fala para testar o bot (AWS CLI)**
1. No AWS CLI, crie um arquivo de áudio usando o Amazon Polly. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "i would like to order flowers" \
--voice-id "Salli" \
IntentSpeech.mpg
```
1. Para enviar o arquivo de áudio para o Amazon Lex, execute o comando a seguir. O Amazon Lex salva o áudio da resposta no arquivo de saída especificado.
```
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
```
O Amazon Lex responde com uma solicitação para o primeiro slot. Ele salva o áudio da resposta no arquivo de saída especificado.
```
{
"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. Para pedir rosas, crie o seguinte arquivo de áudio e envie-o para o 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. Para definir a data de entrega, crie o seguinte arquivo de áudio e envie-o para o 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. Para definir o horário de entrega, crie o seguinte arquivo de áudio e envie-o para o 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. Para confirmar a entrega, crie o seguinte arquivo de áudio e envie-o para o 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
```
Depois que você confirmar a entrega, o Amazon Lex envia uma resposta que confirma o atendimento da intenção:
```
{
"contentType": "text/plain;charset=utf-8",
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers",
"inputTranscript": "yes",
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
}
}
```
## Próxima etapa
[Exercício 2: Adicionar uma nova declaração (AWS CLI)](gs-cli-update-utterance.md)
# Exercício 2: Adicionar uma nova declaração (AWS CLI)
Para melhorar o modelo de Machine Learning que o Amazon Lex usa para reconhecer solicitações dos usuários, adicione outra amostra de declaração ao bot.
A adição de uma nova declaração é um processo de quatro etapas.
1. Use a operação [GetIntent](API_GetIntent.md) para obter uma intenção do Amazon Lex.
1. Atualize a intenção.
1. Use a operação [PutIntent](API_PutIntent.md) para enviar a intenção atualizada de volta ao Amazon Lex.
1. Use as operações [GetBot](API_GetBot.md) e [PutBot](API_PutBot.md) para recriar qualquer bot que use a intenção.
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
A resposta da operação `GetIntent` contém um campo chamado `checksum` que identifica uma revisão específica da intenção. Você deve fornecer o valor de soma de verificação quando usa a operação [PutIntent](API_PutIntent.md) para atualizar uma intenção. Se não fizer isso, você receberá a seguinte mensagem de erro:
```
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.
```
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para atualizar a intenção `OrderFlowers` (AWS CLI)**
1. No AWS CLI, obtenha a intenção do Amazon Lex. O Amazon Lex envia a saída para um arquivo chamado **OrderFlowers-V2.json.**
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V2.json
```
1. Abra **OrderFlowers-V2.json** em um editor de texto.
1. Encontre e exclua os campos `createdDate`, `lastUpdatedDate`e `version`.
1. Adicione o seguinte ao campo `sampleUtterances`:
```
I want to order flowers
```
1. Salve o arquivo.
1. Envie a intenção atualizada ao Amazon Lex com o seguinte comando:
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V2.json
```
O Amazon Lex envia a seguinte resposta:
Agora que você atualizou a intenção, recrie qualquer bot que a utilize.
**Para recriar o bot `OrderFlowersBot` (AWS CLI)**
1. No AWS CLI, obtenha a definição do `OrderFlowersBot` bot e salve-a em um arquivo com o seguinte comando:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V2.json
```
1. Em um editor de texto, abra **OrderFlowersBot-V2.json**. Remova os campos `createdDate`, `lastUpdatedDate`, `status` e `version`.
1. Em um editor de texto, adicione a seguinte linha à definição do bot:
```
"processBehavior": "BUILD",
```
1. No AWS CLI, crie uma nova revisão do bot executando o seguinte comando para:
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V2.json
```
A resposta do servidor é:
## Próxima etapa
[Exercício 3: Adicione uma função do Lambda (AWS CLI)](gs-cli-update-lambda.md)
# Exercício 3: Adicione uma função do Lambda (AWS CLI)
Adicione uma função do Lambda que valide a entrada do usuário e atenda à intenção do usuário ao bot.
A adição de uma expressão função do Lambda é um processo de cinco etapas.
1. [Use a [AddPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html)função Lambda para ativar a `OrderFlowers` intenção de chamar a operação Lambda Invoke.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html)
1. Use a operação [GetIntent](API_GetIntent.md) para obter a intenção do Amazon Lex.
1. Atualize a intenção para adicionar a função do Lambda.
1. Use a operação [PutIntent](API_PutIntent.md) para enviar a intenção atualizada de volta ao Amazon Lex.
1. Use as operações [GetBot](API_GetBot.md) e [PutBot](API_PutBot.md) para recriar qualquer bot que use a intenção.
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
Se você adicionar uma função do Lambda a uma intenção antes de adicionar a permissão `InvokeFunction`, verá a seguinte mensagem de erro:
```
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.
```
A resposta da operação `GetIntent` contém um campo chamado `checksum` que identifica uma revisão específica da intenção. Quando usa a operação [PutIntent](API_PutIntent.md) para atualizar uma intenção, você deve fornecer o valor de soma de verificação. Se não fizer isso, você receberá a seguinte mensagem de erro:
```
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.
```
Este exercício usa a função do Lambda do [Exercício 1: Criar um bot do Amazon Lex usando um esquema (Console).](gs-bp.md). Para obter instruções para criar a função do Lambda, consulte [Etapa 3: Crie uma função do Lambda (console)](gs-bp-create-lambda-function.md).
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST`.
**Para adicionar uma função do Lambda a uma intenção**
1. No AWS CLI, adicione a `InvokeFunction` permissão para a `OrderFlowers` intenção:
```
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
```
O Lambda envia a seguinte resposta:
```
{
"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. Obtenha a intenção do Amazon Lex. O Amazon Lex envia a saída para um arquivo chamado **OrderFlowers-V3.json**.
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V3.json
```
1. Em um editor de texto, abra o **OrderFlowers-V3.json**.
1. Encontre e exclua os campos `createdDate`, `lastUpdatedDate`e `version`.
1. Atualize o campo `fulfillmentActivity`:
```
"fulfillmentActivity": {
"type": "CodeHook",
"codeHook": {
"uri": "arn:aws:lambda:region:account ID:function:OrderFlowersCodeHook",
"messageVersion": "1.0"
}
}
```
1. Salve o arquivo.
1. Em AWS CLI, envie a intenção atualizada para o Amazon Lex:
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V3.json
```
Agora que você atualizou a intenção, recrie o bot.
**Para recriar o bot `OrderFlowersBot`**
1. No AWS CLI, obtenha a definição do `OrderFlowersBot` bot e salve-a em um arquivo:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V3.json
```
1. Em um editor de texto, abra **OrderFlowersBot-V3.json**. Remova os campos `createdDate`, `lastUpdatedDate`, `status` e `version`.
1. No editor de texto, adicione a seguinte linha à definição do bot:
```
"processBehavior": "BUILD",
```
1. No AWS CLI, crie uma nova revisão do bot:
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V3.json
```
A resposta do servidor é:
## Próxima etapa
[Exercício 4: Publicar uma versão (AWS CLI)](gs-cli-publish.md)
# Exercício 4: Publicar uma versão (AWS CLI)
Agora, crie uma versão do bot que você criou no Exercício 1. Uma *versão* é um snapshot do bot. Depois que criar uma versão, você não poderá alterá-la. A única versão de um bot que você pode atualizar é a versão `$LATEST`. Para obter mais informações sobre versões, consulte [Versionamento e aliases](versioning-aliases.md).
Antes de poder publicar uma versão de um bot, você deve publicar a intenção que ele usa. Da mesma forma, você deve publicar os tipos de slot a que essas intenções se referem. No geral, para publicar uma versão de um bot, você faz o seguinte:
1. Publica uma versão de um tipo de slot com a operação [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md).
1. Publica uma versão de uma intenção com a operação [CreateIntentVersion](API_CreateIntentVersion.md).
1. Publica uma versão de um bot com a operação [CreateBotVersion](API_CreateBotVersion.md).
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Topics**
+ [Etapa 1: Publicar o tipo de slot (AWS CLI)](gs-cli-publish-slot-type.md)
+ [Etapa 2: publicar a intenção (AWS CLI)](gs-cli-publish-intent.md)
+ [Etapa 3: Publicar o bot (AWS CLI)](gs-cli-publish-bot.md)
# Etapa 1: Publicar o tipo de slot (AWS CLI)
Antes de poder publicar uma versão de qualquer intenção que usa um tipo de slot, você deve publicar uma versão desse tipo de slot. Neste caso, você publica o tipo de slot `FlowerTypes`.
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para publicar o tipo de slot (AWS CLI)**
1. No AWS CLI, obtenha a versão mais recente do tipo de slot:
```
aws lex-models get-slot-type \
--region region \
--name FlowerTypes \
--slot-type-version "\$LATEST"
```
A resposta do Amazon Lex vem em seguida. Registre a soma de verificação para a revisão atual da versão `$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. Publique uma nova versão do tipo de slot. Use a soma de verificação que você registrou na etapa anterior.
```
aws lex-models create-slot-type-version \
--region region \
--name FlowerTypes \
--checksum "checksum"
```
A resposta do Amazon Lex vem em seguida. Registre o número da versão para a próxima etapa.
```
{
"version": "1",
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"createdDate": timestamp,
"lastUpdatedDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Próxima etapa
[Etapa 2: publicar a intenção (AWS CLI)](gs-cli-publish-intent.md)
# Etapa 2: publicar a intenção (AWS CLI)
Antes de poder publicar uma intenção, você tem que publicar todos os tipos de slot mencionados pela intenção. Os tipos de slot devem ser versões numeradas, não a versão `$LATEST`.
Primeiro, atualize a intenção `OrderFlowers` para usar a versão do tipo de slot `FlowerTypes` que você publicou na etapa anterior. Depois, publique uma nova versão da intenção `OrderFlowers`.
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para publicar uma versão de uma intenção (AWS CLI)**
1. No AWS CLI, obtenha a `$LATEST` versão da `OrderFlowers` intenção e salve-a em um arquivo:
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4.json
```
1. Em um editor de texto, abra o arquivo **OrderFlowers\$1V4.json**. Exclua os campos `createdDate`, `lastUpdatedDate` e `version`. Encontre o tipo de slot `FlowerTypes` e altere a versão para o número da versão que você registrou na etapa anterior. O seguinte fragmento do arquivo **OrderFlowers\$1V4.json** mostra a localização da alteração:
```
{
"slotType": "FlowerTypes",
"name": "FlowerType",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What type of flowers?",
"contentType": "PlainText"
}
]
},
"priority": 1,
"slotTypeVersion": "version",
"sampleUtterances": []
},
```
1. No AWS CLI, salve a revisão da intenção:
```
aws lex-models put-intent \
--name OrderFlowers \
--cli-input-json file://OrderFlowers_V4.json
```
1. Obtenha a soma de verificação da última revisão da intenção:
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4a.json
```
O seguinte fragmento de resposta mostra a soma de verificação da intenção. Registre isso para a próxima etapa.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "$LATEST",
```
1. Publique uma nova versão da intenção:
```
aws lex-models create-intent-version \
--region region \
--name OrderFlowers \
--checksum "checksum"
```
O seguinte fragmento de resposta mostra a nova versão da intenção. Registre o número da versão para a próxima etapa.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "version",
```
## Próxima etapa
[Etapa 3: Publicar o bot (AWS CLI)](gs-cli-publish-bot.md)
# Etapa 3: Publicar o bot (AWS CLI)
Depois que você tiver publicado todos os tipos de slot e intenções que são usados pelo seu bot, você pode publicar o bot.
Atualize o bot `OrderFlowersBot` para usar a intenção `OrderFlowers` que você atualizou na etapa anterior. Depois, publique uma nova versão do bot `OrderFlowersBot`.
**nota**
O AWS CLI exemplo a seguir está formatado para Unix, Linux e macOS. Para Windows, altere `"\$LATEST"` para `$LATEST` e substitua o caractere de continuação de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Para publicar uma versão de um bot (AWS CLI)**
1. No AWS CLI, obtenha a `$LATEST` versão do `OrderFlowersBot` bot e salve-a em um arquivo:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot_V4.json
```
1. Em um editor de texto, abra o arquivo **OrderFlowersBot\$1V4.json**. Exclua os campos `createdDate`, `lastUpdatedDate`, `status` e `version`. Encontre a intenção `OrderFlowers` e altere a versão para o número da versão que você registrou na etapa anterior. O seguinte fragmento de **OrderFlowersBot\$1V4.json** mostra a localização da alteração.
```
"intents": [
{
"intentVersion": "version",
"intentName": "OrderFlowers"
}
```
1. Em AWS CLI, salve a nova revisão do bot. Anote o número de versão retornado pela chamada a `put-bot`.
```
aws lex-models put-bot \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot_V4.json
```
1. Obtenha a soma de verificação da última revisão do bot. Use o número de versão retornado na etapa 3.
```
aws lex-models get-bot \
--region region \
--version-or-alias version \
--name OrderFlowersBot > OrderFlowersBot_V4a.json
```
O seguinte fragmento de resposta mostra a soma de verificação do bot. Registre isso para a próxima etapa.
```
"name": "OrderFlowersBot",
"locale": "en-US",
"checksum": "checksum",
```
1. Publique uma nova versão do bot:
```
aws lex-models create-bot-version \
--region region \
--name OrderFlowersBot \
--checksum "checksum"
```
O seguinte fragmento de resposta mostra a nova versão do bot.
```
"checksum": "checksum",
"abortStatement": {
...
},
"version": "1",
"lastUpdatedDate": timestamp,
```
## Próxima etapa
[Exercício 5: Criar um alias (AWS CLI)](gs-cli-create-alias.md)
# Exercício 5: Criar um alias (AWS CLI)
Um alias é um ponteiro para uma versão específica de um bot. Com um alias, você pode atualizar com facilidade a versão que seus aplicativos cliente estão usando. Para obter mais informações, consulte [Versionamento e aliases](versioning-aliases.md). Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Para criar um alias (AWS CLI)**
1. No AWS CLI, obtenha a versão do `OrderFlowersBot` bot que você criou em[Exercício 4: Publicar uma versão (AWS CLI)](gs-cli-publish.md).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias version > OrderFlowersBot_V5.json
```
1. Em um editor de texto, abra **OrderFlowersBot\$1v5.json**. Encontre e registre o número da versão.
1. No AWS CLI, crie o alias do bot:
```
aws lex-models put-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot \
--bot-version version
```
A resposta do servidor é a seguinte:
```
{
"name": "PROD",
"createdDate": timestamp,
"checksum": "checksum",
"lastUpdatedDate": timestamp,
"botName": "OrderFlowersBot",
"botVersion": "1"
}}
```
## Próxima etapa
[Exercício 6: Limpar (AWS CLI)](gs-cli-clean-up.md)
# Exercício 6: Limpar (AWS CLI)
Exclua os recursos que você criou e limpe sua conta.
Você só pode excluir os recursos que não estão em uso. Em geral, você deve excluir recursos na seguinte ordem.
1. Exclua aliases para liberar recursos de bot.
1. Exclua bots para liberar recursos de intenção.
1. Exclua intenções para liberar recursos de tipo de slot.
1. Exclua tipos de slot.
Para executar os comandos neste exercício, você precisa saber em que região os comandos serão executados. Para obter uma lista de regiões, consulte [Cotas de criação de modelos](gl-limits.md#gl-limits-model-building).
**Para limpar sua conta (AWS CLI)**
1. Na linha de AWS CLI comando, exclua o alias:
```
aws lex-models delete-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot
```
1. Na linha de AWS CLI comando, exclua o bot:
```
aws lex-models delete-bot \
--region region \
--name OrderFlowersBot
```
1. Na linha de AWS CLI comando, exclua a intenção:
```
aws lex-models delete-intent \
--region region \
--name OrderFlowers
```
1. Na linha de AWS CLI comando, exclua o tipo de slot:
```
aws lex-models delete-slot-type \
--region region \
--name FlowerTypes
```
Você removeu todos os recursos que criou e limpou sua conta.