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á.
# 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.