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