Aviso de fin de soporte: el 15 de septiembre de 2025, AWS dejaremos de ofrecer soporte para Amazon Lex V1. Después del 15 de septiembre de 2025, ya no podrá acceder a la consola de Amazon Lex V1 ni a los recursos de Amazon Lex V1. Si utiliza Amazon Lex V2, consulte en su lugar la [guía Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Introducción a Amazon Lex
Amazon Lex ofrece operaciones de la API que puede integrar con las aplicaciones existentes. Para ver una lista de las operaciones admitidas, consulte [referencia de la API](API_Reference.md). Puede utilizar cualquiera de las siguientes opciones:
+ AWS SDK: al usar el, SDKs sus solicitudes a Amazon Lex se firman y autentican automáticamente con las credenciales que usted proporciona. Esta es la opción recomendada para compilar las aplicaciones.
+ AWS CLI — Puede utilizarla AWS CLI para acceder a cualquier función de Amazon Lex sin tener que escribir ningún código.
+ Consola de AWS: la consola es la forma más sencilla de comenzar a probar y utilizar Amazon Lex.
Si es la primera vez que utiliza Amazon Lex, le recomendamos que lea [Funcionamiento de Amazon Lex](how-it-works.md) antes de continuar.
**Topics**
+ [
# Paso 1: configurar una AWS cuenta y crear un usuario administrador
](gs-account.md)
+ [
# Paso 2: configurar el AWS Command Line Interface
](gs-set-up-cli.md)
+ [
# Paso 3: Introducción (consola)
](gs-console.md)
+ [
# Paso 4: Introducción (AWS CLI)
](gs-cli.md)
# Paso 1: configurar una AWS cuenta y crear un usuario administrador
Antes de usar Amazon Lex por primera vez, complete las siguientes tareas:
1. [Inscríbase en AWS](#gs-account-create)
1. [Creación de un usuario](#gs-account-user)
## Inscríbase en AWS
Si ya tienes una AWS cuenta, omite esta tarea.
Cuando te registras en Amazon Web Services (AWS), tu AWS cuenta se registra automáticamente en todos los servicios de Amazon Lex AWS, incluido Amazon Lex. Solo se le cobrará por los servicios que utilice.
Con Amazon Lex, paga solo por los recursos que usa. Si es cliente nuevo de AWS , puede comenzar con Amazon Lex de forma gratuita. Para obtener más información, consulte [Nivel de uso gratuito de AWS](https://aws.amazon.com/free/).
Si ya tienes una AWS cuenta, pasa a la siguiente tarea. Si no dispone de una cuenta de AWS , utilice el siguiente procedimiento para crear una.
**Para crear una AWS cuenta**
1. Abre el [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).
1. Siga las instrucciones que se le indiquen.
Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.
Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
Anota el ID de tu AWS cuenta porque lo necesitarás para la siguiente tarea.
## Creación de un usuario
Los servicios de AWS, como Amazon Lex, requieren que proporcione credenciales al acceder a ellos para que el servicio pueda determinar si tiene permisos para acceder a los recursos que son propiedad de ese servicio. La consola requiere que especifique la contraseña. Sin embargo, no le recomendamos que acceda AWS con las credenciales de su AWS cuenta. Le recomendamos que utilice en su lugar:
+ Usa AWS Identity and Access Management (IAM) para crear un usuario
+ Añada el usuario a un grupo de IAM con permisos administrativos.
+ Conceda permisos administrativos al usuario que ha creado.
A continuación, puede acceder AWS mediante una URL especial y las credenciales del usuario.
En los ejercicios de introducción de esta guía se presupone que tiene un usuario (`adminuser`) con privilegios de administrador. Siga el procedimiento para crear `adminuser` en su cuenta.
**Para crear un usuario administrador e iniciar sesión en la consola**
1. Cree un usuario administrador llamado `adminuser` en su cuenta de AWS . Para obtener instrucciones, consulte [Creación de su primer grupo de administradores y usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) en la *Guía del usuario de IAM*.
1. Como usuario, puede iniciar sesión en el Consola de administración de AWS mediante una URL especial. Para obtener más información, consulte [Cómo inician sesión los usuarios en su cuenta](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_how-users-sign-in.html) en la *Guía del usuario de IAM*.
Para obtener más información sobre IAM, consulte lo siguiente:
+ [AWS Identity and Access Management (IAM)](https://aws.amazon.com/iam/)
+ [Cómo empezar con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html)
+ [Guía del usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
## Paso siguiente
[Paso 2: configurar el AWS Command Line Interface](gs-set-up-cli.md)
# Paso 2: configurar el AWS Command Line Interface
Si prefiere utilizar Amazon Lex con AWS Command Line Interface (AWS CLI), descárguelo y configúrelo.
**importante**
No los necesita AWS CLI para realizar los pasos de los ejercicios de introducción. Sin embargo, en algunos de los ejercicios posteriores de esta guía se utiliza la AWS CLI. Si prefiere empezar con la consola, omita este paso y vaya a [Paso 3: Introducción (consola)](gs-console.md). Más adelante, cuando lo necesites AWS CLI, vuelve aquí para configurarlo.
**Para configurar el AWS CLI**
1. Descargue y configure la AWS CLI. Para obtener instrucciones, consulte los siguientes temas en la *Guía del usuario de AWS Command Line Interface *:
+ [Cómo configurarse con el AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
+ [Configuración de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Agregue un perfil con nombre para el usuario administrador al final del archivo de AWS CLI configuración. Este perfil se utiliza al ejecutar AWS CLI comandos. Para obtener más información sobre los perfiles con nombre, consulte [Perfiles con nombre](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) en la *Guía del usuario de la 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 obtener una lista de AWS las regiones disponibles, consulte [Regiones y puntos finales](https://docs.aws.amazon.com/general/latest/gr/rande.html) en la *Referencia general de Amazon Web Services*.
1. Compruebe la configuración; para ello, escriba el comando de ayuda en el símbolo del sistema:
```
aws help
```
##
[Paso 3: Introducción (consola)](gs-console.md)
# Paso 3: Introducción (consola)
La forma más sencilla de aprender a utilizar Amazon Lex es mediante la consola. Para comenzar, hemos creado los siguientes ejercicios, en todos los cuales se utiliza la consola:
+ Ejercicio 1: crear un bot de Amazon Lex mediante un esquema, un bot predefinido que proporciona toda la configuración necesaria para el bot. Solo tiene que hacer un mínimo de trabajo para probar la end-to-end configuración.
Además, se utiliza el esquema de funciones Lambda, proporcionado por AWS Lambda, para crear una función Lambda. La función es un enlace de código que utiliza código predefinido que es compatible con su bot.
+ Ejercicio 2: crear y configurar manualmente un bot personalizado. También creará una función de Lambda como enlace de código. Se proporciona un código de muestra.
+ Ejercicio 3: publicar un bot y crear una nueva versión. En este ejercicio también va a crear un alias que apunte a la versión del bot.
**Topics**
+ [
# Ejercicio 1: creación de un bot de Amazon Lex mediante un esquema (consola)
](gs-bp.md)
+ [
# Ejercicio 2: creación de un bot de Amazon Lex personalizado
](getting-started-ex2.md)
+ [
# Ejercicio 3: publicación de una versión y creación de un alias
](gettingstarted-ex3.md)
# Ejercicio 1: creación de un bot de Amazon Lex mediante un esquema (consola)
En este ejercicio, hará lo siguiente:
+ Crear su primer bot de Amazon Lex y probarlo en la consola de Amazon Lex.
Para este ejercicio, utilizará el **OrderFlowers**plano. Para obtener más información sobre los proyectos, consulte [Amazon Lex y AWS Lambda planos](lex-lambda-blueprints.md).
+ Cree una AWS Lambda función y pruébela en la consola Lambda. Cuando procesa una solicitud, el bot llama a esta función de Lambda. Para este ejercicio, utilizará un blueprint de Lambda (**lex-order-flowers-python**) incluido en la AWS Lambda consola para crear la función Lambda. El código del esquema indica cómo se puede utilizar la misma función de Lambda para la inicialización y validación, así como para llevar a cabo la intención `OrderFlowers`.
+ Actualizar el bot para agregar la función de Lambda como el enlace de código que permite cumplir con la intención. Pon a prueba la experiencia. end-to-end
En las siguientes secciones se explica qué hacen los proyectos.
## Bot de Amazon Lex: descripción general del esquema
El **OrderFlowers**plano se utiliza para crear un bot de Amazon Lex. Para obtener más información sobre la estructura de un bot, consulte. [Funcionamiento de Amazon Lex](how-it-works.md) El bot está preconfigurado del modo siguiente:
+ **Intención:** OrderFlowers
+ **Tipos de slot**: un tipo de slot personalizado denominado `FlowerTypes` con los valores de enumeración: `roses`, `lilies` y `tulips`.
+ **Slots**: la intención requiere la siguiente información (es decir, slots) para que el bot pueda llevar a cabo la intención.
+ `PickupTime` (AMAZON.TIME built-in type)
+ `FlowerType`(tipo FlowerTypes personalizado)
+ `PickupDate` (tipo integrado AMAZON.DATE)
+ **Enunciados**: los siguientes enunciados de muestra identifican la intención del usuario:
+ «Me gustaría recoger unas flores».
+ «Me gustaría pedir unas flores».
+ **Preguntas**: una vez que el bot identifica la intención, utiliza las siguientes preguntas para rellenar los slots:
+ Pregunta para el slot `FlowerType`: «¿Qué tipo de flores deseas pedir?»
+ Pregunta para el `PickupDate` espacio: «¿Qué día quieres que recojan el \$1FlowerType\$1?»
+ Pregunta sobre el `PickupTime` espacio: «¿A qué hora quieres que recojan el \$1FlowerType\$1?»
+ Declaración de confirmación: «De acuerdo, tu \$1FlowerType\$1 estará listo para ser recogido antes del \$1PickupTime\$1 el \$1PickupDate\$1. ¿Te parece bien?»
## AWS Lambda Función: resumen del plano
La función de Lambda de este ejercicio realiza tanto las tareas de inicialización y validación como las de cumplimiento. Por lo tanto, después de crear la función de Lambda, deberá actualizar la configuración de la intención y especificar la misma función de Lambda como enlace de código para administrar las tareas de inicialización o validación y de cumplimiento.
+ Como enlace de código de inicialización y validación, la función de Lambda realiza la validación básica. Por ejemplo, si el usuario indica una hora de recogida que está fuera del horario de apertura habitual, la función de Lambda indica a Amazon Lex que solicite una hora nueva al usuario.
+ Como parte del enlace de código de cumplimiento, la función de Lambda devuelve un mensaje de resumen que indica que se ha realizado el pedido de flores (es decir, que se ha cumplido con la intención).
**Paso siguiente**
[Paso 1: creación de un bot de Amazon Lex (consola)](gs-bp-create-bot.md)
# Paso 1: creación de un bot de Amazon Lex (consola)
Para este ejercicio, crea un bot para pedir flores, llamado OrderFlowersBot.
Creación de un bot de Amazon Lex (consola)
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Si es su primer bot, elija **Get Started (Empezar)**; de lo contrario, en la página **Bots**, elija **Create (Crear)**.
1. En la página **Create your Lex bot**, proporcione la información siguiente y, a continuación, seleccione **Create**.
+ Elija el proyecto **OrderFlowers**.
+ Deje el nombre del bot predeterminado (OrderFlowers).
+ En **COPPA**, elija **No**.
+ En **Almacenamiento de enunciados del usuario**, elija la respuesta adecuada.
1. Seleccione **Crear**. La consola realiza las solicitudes necesarias para que Amazon Lex guarde la configuración. A continuación, la consola muestra la ventana del editor de bots.
1. Espere a que se le confirme que se creó su bot.
1. Pruebe el bot.
**nota**
Puede probar el bot escribiendo el texto en la ventana de prueba o, con navegadores compatibles, seleccionando el botón de micrófono en la misma ventana y hablando.
Utilice el siguiente texto de ejemplo para participar en la conversación con el bot para pedir flores:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/OrderFlowers-NoLambda.png)
A partir de esta entrada, el bot deduce la intención `OrderFlowers` y solicita los datos de slot. Cuando proporcione todos los datos necesarios del slot, el bot llevará a cabo la intención (`OrderFlowers`) devolviendo toda la información a la aplicación cliente (en este caso, la consola). La consola simplemente muestra la información en la ventana de prueba.
En concreto:
+ En la instrucción "¿Qué día desea recoger las rosas?" aparece el término "rosas" porque la pregunta del slot `pickupDate` está configurada con sustituciones, `{FlowerType}`. Compruébelo en la consola.
+ La instrucción "Bien, sus rosas estarán listas..." es lo que ha configurado para la confirmación.
+ La última instrucción ("`FlowerType:roses...`") incluye solo los datos de slot que se devuelven al cliente, en este caso, en la ventana de prueba. En el siguiente ejercicio, utilizará una función de Lambda para llevar a cabo la intención, en cuyo caso obtendrá un mensaje que indica que se ha efectuado el pedido.
**Paso siguiente**
[Paso 2 (opcional): revisión de los detalles del flujo de información (consola)](gs-bp-details-two-runtime-apis.md)
# Paso 2 (opcional): revisión de los detalles del flujo de información (consola)
En esta sección se explica el flujo de información entre un cliente y Amazon Lex para cada entrada de usuario en nuestra conversación de ejemplo.
En el ejemplo se utiliza la ventana de pruebas de la consola para mostrar la conversación con el bot.
**Visualización de la ventana de pruebas de Amazon Lex**
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Elija el bot que quiera probar.
1. En la parte derecha de la consola, elija **Probar bot de chat**.
Para ver el flujo de información de contenido hablado o escrito, elija el tema correspondiente.
**Topics**
+ [
# Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)
](gs-bp-details-postcontent-flow.md)
+ [
# Paso 2b (opcional): revisión de los detalles del flujo de información escrita (consola)
](gs-bp-details-part1.md)
# Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex cuando el cliente utiliza la voz para enviar solicitudes. Para obtener más información, consulte [PostContent](API_runtime_PostContent.md).
1. El usuario dice: Me gustaría pedir unas flores.
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a 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
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), su alias (`$LATEST`) y el nombre del usuario (una cadena aleatoria que identifica al usuario). `content` indica que se trata de una solicitud de la API `PostContent` (no una solicitud `PostText`).
+ Encabezados de solicitudes
+ `x-amz-lex-session-attributes`: el valor con codificación base64 representa “\$1\$1”. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión.
+ `Content-Type`: refleja el formato de audio.
+ Cuerpo de la solicitud: la transmisión de audio de la entrada del usuario ("Me gustaría pedir unas flores.").
**nota**
En caso de que el usuario elija enviar texto ("Me gustaría pedir unas flores") a la API `PostContent` en lugar de hablar, el cuerpo de la solicitud será la entrada del usuario. El encabezado `Content-Type` se fija en consecuencia:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: accept
Request body
input stream
```
1. Amazon Lex deduce la intención (`OrderFlowers`) a partir de la transmisión de entrada. A continuación, elige uno de los slots de la intención (en este caso, `FlowerType`) y una de sus preguntas para obtener valores y, luego, envía una respuesta con los siguientes encabezados:
```
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==
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-input-transcript`: proporciona la transcripción del audio (entrada del usuario) de la solicitud
+ `x-amz-lex-message`: proporciona la transcripción del audio que devuelve Amazon Lex en la respuesta
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: rosas
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a 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")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario (rosas). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `FlowerType`). En primer lugar, Amazon Lex actualiza el valor de ranura de la intención actual. Después, elige otro slot (`PickupDate`), junto con uno de los mensajes de pregunta (¿Cuándo desea pasar a por las rosas?) y devuelve una respuesta con los siguientes encabezados:
```
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=
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: mañana
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a 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")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("mañana"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `PickupDate`). Amazon Lex actualiza el valor de ranura (`PickupDate`) de la intención actual. A continuación, elige otro slot para obtener el valor (`PickupTime`) y una de las preguntas para obtener valores (¿Cuándo desea recoger las rosas el 18/03/2017?), y devuelve una respuesta con los siguientes encabezados:
```
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
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: 18:00 h
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a 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")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("18:00 h"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `PickupTime`). Primero actualiza el valor de slot de la intención actual.
Ahora Amazon Lex detecta que tiene información para todas las ranuras. Sin embargo, la intención `OrderFlowers` se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex necesita una confirmación explícita del usuario antes de cumplir con la intención. Envía una respuesta con los siguientes encabezados para solicitar la confirmación antes de encargar las 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
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: Sí
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a 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")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("Sí"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada y entiende que el usuario desea continuar con el pedido. La intención `OrderFlowers` se ha configurado con `ReturnIntent` como la actividad de cumplimiento. Esto provoca que Amazon Lex devuelva todos los datos de la intención al cliente. Amazon Lex devuelve una respuesta con lo siguiente:
```
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==
```
El encabezado de la respuesta `x-amz-lex-dialog-state` está configurado en `ReadyForFulfillment`. Ahora el cliente podrá llevar a cabo la intención.
1. Ahora, pruebe de nuevo el bot. Para establecer un nuevo contexto (usuario), elija el enlace **Clear** en la consola. Proporcione datos para la intención `OrderFlowers` e incluya algunos datos no válidos. Por ejemplo:
+ Jazmín como tipo de flor (este tipo de flor no se admite)
+ Ayer como el día en que desea recoger las flores
Observe que el bot acepta estos valores, ya que no tiene ningún código para inicializar y validar los datos de usuario. En la siguiente sección, añadirá una función de Lambda para que lo haga. Tenga en cuenta lo siguiente en relación con la función de Lambda:
+ Valida los datos de slot después de cada entrada de usuario. Gestiona la intención al final. Es decir, el bot procesa el pedido de flores y devuelve un mensaje al usuario en lugar de simplemente devolver los datos de slot al cliente. Para obtener más información, consulte [Uso de funciones de Lambda](using-lambda.md).
+ También establece los atributos de la sesión. Para obtener más información acerca de los atributos de sesión, consulte [PostText](API_runtime_PostText.md).
Una vez completada la sección Introducción, puede realizar los ejercicios adicionales ([Ejemplos adicionales: creación de bots de Amazon Lex](additional-exercises.md)). [Reserva de viaje](ex-book-trip.md) usa los atributos de sesión para compartir información entre intenciones y entablar una conversación dinámica con el usuario.
**Paso siguiente**
[Paso 3: creación de una función de Lambda (consola)](gs-bp-create-lambda-function.md)
# Paso 2b (opcional): revisión de los detalles del flujo de información escrita (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex en el que el cliente utiliza la API `PostText` para enviar solicitudes. Para obtener más información, consulte [PostText](API_runtime_PostText.md).
1. El usuario escribe: Me gustaría pedir unas flores
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a 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": {}
}
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), el alias del bot (`$LATEST`) y el nombre de usuario (una cadena aleatoria que identifica al usuario). El `text` de cola indica que se trata de una solicitud de API `PostText` (no `PostContent`).
+ Cuerpo de la solicitud: incluye la entrada del usuario (`inputText`). No hay `sessionAttributes`. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión. La función Lambda los inicia más adelante.
1. Amazon Lex deduce la intención (`OrderFlowers`) a partir de `inputText`. Esta intención no tiene ningún enlace de código (es decir, funciones de Lambda) para la inicialización y validación de la entrada del usuario o el cumplimiento.
Amazon Lex elige una de las ranuras de la intención (`FlowerType`) para obtener el valor. También selecciona una de las preguntas para obtener valores para el slot (que forman parte de la configuración de la intención) y, a continuación, envía la siguiente respuesta al cliente. La consola muestra el mensaje en la respuesta al usuario.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-10.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: rosas
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
1. En primer lugar, Amazon Lex interpreta `inputText` en el contexto de la intención actual (el servicio recuerda que ha solicitado al usuario información sobre la ranura `FlowerType`). Amazon Lex actualiza primero el valor del slot de la intención actual y elige otro slot (`PickupDate`) junto con uno de los mensajes de pregunta (¿Qué día desea recoger las rosas?) ``para el slot.
A continuación, Amazon Lex devuelve la siguiente respuesta:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-20.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: mañana
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
1. En primer lugar, Amazon Lex interpreta `inputText` en el contexto de la intención actual (el servicio recuerda que ha solicitado al usuario información sobre la ranura `PickupDate`). Amazon Lex actualiza el valor de ranura (`PickupDate`) de la intención actual. Elige otro slot para obtener un valor para (`PickupTime`). Devuelve una de las preguntas para obtener valores (¿A qué hora quiere que se entreguen las rosas el 05/01/2017?) ``al cliente.
A continuación, Amazon Lex devuelve la siguiente respuesta:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-30.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: 18:00 h
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
1. En primer lugar, Amazon Lex interpreta `inputText` en el contexto de la intención actual (el servicio recuerda que ha solicitado al usuario información sobre la ranura `PickupTime`). En primer lugar, Amazon Lex actualiza el valor de ranura de la intención actual. Ahora Amazon Lex detecta que tiene información para todas las ranuras.
La intención `OrderFlowers` se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex necesita una confirmación explícita del usuario antes de cumplir con la intención. Amazon Lex envía el siguiente mensaje al cliente para solicitar su confirmación antes de pedir las flores:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-40.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: Sí
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
1. Amazon Lex interpreta `inputText` en el contexto de la confirmación de la intención actual. Entiende que el usuario desea continuar con el pedido. La intención `OrderFlowers` se ha configurado con `ReturnIntent` como la actividad de cumplimiento (no existe ninguna función de Lambda para cumplir con la intención). Por ello, Amazon Lex devuelve los siguientes datos de ranura al cliente.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex establece `dialogState` en `ReadyForFulfillment`. Ahora el cliente podrá llevar a cabo la intención.
1. Ahora vuelva a probar el bot. Para ello, debe elegir el enlace **Clear** en la consola y establecer un nuevo contexto (usuario). Al proporcionar datos para la intención Pedir flores, intente que sean datos no válidos. Por ejemplo:
+ Jazmín como tipo de flor (este tipo de flor no se admite).
+ Ayer como el día en que desea recoger las flores.
Ten en cuenta que el bot acepta estos valores porque no tienes ningún código para los datos initialize/validate del usuario. En la siguiente sección, añadirá una función de Lambda para que lo haga. Tenga en cuenta lo siguiente en relación con la función de Lambda:
+ La función de Lambda valida los datos de ranura después de cada entrada del usuario. Gestiona la intención al final. Es decir, el bot procesa el pedido de flores y devuelve un mensaje al usuario en lugar de simplemente devolver los datos de slot al cliente. Para obtener más información, consulte [Uso de funciones de Lambda](using-lambda.md).
+ La función de Lambda también establece los atributos de la sesión. Para obtener más información acerca de los atributos de sesión, consulte [PostText](API_runtime_PostText.md).
Una vez completada la sección Introducción, puede realizar los ejercicios adicionales ([Ejemplos adicionales: creación de bots de Amazon Lex](additional-exercises.md)). [Reserva de viaje](ex-book-trip.md) usa los atributos de sesión para compartir información entre intenciones y entablar una conversación dinámica con el usuario.
**Paso siguiente**
[Paso 3: creación de una función de Lambda (consola)](gs-bp-create-lambda-function.md)
# Paso 3: creación de una función de Lambda (consola)
Cree una función Lambda (mediante el **lex-order-flowers-python**esquema) y realice una invocación de prueba con datos de eventos de muestra en la consola. AWS Lambda
Regrese a la consola de Amazon Lex y agregue la función de Lambda como el enlace de código para cumplir la intención `OrderFlowers` en `OrderFlowersBot` que ha creado en la sección anterior.
**Para crear la función Lambda (consola)**
1. Inicie sesión en la consola Consola de administración de AWS y ábrala en AWS Lambda . [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Seleccione **Creación de función**.
1. En la página **Create function (Crear función)**, seleccione **Use a blueprint (Utilizar un proyecto)**. Escriba **lex-** en el cuadro de texto de filtro y pulse `Enter` para buscar el proyecto. Seleccione el proyecto `lex-order-flowers-python`.
Los esquemas de funciones de Lambda están en formato Node.js y Python. En este ejercicio, utilizaremos el proyecto basado en Python.
1. En la página **Basic information (Información básica)**, haga lo siguiente:
+ Escriba el nombre de la función de Lambda (`OrderFlowersCodeHook`).
+ Para el rol de ejecución, elija **Crear un nuevo rol con permisos básicos de Lambda**.
+ Deje los demás valores predeterminados.
1. Seleccione **Creación de función**.
1. Si utiliza una configuración regional que no sea Inglés (EE. UU.) (en-US), actualice los nombres de las intenciones tal como se indica en [Actualización de un esquema para una configuración regional específica](lex-lambda-blueprints.md#blueprint-update-locale).
1. Pruebe la función de Lambda.
1. Haga clic en **Select a test event (Seleccionar un evento de prueba)** y en **Configure test events (Configurar eventos de prueba)**.
1. Seleccione **Amazon Lex Order Flowers (Pedido de flores de Amazon Lex)** en la lista **Event template (Plantilla de eventos)**. Este evento de muestra coincide con el request/response modelo Amazon Lex (consulte[Uso de funciones de Lambda](using-lambda.md)). Asigne un nombre al evento de prueba (`LexOrderFlowersTest`).
1. Seleccione **Crear**.
1. Seleccione **Test (Probar)** para probar el enlace de código.
1. Compruebe que la función de Lambda se ha ejecutado correctamente. En este caso, la respuesta sigue el modelo de respuesta de Amazon Lex.
**Paso siguiente**
[Paso 4: adición de la función de Lambda como enlace de código (consola)](gs-bp-create-integrate.md)
# Paso 4: adición de la función de Lambda como enlace de código (consola)
En esta sección, se actualiza la configuración de la OrderFlowers intención de utilizar la función Lambda de la siguiente manera:
+ Primero debe utilizar la función de Lambda como enlace de código para cumplir con la intención `OrderFlowers`. Puede probar el bot y verificar que ha recibido un mensaje de cumplimiento de la función de Lambda. Amazon Lex invoca la función de Lambda únicamente después de proporcionar datos para todas las ranuras necesarias para pedir flores.
+ Configure la misma función de Lambda como enlace de código para llevar a cabo la inicialización y la validación. Puede probar y comprobar que la función de Lambda realiza la validación (a medida que proporciona datos de ranura).
**Adición de una función de Lambda como enlace de código (consola)**
1. En la consola Amazon Lex, selecciona el **OrderFlowers**bot. La consola muestra la **OrderFlowers**intención. Asegúrese de que la versión de la intención está establecida en `$LATEST` porque esta es la única versión que podemos modificar.
1. Agregue la función de Lambda como enlace de código de cumplimiento y pruébela.
1. En el editor, elija **AWS Lambda Función** como **Cumplimiento** y seleccione la función de Lambda que ha creado en el paso anterior (`OrderFlowersCodeHook`). Elija **Aceptar** para dar a Amazon Lex permiso para invocar la función de Lambda.
Está configurando esta función de Lambda como un enlace de código para cumplir con la intención. Amazon Lex invoca esta función únicamente después de disponer de todos los datos de ranura necesarios para llevar a cabo la intención.
1. Especifique un **mensaje de despedida**.
1. Elija **Compilar**.
1. Pruebe el bot utilizando la conversación anterior.
La última frase, “Gracias, su pedido de rosas…”, es una respuesta de la función de Lambda configurada como enlace de código. En la sección anterior, no había ninguna función de Lambda. Ahora utiliza una función de Lambda para cumplir realmente la intención `OrderFlowers`.
1. Añada la función de Lambda como un enlace de código de inicialización y validación y pruébela.
El código del ejemplo de función de Lambda que utiliza se encarga tanto de la validación de la entrada del usuario como del cumplimiento. El evento de entrada que recibe la función de Lambda tiene un campo (`invocationSource`) que el código utiliza para determinar qué parte del código debe ejecutar. Para obtener más información, consulte [Formato del evento de entrada y de la respuesta de la función de Lambda](lambda-input-response-format.md).
1. Seleccione la versión \$1LATEST de la intención `OrderFlowers`. Esa es la única versión que puede actualizar.
1. En el Editor, seleccione **Initialization and validation** en **Options**.
1. De nuevo, seleccione la misma función de Lambda.
1. Elija **Compilar**.
1. Pruebe el bot.
Ahora está listo para conversar con Amazon Lex como se indica en la siguiente imagen. Para probar la parte de validación, elija la hora 18:00. La función de Lambda devolverá una respuesta (“Nuestro horario es de 10:00 a 17:00 horas”) y le preguntará de nuevo. Después de proporcionar todos los datos de ranura válidos, la función de Lambda realizará el pedido.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Paso siguiente**
[Paso 5 (opcional): revisión de los detalles del flujo de información (consola)](gs-bp-details-after-lambda.md)
# Paso 5 (opcional): revisión de los detalles del flujo de información (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex para cada entrada del usuario, incluida la integración de la función de Lambda.
**nota**
En esta sección se supone que el cliente envía solicitudes a Amazon Lex mediante la API en tiempo de ejecución `PostText` y se muestran los detalles correspondientes de la solicitud y la respuesta. Para ver un ejemplo de flujo de información entre el cliente y Amazon Lex en el que el usuario usa la API `PostContent`, consulte [Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)](gs-bp-details-postcontent-flow.md).
Para obtener más información sobre la API en tiempo de ejecución `PostText` y detalles adicionales sobre las solicitudes y las respuestas que se muestran en los siguientes pasos, consulte [PostText](API_runtime_PostText.md).
1. Usuario: Me gustaría pedir unas flores.
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a 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": {}
}
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), el alias del bot (`$LATEST`) y el nombre de usuario (una cadena aleatoria que identifica al usuario). El `text` de cola indica que se trata de una solicitud de API `PostText` (no `PostContent`).
+ Cuerpo de la solicitud: incluye la entrada del usuario (`inputText`). No hay `sessionAttributes`. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión. La función Lambda los inicia más adelante.
1. Amazon Lex deduce la intención (`OrderFlowers`) a partir de `inputText`. Esta intención está configurada con una función de Lambda como enlace de código para las tareas de inicialización y validación de los datos del usuario. Por ello, Amazon Lex invoca la función de Lambda mediante la transferencia de la siguiente información como datos de eventos:
```
{
"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 obtener más información, consulte [Formato del evento de entrada](lambda-input-response-format.md#using-lambda-input-event-format).
Además de la información que envía el cliente, Amazon Lex también incluye los siguientes datos adicionales:
+ `messageVersion`: actualmente Amazon Lex solo es compatible con la versión 1.0.
+ `invocationSource`: indica la finalidad de la invocación de la función de Lambda. En este caso, es para inicializar y validar los datos del usuario. En este punto, Amazon Lex sabe que el usuario no ha proporcionado todos los datos de ranura necesarios para cumplir la intención.
+ Información de `currentIntent` con todos los valores de slot establecidos en nulos.
1. En este momento, todos los valores de slot son nulos. La función de Lambda no tiene que validar nada. y devuelve la siguiente respuesta a Amazon Lex:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Para obtener más información sobre el formato de la respuesta, consulte [Formato de respuesta](lambda-input-response-format.md#using-lambda-response-format).
Tenga en cuenta lo siguiente:
+ `dialogAction.type`: al establecer este valor en `Delegate`, la función de Lambda delega la responsabilidad de decidir el siguiente procedimiento a Amazon Lex.
**nota**
Si la función de Lambda detecta algo en la validación de los datos de usuario, indica a Amazon Lex el siguiente paso, tal como se muestra a continuación.
1. De acuerdo con `dialogAction.type`, Amazon Lex decide cómo continuar. Puesto que ninguno de los slots tiene información, decide obtener el valor del slot `FlowerType`. Selecciona una de las preguntas para obtener valores para el slot ("¿Qué tipo de flores le gustaría pedir?") y envía la siguiente respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-10.png)
El cliente muestra el mensaje en la respuesta.
1. Usuario: rosas
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario. No hay `sessionAttributes`.
1. Amazon Lex interpreta primero `inputText` en el contexto de la confirmación de la intención actual. El servicio recuerda que ha solicitado al usuario específico información acerca del slot `FlowerType`. Actualiza el valor de la ranura para la intención actual e invoca la función de Lambda con los siguientes datos 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": "roses",
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Tenga en cuenta lo siguiente:
+ `invocationSource`: sigue siendo `DialogCodeHook` (simplemente validamos los datos de usuario).
+ `currentIntent.slots`: Amazon Lex ha actualizado la ranura `FlowerType` con “roses”.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos del usuario. Reconoce `roses` como un valor de ranura válido (y establece `Price` como atributo de la sesión) y devuelve la siguiente respuesta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: la función de Lambda ha agregado `Price` (de las rosas) como un atributo de la sesión.
+ `dialogAction.type`: se establece en `Delegate`. Los datos del usuario son válidos, por lo que la función de Lambda indica a Amazon Lex que decida el siguiente paso.
1. Amazon Lex elige el siguiente paso en función de `dialogAction.type`. Amazon Lex sabe que necesita más datos de ranura, de modo que elige la siguiente ranura vacía (`PickupDate`) con la mayor prioridad según la configuración de la intención. Amazon Lex selecciona uno de los mensajes de pregunta (“¿Qué día desea recoger las rosas?”) para esta ranura, según la configuración de la intención y, a continuación, envía esta respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-20.png)
El cliente simplemente muestra el mensaje en la respuesta: "¿Qué día desea recoger las rosas?."
1. Usuario: mañana
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario y el cliente devuelve los atributos de la sesión al servicio.
1. Amazon Lex recuerda el contexto; es decir, que está obteniendo datos para la ranura `PickupDate`. En este contexto, sabe que el valor de `inputText` es para el slot `PickupDate`. A continuación, Amazon Lex llama la función de Lambda mediante el envío de los siguientes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex ha actualizado `currentIntent.slots` al establecer el valor `PickupDate`. Además, tenga en cuenta que el servicio pasa `sessionAttributes` tal cual a la función de Lambda.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos de usuario. Reconoce que el valor de la ranura `PickupDate` es válido y devuelve la siguiente respuesta a Amazon Lex:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: sin cambios.
+ `dialogAction.type`: se establece en `Delegate`. Los datos del usuario son válidos, por lo que la función de Lambda indica a Amazon Lex que decida el siguiente paso.
1. Amazon Lex elige el siguiente paso en función de `dialogAction.type`. Amazon Lex sabe que necesita más datos de ranura, de modo que elige la siguiente ranura vacía (`PickupTime`) con la mayor prioridad según la configuración de la intención. Amazon Lex selecciona uno de los mensajes de pregunta (“¿A qué hora quiere que se entreguen las rosas el 05/01/2017?”) para esta ranura, según la configuración de la intención y, a continuación, envía esta respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-30.png)
El cliente muestra el mensaje en la respuesta: “¿A qué hora quiere que entreguen las rosas el 05/01/2017?”.
1. Usuario: 16:00 h
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a 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"
}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario. El cliente pasa los `sessionAttributes` en la solicitud.
1. Amazon Lex entiende el contexto. Entiende que estaba obteniendo datos para el slot `PickupTime`. En este contexto, sabe que el valor `inputText` es para la ranura `PickupTime`. A continuación, Amazon Lex llama la función de Lambda mediante el envío de los siguientes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex ha actualizado `currentIntent.slots` al establecer el valor `PickupTime`.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos del usuario. Reconoce que el valor de la ranura `PickupDate` es válido y devuelve la siguiente respuesta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: sin cambios en el atributo de la sesión.
+ `dialogAction.type`: se establece en `Delegate`. Los datos del usuario son válidos, por lo que la función de Lambda indica a Amazon Lex que decida el siguiente paso.
1. En este punto, Amazon Lex sabe que dispone de todos los datos de ranura. Esta intención se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex envía la siguiente respuesta al usuario para solicitar su confirmación antes de cumplir con la intención:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-45.png)
El cliente simplemente muestra el mensaje en la respuesta y espera la respuesta del usuario.
1. Usuario: Sí
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "yes",
"sessionAttributes": {
"Price": "25"
}
}
```
1. Amazon Lex interpreta `inputText` en el contexto de la confirmación de la intención actual. Amazon Lex entiende que el usuario desea continuar con el pedido. Esta vez, Amazon Lex invoca la función de Lambda para cumplir la intención mediante el envío del siguiente evento, que establece `invocationSource` en `FulfillmentCodeHook` en el caso de que se envíe a la función. Amazon Lex también establece `confirmationStatus` en `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"
}
}
```
Tenga en cuenta lo siguiente:
+ `invocationSource`: esta vez, Amazon Lex configura este valor como `FulfillmentCodeHook`, por lo que indica a la función de Lambda que cumpla con la intención.
+ `confirmationStatus`: se establece en `Confirmed`.
1. Esta vez, la función de Lambda cumple con la intención `OrderFlowers` y devuelve la siguiente respuesta:
```
{
"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"
}
}
}
```
Tenga en cuenta lo siguiente:
+ Establece `dialogAction.type`: la función de Lambda establece este valor en `Close` para que Amazon Lex no espere una respuesta del usuario.
+ `dialogAction.fulfillmentState`: se establece en Fulfilled e incluye un `message` adecuado para transmitir al usuario.
1. Amazon Lex analiza `fulfillmentState` y envía la siguiente respuesta de vuelta al cliente:
A continuación, Amazon Lex devuelve lo siguiente al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-48.png)
Tenga en cuenta que:
+ `dialogState`: Amazon Lex establece este valor en `fulfilled`.
+ `message`: es el mismo mensaje que ha proporcionado la función de Lambda.
El cliente muestra el mensaje.
1. Ahora vuelva a probar el bot. Para establecer un nuevo contexto (usuario), elija el enlace **Clear** en la ventana de prueba. Ahora proporcione datos de slot no válidos para la intención `OrderFlowers`. Esta vez, la función de Lambda valida los datos, restablece el valor de los datos de ranura no válidos en nulo y pide a Amazon Lex que solicite al usuario datos válidos. Por ejemplo, pruebe lo siguiente:
+ Jazmín como tipo de flor (este tipo de flor no se admite).
+ Ayer como el día en que desea recoger las flores.
+ Después de realizar el pedido, escriba otro tipo de flores en lugar de responder "sí" para confirmar el pedido. Como respuesta, la función de Lambda actualiza `Price` en el atributo de la sesión y mantiene un recuento actual de los pedidos de flores.
La función de Lambda también lleva a cabo la actividad de cumplimiento.
**Paso siguiente**
[Paso 6: actualización de la configuración de la intención para añadir un enunciado (consola)](gs-bp-utterance.md)
# Paso 6: actualización de la configuración de la intención para añadir un enunciado (consola)
El bot `OrderFlowers` está configurado con tan solo dos enunciados. Esto proporciona información limitada para que Amazon Lex genere un modelo de machine learning que reconozca la intención del usuario y responda a esta. Pruebe a escribir “Deseo encargar flores” en la siguiente ventana de pruebas. Amazon Lex no reconoce el texto y responde “No he entendido, ¿qué desea hacer?”. Puede mejorar el modelo de machine learning añadiendo más enunciados.
![\[Ventana de pruebas con un enunciado no reconocido\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-120.png)
Cada enunciado que agrega proporciona a Amazon Lex más información sobre cómo responder a los usuarios. No es necesario añadir un enunciado, exacto, Amazon Lex generaliza a partir de las muestras que proporcione para reconocer las coincidencias exactas y entradas similares.
**Para añadir un enunciado (consola)**
1. Escriba el enunciado “Quiero flores” en la sección **Ejemplos de enunciados** del editor de intenciones para agregarlo, tal como se indica en la siguiente imagen, y, a continuación, haga clic en el icono del signo más situado junto a la nueva publicación.
![\[Editor de intenciones con el nuevo enunciado\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-130.png)
1. Compile el bot para incluir el cambio. Elija **Build** y vuelva a elegir **Build**.
1. Pruebe el bot para confirmar que reconoce el nuevo enunciado. En la ventana de pruebas, tal como se indica en la siguiente imagen, escriba “Quiero pedir flores”. Amazon Lex reconoce la frase y responde con “¿Qué tipo de flores desea encargar?”.
![\[El editor de intenciones reconoce el nuevo enunciado\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-140.png)
**Paso siguiente**
[Paso 7 (opcional): eliminar recursos (consola)](gs-bp-cleaning-up.md)
# Paso 7 (opcional): eliminar recursos (consola)
Ahora va a eliminar los recursos que ha creado y a limpiar la cuenta.
Puede eliminar únicamente los recursos que no se usan. En general, debería eliminar los recursos en el orden que se indica a continuación:
+ Eliminar bots para liberar los recursos de las intenciones.
+ Eliminar intenciones para liberar los recursos de los tipos de slot.
+ Por último, eliminar el tipo de slot.
**Para limpiar la cuenta (consola)**
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. En la lista de bots, selecciona la casilla de verificación situada junto a **OrderFlowers**.
1. Para borrar el bot, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
1. En el panel izquierdo, elija **Intents**.
1. En la lista de intenciones, elija **OrderFlowersIntent**.
1. Para eliminar la intención, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
1. En el panel izquierdo, elija **Slot types**.
1. En la lista de tipos de slot, elija **Flowers**.
1. Para borrar el tipo de slot, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
Ha eliminado todos los recursos de Amazon Lex que ha creado y ha limpiado su cuenta. Si lo desea, puede utilizar la [consola de Lambda](https://console.aws.amazon.com/lambda) para eliminar la función de Lambda que se utiliza en este ejercicio.
# Ejercicio 2: creación de un bot de Amazon Lex personalizado
En este ejercicio, utilizará la consola de Amazon Lex para crear un bot personalizado que encargue una pizza (`OrderPizzaBot`). Para configurar el bot, añada una intención personalizada (`OrderPizza`), defina los tipos de slot personalizados y defina los slots necesarios para llevar a cabo el pedido de pizza (la masa de la pizza, el tamaño de la pizza, etc.). Para obtener más información sobre los slots y los tipos de slot, consulte [Funcionamiento de Amazon Lex](how-it-works.md).
**Topics**
+ [
# Paso 1: Crear una función Lambda
](gs2-prepare.md)
+ [
# Paso 2: creación de un bot
](gs2-create-bot.md)
+ [
# Paso 3: compilación y prueba del bot
](gs2-build-and-test.md)
+ [
# Paso 4 (opcional): Eliminación
](gs2-clean-up.md)
# Paso 1: Crear una función Lambda
En primer lugar, cree una función de Lambda que pida una pizza. Deberá especificar esta función en el bot de Amazon Lex que creará en la siguiente sección.
**Cómo crear una función de Lambda**
1. Inicie sesión en Consola de administración de AWS y abra la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Seleccione **Creación de función**.
1. En la página **Crear función**, elija **Diseñar desde cero**.
Dado que está utilizando el código personalizado que se le ha proporcionado en este ejercicio para crear una función Lambda, debe seleccionar la opción para crear la función desde cero.
Haga lo siguiente:
1. Escriba el nombre (`PizzaOrderProcessor`).
1. En **Runtime**, elija la última versión de Node.js.
1. En **Role**, elija **Create new role from template(s)**.
1. Escriba un nombre nuevo para el rol (`PizzaOrderProcessorRole`).
1. Seleccione **Creación de función**.
1. En la página function, haga lo siguiente:
En la sección **Function code**, elija **Edit code inline** y, a continuación, copie el siguiente código de función de Node.js y péguelo en la ventana.
```
'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. Seleccione **Save**.
## Prueba de la función de Lambda con datos de eventos de ejemplo
En la consola, pruebe la función de Lambda con datos de eventos de ejemplo para invocarla de manera manual.
**Para probar la función de Lambda:**
1. Inicie sesión en Consola de administración de AWS y abra la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. En la página **Función de Lambda**, elija la función de Lambda (`PizzaOrderProcessor).`
1. En la página de la función, en la lista de eventos de prueba, elija **Configure test events**.
1. En la página **Configure test event**, haga lo siguiente:
1. Elija **Crear nuevo evento de prueba**.
1. En el campo **Event name**, escriba un nombre para el evento (`PizzaOrderProcessorTest`).
1. Copie el siguiente evento de Amazon Lex en la ventana.
```
{
"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. Seleccione **Crear**.
AWS Lambda crea la prueba y tú vuelves a la página de funciones. Elija **Probar** y Lambda ejecutará la función de Lambda.
En el cuadro de resultados, elija **Details**. La consola muestra la salida siguiente en el panel **Execution result**.
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Okay, I have ordered your large meat pizza on thin crust."
}
}
```
## Paso siguiente
[Paso 2: creación de un bot](gs2-create-bot.md)
# Paso 2: creación de un bot
En este paso, debe crear un bot para gestionar los pedidos de pizza.
**Topics**
+ [
# Cree el bot
](gs2-create-bot-create.md)
+ [
# Cree una intención
](gs2-create-bot-intent.md)
+ [
# Cree tipos de slot
](gs2-create-bot-slot-types.md)
+ [
# Configure la intención
](gs2-create-bot-configure-intent.md)
+ [
# Configuración del bot de
](gs2-create-bot-configure-bot.md)
# Cree el bot
Cree el bot `PizzaOrderingBot` con el mínimo de información necesaria. Más adelante, puede añadir una intención, que es una acción que el usuario desea realizar, para el bot.
**Para crear el bot**
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Cree un bot.
1. Si está creando su primer bot, elija **Empezar**. De lo contrario, elija **Bots** y, a continuación, seleccione **Create**.
1. En la página **Crear un bot de Lex**, elija **Bot personalizado** y proporcione la siguiente información:
+ **Nombre del bot**: PizzaOrderingBot
+ **Idioma**: elija el idioma y la configuración regional del bot.
+ **Output voice**: Salli
+ **Session timeout **: 5 minutos.
+ **COPPA**: elija la respuesta adecuada.
+ **Almacenamiento de enunciados del usuario**: elija la respuesta adecuada.
1. Seleccione **Crear**.
La consola envía a Amazon Lex una solicitud para crear un nuevo bot. Amazon Lex establece la versión del bot en `$LATEST`. Después de crear el bot, Amazon Lex muestra la pestaña **Editor** del bot, tal como se indica en la siguiente imagen:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-20.png)
+ La versión del bot, **Latest**, aparece junto al nombre del bot en la consola. Los nuevos recursos de Amazon Lex tienen la versión `$LATEST`. Para obtener más información, consulte [Control de versiones y alias](versioning-aliases.md).
+ Dado que todavía no ha creado ninguna intención ni tipo de slot, no se indica ninguno.
+ **Build** y **Publish** son actividades del nivel de bot. Después de configurar todo el bot, podrá obtener más información sobre estas actividades.
## Paso siguiente
[Cree una intención](gs2-create-bot-intent.md)
# Cree una intención
Ahora, cree la intención `OrderPizza`, una acción que el usuario desea realizar, con el mínimo de información necesaria. Puede añadir tipos de slot para la intención y luego configurar la intención en otro momento.
**Para crear una intención**
1. En la consola de Amazon Lex, elija el signo más (\$1) junto a **Intenciones** y, a continuación, seleccione **Crear nueva intención**.
1. En el cuadro de diálogo **Create intent**, escriba el nombre de la intención (`OrderPizza`) y, a continuación, elija **Add**.
La consola envía una solicitud a Amazon Lex para crear la intención `OrderPizza`. En este ejemplo se crean ranuras para la intención después de crear los tipos de ranura.
## Paso siguiente
[Cree tipos de slot](gs2-create-bot-slot-types.md)
# Cree tipos de slot
Cree los tipos de slot, o valores de parámetros, que utiliza la intención `OrderPizza`.
**Para crear tipos de slot**
1. En el menú de la izquierda, seleccione el signo más (\$1) junto a **Slot types**.
1. En el cuadro de diálogo **Add slot type**, añada lo siguiente:
+ **Slot type name**: Crusts
+ **Description**: Available crusts
+ Elija **Restrict to Slot values and Synonyms**
+ **Valor**: escriba **thick**. Pulse en la pestaña y, en el campo **Synonym**, escriba **stuffed**. Elija el signo más (\$1). Escriba **thin** y, a continuación, elija el signo más (\$1) de nuevo.
El cuadro de diálogo debería ser similar al de la siguiente imagen:
![\[Cuadro de diálogo de edición de tipo de slot.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-25a.png)
1. Elija **Add slot to intent**.
1. En la página **Intent**, elija **Required**. Cambie el nombre del slot de **slotOne** a **crust**. Cambie la pregunta a **What kind of crust would you like?**
1. Repita el [Step 1](#slotTypeStart) al [Step 4](#slotTypeFinish) utilizando los valores de la siguiente tabla:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/gs2-create-bot-slot-types.html)
## Paso siguiente
[Configure la intención](gs2-create-bot-configure-intent.md)
# Configure la intención
Configure la intención `OrderPizza` para llevar a cabo la solicitud de pizza de un usuario.
**Para configurar una intención**
+ En la página **OrderPizza**de configuración, configure la intención de la siguiente manera:
+ **Ejemplos de enunciados**: escriba las siguientes cadenas. Las llaves \$1\$1 incluyen los nombres de slot.
+ Deseo pedir una pizza, por favor
+ Deseo pedir una pizza
+ Deseo pedir una pizza \$1pizzaKind\$1
+ Deseo pedir una pizza \$1size\$1 \$1pizzaKind\$1
+ Deseo una pizza \$1size\$1 con masa \$1crust\$1 \$1pizzaKind\$1
+ ¿Puede traerme una pizza, por favor?
+ ¿Puede traerme una pizza \$1pizzaKind\$1?
+ ¿Puede traerme una pizza \$1size\$1 \$1pizzaKind\$1?
+ **Lambda initialization and validation**: deje el valor predeterminado.
+ **Confirmation prompt**: deje el valor predeterminado.
+ **Cumplimiento**: realice las siguientes tareas:
+ Elija **función AWS Lambda **.
+ Elija **PizzaOrderProcessor**.
+ Si se abre el cuadro de diálogo **Agregar permiso a la función de Lambda**, elija **Aceptar** para dar a la intención `OrderPizza` el permiso para llamar a la función de Lambda `PizzaOrderProcessor`.
+ Deje seleccionado **None**.
La intención debe ser similar a la siguiente:
![\[Editor de intenciones\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-70c.png)
## Paso siguiente
[Configuración del bot de](gs2-create-bot-configure-bot.md)
# Configuración del bot de
Configure la gestión de errores del bot `PizzaOrderingBot`.
1. Vaya al bot `PizzaOrderingBot`. Elija **Editor** y, a continuación, elija **Gestión de errores**, tal como se muestra en la siguiente imagen:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-80.png)
1. Utilice la pestaña **Editor** para configurar la gestión de errores del bot.
+ La información que facilita en **Clarification Prompts** se asigna a la configuración [clarificationPrompt](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-clarificationPrompt) del bot.
Si Amazon Lex no puede determinar la intención del usuario, el servicio devuelve una respuesta con este mensaje.
+ La información que facilita en la frase **Hang-up** se asigna a la configuración [abortStatement](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-abortStatement) del bot.
Si el servicio no puede determinar la intención del usuario después de un número determinado de solicitudes consecutivas, Amazon Lex devuelve una respuesta con este mensaje.
Deje los valores predeterminados.
## Paso siguiente
[Paso 3: compilación y prueba del bot](gs2-build-and-test.md)
# Paso 3: compilación y prueba del bot
Para asegurarse de que el bot funciona, compílelo y pruébelo.
**Para compilar y probar el bot**
1. Para compilar el bot `PizzaOrderingBot`, elija **Build**.
Amazon Lex crea un modelo de machine learning para el bot. Al probar el bot, la consola utiliza la API en tiempo de ejecución para enviar las entradas del usuario de nuevo a Amazon Lex. A continuación, Amazon Lex utiliza el modelo de machine learning para interpretar las entradas del usuario.
La compilación puede llevar tiempo.
1. Para probar el bot, en la ventana **Probar bot**, empiece a comunicarse con el bot de Amazon Lex.
+ Por ejemplo, puede decir o escribir lo siguiente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-110.png)
+ Utilice los enunciados de ejemplo que haya configurado en la intención `OrderPizza` para probar el bot. Por ejemplo, a continuación tenemos uno de los enunciados de ejemplo que ha configurado para la intención `PizzaOrder`:
```
I want a {size} {crust} crust {pizzaKind} pizza
```
Para probarlo, escriba lo siguiente:
```
I want a large thin crust cheese pizza
```
Al escribir “Quiero pedir una pizza”, Amazon Lex detecta la intención (`OrderPizza`). A continuación, Amazon Lex solicita información de la ranura.
Cuando haya proporcionado toda la información de la ranura, Amazon Lex invoca la función de Lambda que ha configurado para la intención.
La función de Lambda devuelve un mensaje (“Bien, he pedido…”) a Amazon Lex, que este le devuelve a usted.
## Inspección de la respuesta
Debajo de la ventana de chat hay un panel que le permite inspeccionar la respuesta de Amazon Lex. El panel ofrece información completa acerca del estado del bot, que cambia a medida que interactúa con el bot. El contenido del panel muestra el estado actual de la operación.
+ **Estado de diálogo**: el estado actual de la conversación con el usuario. Puede ser `ElicitIntent`, `ElicitSlot`, `ConfirmIntent` o `Fulfilled`.
+ **Resumen**: muestra una vista simplificada del cuadro de diálogo que indica los valores de ranura de la intención que se está realizando para que pueda realizar un seguimiento del flujo de información. Muestra el nombre de la intención, el número de slots y el número de slots rellenos, además de una lista de todos los slots y sus valores asociados. Vea la siguiente imagen:
![\[Panel de inspección del resumen de la respuesta en la consola de Amazon Lex.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-115.png)
+ **Detalle**: muestra la respuesta JSON sin procesar del bot de chat para que pueda comprender mejor la interacción con el bot y el estado actual del cuadro de diálogo mientras prueba y depura el bot de chat. Si escribe en la ventana de chat, el panel de inspección muestra la respuesta JSON de la operación [PostText](API_runtime_PostText.md). Si habla a la ventana de chat, el panel de inspección muestra los encabezados de la respuesta de la operación [PostContent](API_runtime_PostContent.md). Vea la siguiente imagen:
![\[Panel de inspección de la respuesta de la consola\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-116.png)
## Paso siguiente
[Paso 4 (opcional): Eliminación](gs2-clean-up.md)
# Paso 4 (opcional): Eliminación
Elimine los recursos que ha creado y limpie su cuenta para evitar incurrir en más cargos por los recursos que ha creado.
Puede eliminar únicamente los recursos que no se usan. Por ejemplo, no puede eliminar un tipo de slot al que haga referencia una intención. No puede eliminar una intención a la que haga referencia un bot.
Elimine los recursos en el orden que se indica a continuación:
+ Eliminar bots para liberar los recursos de las intenciones.
+ Eliminar intenciones para liberar los recursos de los tipos de slot.
+ Por último, eliminar el tipo de slot.
**Para limpiar la cuenta**
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. En la lista de bots, elija **PizzaOrderingBot**.
1. Para eliminar el bot, elija **Delete** y, a continuación, **Continue**.
1. En el panel izquierdo, elija **Intents**.
1. En la lista de intenciones, elija **OrderPizza**.
1. Para eliminar la intención, elija **Delete** y, a continuación, **Continue**.
1. En el menú de la izquierda, elija **Slot types**.
1. En la lista de tipos de slot, elija **Crusts**.
1. Para eliminar el tipo de slot, elija **Delete** y, a continuación, **Continue**.
1. Repita [Step 8](#chooseSlots) y [Step 9](#deleteSlots) para los tipos de slot `Sizes` y `PizzaKind`.
Ha eliminado todos los recursos que ha creado y ha limpiado su cuenta.
## Siguientes pasos
+ [Publique una versión y cree un alias](https://docs.aws.amazon.com/lex/latest/dg/gettingstarted-ex3.html)
+ [Cree un bot de Amazon Lex con AWS Command Line Interface](https://docs.aws.amazon.com/lex/latest/dg/gs-cli.html)
# Ejercicio 3: publicación de una versión y creación de un alias
En los ejercicios de introducción 1 y 2, creó un bot y lo probó. En este ejercicio, hará lo siguiente:
+ Publicar una nueva versión del bot. Amazon Lex realiza una copia instantánea de la versión `$LATEST` para publicar una nueva versión.
+ Cree un alias que apunte a la nueva versión.
Para obtener más información sobre el control de versiones y los alias, consulte [Control de versiones y alias](versioning-aliases.md).
Haga lo siguiente para publicar una versión de un bot que ha creado para este ejercicio:
1. En la consola de Amazon Lex, elija uno de los bots que ha creado.
Compruebe que la consola muestra `$LATEST` como la versión del bot junto al nombre del bot.
1. Elija **Publicar**.
1. En el *botname* asistente de **publicación**, especifique el alias y**BETA**, a continuación, elija **Publicar**.
1. Compruebe que la consola de Amazon Lex muestra la nueva versión del bot junto al nombre del bot, tal como se muestra en la siguiente imagen.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs2-final.png)
Ahora que tiene un bot de trabajo con la versión publicada y un alias, puede implementar el bot (en su aplicación móvil o integrar el bot en Facebook Messenger). Para ver un ejemplo, consulte [Integración de un bot de Amazon Lex con Facebook Messenger](fb-bot-association.md).
# Paso 4: Introducción (AWS CLI)
En este paso, se utiliza AWS CLI para crear, probar y modificar un bot de Amazon Lex. Para completar estos ejercicios, es necesario conocer el uso de la CLI y disponer de un editor de texto. Para obtener más información, consulte [Paso 2: configurar el AWS Command Line Interface](gs-set-up-cli.md)
+ Ejercicio 1: crear y probar un bot de Amazon Lex El ejercicio proporciona todos los objetos JSON necesarios para crear un slot personalizado, una intención y un bot. Para obtener más información, consulte [Funcionamiento de Amazon Lex](how-it-works.md)
+ Ejercicio 2: actualizar el bot creado en el ejercicio 1 para agregar un ejemplo de enunciado adicional. Amazon Lex utiliza ejemplos de enunciados para crear el modelo de machine learning del bot.
+ Ejercicio 3: actualizar el bot que ha creado en el ejercicio 1 para agregar una función de Lambda que valide las entradas del usuario y cumpla con la intención.
+ Ejercicio 4: publicar una versión del tipo de ranura, la intención y los recursos de bot creados en el ejercicio 1. Una versión es una snapshot de un recurso que no se puede cambiar.
+ Ejercicio 5: crear un alias para el bot creado en el ejercicio 1.
+ Ejercicio 6: eliminar el tipo de ranura, la intención y el bot creados en el ejercicio 1 y el alias creado en el ejercicio 5 para limpiar la cuenta.
**Topics**
+ [
# Ejercicio 1: creación de un bot de Amazon Lex (AWS CLI)
](gs-cli-create.md)
+ [
# Ejercicio 2: Añadir un nuevo enunciado (AWS CLI)
](gs-cli-update-utterance.md)
+ [
# Ejercicio 3: adición de una función de Lambda (AWS CLI)
](gs-cli-update-lambda.md)
+ [
# Ejercicio 4: Publicar una versión (AWS CLI)
](gs-cli-publish.md)
+ [
# Ejercicio 5: Crear un alias (AWS CLI)
](gs-cli-create-alias.md)
+ [
# Ejercicio 6: Limpieza (AWS CLI)
](gs-cli-clean-up.md)
# Ejercicio 1: creación de un bot de Amazon Lex (AWS CLI)
En general, cuando se crean bots, hay que:
1. Crear tipos de slots para definir la información con la que trabajará el bot.
1. Crear las intenciones que definen las acciones del usuario que admite el bot. Utilice los tipos de slots personalizadas que ha creado anteriormente para definir los slots, o parámetros, que requiere la intención.
1. Crear un bot que utilice las intenciones que ha definido.
En este ejercicio, creará y probará un nuevo bot de Amazon Lex con la CLI. Utilice las estructuras JSON que proporcionamos para ello. Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Topics**
+ [
# Paso 1: Crear un rol vinculado a servicio (AWS CLI)
](gs-create-role.md)
+ [
# Paso 2: Crear un tipo de slot personalizado (AWS CLI)
](gs-create-flower-types.md)
+ [
# Paso 3: Crear una intención (AWS CLI)
](gs-cli-create-order-flowers.md)
+ [
# Paso 4: Crear un bot (AWS CLI)
](gs-cli-create-order-flowers-bot.md)
+ [
# Paso 5: Probar un bot (AWS CLI)
](gs-create-test.md)
# Paso 1: Crear un rol vinculado a servicio (AWS CLI)
Amazon Lex asume funciones AWS Identity and Access Management vinculadas a servicios para llamar a AWS los servicios en nombre de sus bots. Los roles, que están en su cuenta, están vinculados a casos de uso de Amazon Lex y tienen permisos predefinidos. Para obtener más información, consulte [Uso de roles vinculados a servicios para Amazon Lex](using-service-linked-roles.md).
Si ya ha creado un bot de Amazon Lex con la consola, el rol vinculado al servicio se habrá creado automáticamente. Vaya a [Paso 2: Crear un tipo de slot personalizado (AWS CLI)](gs-create-flower-types.md).
**Para crear un rol vinculado a un servicio (AWS CLI)**
1. En el AWS CLI, escriba el siguiente comando:
```
aws iam create-service-linked-role --aws-service-name lex.amazonaws.com
```
1. Compruebe la política usando el comando siguiente:
```
aws iam get-role --role-name AWSServiceRoleForLexBots
```
La respuesta es:
## Paso siguiente
[Paso 2: Crear un tipo de slot personalizado (AWS CLI)](gs-create-flower-types.md)
# Paso 2: Crear un tipo de slot personalizado (AWS CLI)
Cree un tipo de slot personalizado con valores de enumeración para las flores que puedan encargarse. Puede utilizar este tipo en el siguiente paso cuando cree la intención `OrderFlowers`. Un *tipo de slot* define los valores posibles para un slot, o parámetro, de la intención.
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Para crear un tipo de slot personalizado (AWS CLI)**
1. Cree un archivo de texto denominado **FlowerTypes.json**. Copie el código JSON de [FlowerTypes.json](gs-cli-create-flower-types-json.md) en el archivo de texto.
1. Llame a la [PutSlotType](API_PutSlotType.md) operación mediante el AWS CLI para crear el tipo de ranura. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws lex-models put-slot-type \
--region region \
--name FlowerTypes \
--cli-input-json file://FlowerTypes.json
```
La respuesta del servidor es:
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"checksum": "checksum",
"version": "$LATEST",
"lastUpdatedDate": timestamp,
"createdDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Paso siguiente
[Paso 3: Crear una intención (AWS CLI)](gs-cli-create-order-flowers.md)
# FlowerTypes.json
El siguiente código contiene los datos JSON necesarios para crear el tipo de slot personalizado `FlowerTypes`:
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"description": "Types of flowers to pick up"
}
```
# Paso 3: Crear una intención (AWS CLI)
Cree una intención para el bot `OrderFlowersBot` y proporcione tres slots o parámetros. Los slots permiten que el bot satisfaga la intención:
+ `FlowerType` es un tipo de slot personalizado que especifica los tipos de flores que pueden encargarse.
+ `AMAZON.DATE` y `AMAZON.TIME` son tipos de slots integrados que se emplean para obtener del usuario la fecha y la hora de entrega de las flores.
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Para crear la intención `OrderFlowers` (AWS CLI)**
1. Cree un archivo de texto denominado **OrderFlowers.json**. Copie el código JSON de [OrderFlowers.json](gs-cli-create-order-flowers-json.md) en el archivo de texto.
1. En AWS CLI, llama a la [PutIntent](API_PutIntent.md) operación para crear la intención. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers.json
```
El servidor responde con lo siguiente:
## Paso siguiente
[Paso 4: Crear un bot (AWS CLI)](gs-cli-create-order-flowers-bot.md)
# OrderFlowers.json
El siguiente código contiene los datos JSON necesarios para crear la intención `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"
}
```
# Paso 4: Crear un bot (AWS CLI)
El bot `OrderFlowersBot` tiene una intención, la intención `OrderFlowers` que ha creado en el paso anterior. Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST`.
**Para crear el bot `OrderFlowersBot` (AWS CLI)**
1. Cree un archivo de texto denominado **OrderFlowersBot.json**. Copie el código JSON de [OrderFlowersBot.json](gs-cli-create-order-flowers-bot-json.md) en el archivo de texto.
1. En el AWS CLI, llama a la [PutBot](API_PutBot.md) operación para crear el bot. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot.json
```
La respuesta del servidor sigue a continuación. Cuando crea o actualiza el bot, el campo `status` se establece en `BUILDING`. Esto indica que el bot no está listo para su uso. Para determinar si el bot está listo, utilice la operación [GetBot](API_GetBot.md) en el siguiente paso.
1. Para determinar si el nuevo bot está listo para su uso, ejecute este comando. Repita este comando hasta que el campo `status` devuelva `READY`. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST"
```
Busque el campo `status` en la respuesta:
```
{
"status": "READY",
...
}
```
## Paso siguiente
[Paso 5: Probar un bot (AWS CLI)](gs-create-test.md)
# OrderFlowersBot.json
El siguiente código JSON proporciona los datos necesarios para crear el bot de 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"
}
```
# Paso 5: Probar un bot (AWS CLI)
Para probar el bot, utilice una prueba basada en texto o en voz.
**Topics**
+ [
# Probar el bot con entrada de texto (AWS CLI)
](gs-create-test-text.md)
+ [
# Probar el bot con entrada de voz (AWS CLI)
](gs-create-test-speech.md)
# Probar el bot con entrada de texto (AWS CLI)
Para verificar que el bot funciona correctamente con entradas de texto, utilice la operación [PostText](API_runtime_PostText.md). Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de servicio en tiempo de ejecución](gl-limits.md#gl-limits-runtime).
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para probar el bot con texto (AWS CLI)**
1. En el AWS CLI, inicia una conversación con el `OrderFlowersBot` bot. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws lex-runtime post-text \
--region region \
--bot-name OrderFlowersBot \
--bot-alias "\$LATEST" \
--user-id UserOne \
--input-text "i would like to order flowers"
```
Amazon Lex reconoce la intención del usuario y comienza una conversación al devolver la siguiente respuesta:
```
{
"slotToElicit": "FlowerType",
"slots": {
"PickupDate": null,
"PickupTime": null,
"FlowerType": null
},
"dialogState": "ElicitSlot",
"message": "What type of flowers would you like to order?",
"intentName": "OrderFlowers"
}
```
1. Ejecute los comandos siguientes para finalizar la conversación con el 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"
```
Después de confirmar el pedido, Amazon Lex envía una respuesta de cumplimiento para completar la conversación:
```
{
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
},
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers"
}
```
## Paso siguiente
[Probar el bot con entrada de voz (AWS CLI)](gs-create-test-speech.md)
# Probar el bot con entrada de voz (AWS CLI)
Para probar el bot utilizando archivos de audio, use la operación [PostContent](API_runtime_PostContent.md). Los archivos de audio se generan mediante las operaciones de Amazon Polly. text-to-speech
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos de Amazon Lex y Amazon Polly. Para ver la lista de regiones de Amazon Lex, consulte [Cuotas de servicio en tiempo de ejecución](gl-limits.md#gl-limits-runtime). Para ver la lista de regiones de Amazon Polly, consulte [AWS Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region) en la *referencia general de Amazon Web Services*.
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para utilizar una entrada de voz para probar el bot (AWS CLI)**
1. En el AWS CLI, crea un archivo de audio con Amazon Polly. El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "i would like to order flowers" \
--voice-id "Salli" \
IntentSpeech.mpg
```
1. Para enviar el archivo de audio a Amazon Lex, ejecute el siguiente comando. Amazon Lex guarda el audio de la respuesta en el archivo de salida 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
```
Amazon Lex responde con una solicitud para la primera ranura. Guarda la respuesta de audio en el archivo de salida 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 realizar un pedido de rosas, cree el siguiente archivo de audio y envíelo a 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 establecer la fecha de la entrega, cree el siguiente archivo de audio y envíelo a 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 establecer la hora de la entrega, cree el siguiente archivo de audio y envíelo a 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 la entrega, cree el siguiente archivo de audio y envíelo a 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
```
Después de confirmar la entrega, Amazon Lex envía una respuesta que confirma el cumplimiento de la intención:
```
{
"contentType": "text/plain;charset=utf-8",
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers",
"inputTranscript": "yes",
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
}
}
```
## Paso siguiente
[Ejercicio 2: Añadir un nuevo enunciado (AWS CLI)](gs-cli-update-utterance.md)
# Ejercicio 2: Añadir un nuevo enunciado (AWS CLI)
Con el fin de mejorar el modelo de machine learning que Amazon Lex utiliza para reconocer las solicitudes de los usuarios, agregue otro enunciado de muestra al bot.
El proceso de añadir un nuevo enunciado consta de cuatro pasos.
1. Utilice la operación [GetIntent](API_GetIntent.md) para obtener una intención de Amazon Lex.
1. Actualice la intención.
1. Use la operación [PutIntent](API_PutIntent.md) para enviar la intención actualizada de vuelta a Amazon Lex.
1. Use las operaciones [GetBot](API_GetBot.md) y [PutBot](API_PutBot.md) para volver a compilar los bots que usen la intención.
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
La respuesta de la operación `GetIntent` contiene un campo llamado `checksum` que identifica una revisión específica de la intención. Debe proporcionar el valor de la suma de comprobación cuando utilice la operación [PutIntent](API_PutIntent.md) para actualizar una intención. Si no, recibirá el siguiente mensaje de error:
```
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**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para actualizar la intención `OrderFlowers` (AWS CLI)**
1. En el AWS CLI, obtenga la intención de Amazon Lex. Amazon Lex envía el resultado a un archivo llamado **OrderFlowers-V2.json.**
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V2.json
```
1. Abra **OrderFlowers-V2.json** en un editor de texto.
1. Busque y elimine los campos `createdDate`, `lastUpdatedDate` y `version`.
1. Añada la línea siguiente al campo `sampleUtterances`:
```
I want to order flowers
```
1. Guarde el archivo.
1. Envíe la intención actualizada a Amazon Lex con el siguiente comando:
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V2.json
```
Amazon Lex envía la siguiente respuesta:
Ahora que ha actualizado la intención, recompile los bots que la usen.
**Para recompilar el bot `OrderFlowersBot` (AWS CLI)**
1. En el AWS CLI, obtén la definición del `OrderFlowersBot` bot y guárdala en un archivo con el siguiente comando:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V2.json
```
1. En un editor de texto, abra **OrderFlowersBot-V2.json**. Elimine los campos `createdDate`, `lastUpdatedDate`, `status` y `version`.
1. En un editor de texto, añada la siguiente línea a la definición de bot:
```
"processBehavior": "BUILD",
```
1. En el AWS CLI, crea una nueva revisión del bot ejecutando el siguiente comando para:
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V2.json
```
La respuesta del servidor es:
## Paso siguiente
[Ejercicio 3: adición de una función de Lambda (AWS CLI)](gs-cli-update-lambda.md)
# Ejercicio 3: adición de una función de Lambda (AWS CLI)
Agregue al bot una función de Lambda que valide las entradas del usuario y cumpla la intención del usuario.
El proceso de agregar una expresión de Lambda consta de cinco pasos.
1. [Utilice la [AddPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html)función Lambda para activar la `OrderFlowers` intención de llamar a la operación Lambda Invoke.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html)
1. Utilice la operación [GetIntent](API_GetIntent.md) para obtener la intención de Amazon Lex.
1. Actualice la intención para agregar la función de Lambda.
1. Use la operación [PutIntent](API_PutIntent.md) para enviar la intención actualizada de vuelta a Amazon Lex.
1. Use las operaciones [GetBot](API_GetBot.md) y [PutBot](API_PutBot.md) para volver a compilar los bots que usen la intención.
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
Si agrega una función de Lambda a una intención antes de agregar el permiso `InvokeFunction`, obtendrá el siguiente mensaje de error:
```
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.
```
La respuesta de la operación `GetIntent` contiene un campo llamado `checksum` que identifica una revisión específica de la intención. Cuando se usa la operación [PutIntent](API_PutIntent.md) para actualizar una intención, debe proporcionar el valor de la suma de comprobación. Si no, recibirá el siguiente mensaje de error:
```
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.
```
En este ejercicio se utiliza la función de Lambda desde [Ejercicio 1: creación de un bot de Amazon Lex mediante un esquema (consola)](gs-bp.md). Para obtener instrucciones para crear la función de Lambda, consulte [Paso 3: creación de una función de Lambda (consola)](gs-bp-create-lambda-function.md).
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST`.
**Adición de una función de Lambda a una intención**
1. En el AWS CLI, agrega el `InvokeFunction` permiso para la `OrderFlowers` intención:
```
aws lambda add-permission \
--region region \
--function-name OrderFlowersCodeHook \
--statement-id LexGettingStarted-OrderFlowersBot \
--action lambda:InvokeFunction \
--principal lex.amazonaws.com \
--source-arn "arn:aws:lex:region:account ID:intent:OrderFlowers:*"
--source-account account ID
```
Lambda envía la siguiente respuesta:
```
{
"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. Obtenga la intención de Amazon Lex. Amazon Lex envía el resultado a un archivo llamado **OrderFlowers-V3.json**.
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V3.json
```
1. Abra **OrderFlowers-V3.json** en un editor de texto.
1. Busque y elimine los campos `createdDate`, `lastUpdatedDate` y `version`.
1. Actualice el campo `fulfillmentActivity`:
```
"fulfillmentActivity": {
"type": "CodeHook",
"codeHook": {
"uri": "arn:aws:lambda:region:account ID:function:OrderFlowersCodeHook",
"messageVersion": "1.0"
}
}
```
1. Guarde el archivo.
1. En el AWS CLI, envíe la intención actualizada a Amazon Lex:
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V3.json
```
Ahora que ha actualizado la intención, recompile el bot.
**Para recompilar el bot `OrderFlowersBot`**
1. En el AWS CLI, obtén la definición del `OrderFlowersBot` bot y guárdala en un archivo:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V3.json
```
1. En un editor de texto, abra **OrderFlowersBot-V3.json**. Elimine los campos `createdDate`, `lastUpdatedDate`, `status` y `version`.
1. En el editor de texto, añada la siguiente línea a la definición del bot:
```
"processBehavior": "BUILD",
```
1. En el AWS CLI, crea una nueva revisión del bot:
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V3.json
```
La respuesta del servidor es:
## Paso siguiente
[Ejercicio 4: Publicar una versión (AWS CLI)](gs-cli-publish.md)
# Ejercicio 4: Publicar una versión (AWS CLI)
Ahora, cree una versión del bot que ha creado en el ejercicio 1. Una *versión* es una snapshot del bot. No se puede cambiar una versión después de crearla. La única versión de un bot que puede actualizar es la versión `$LATEST`. Para obtener más información acerca de las versiones, consulte [Control de versiones y alias](versioning-aliases.md).
Para poder publicar una versión de un bot, debe publicar las intenciones que este utilice. Del mismo modo, debe publicar los tipos de slot a los que hacen referencias las intenciones. En general, para publicar una versión de un bot, haga lo siguiente:
1. Publique una versión de un tipo de slot con la operación [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md).
1. Publique una versión de una intención con la operación [CreateIntentVersion](API_CreateIntentVersion.md).
1. Publique una versión de un bot con la operación [CreateBotVersion](API_CreateBotVersion.md).
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Topics**
+ [
# Paso 1: Publicar el tipo de slot (AWS CLI)
](gs-cli-publish-slot-type.md)
+ [
# Paso 2: Publicar la intención (AWS CLI)
](gs-cli-publish-intent.md)
+ [
# Paso 3: Publicar el bot (AWS CLI)
](gs-cli-publish-bot.md)
# Paso 1: Publicar el tipo de slot (AWS CLI)
Antes de publicar una versión de alguna intención que use un tipo de slot, debe publicar una versión de ese tipo de slot. En este caso, publique el tipo de slot `FlowerTypes`.
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para publicar un tipo de slot (AWS CLI)**
1. En el AWS CLI, obtén la última versión del tipo de ranura:
```
aws lex-models get-slot-type \
--region region \
--name FlowerTypes \
--slot-type-version "\$LATEST"
```
La respuesta de Amazon Lex es la siguiente. Registre la suma de comprobación para la revisión actual de la versión `$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 una nueva versión del tipo de slot. Use la suma de comprobación que ha registrado en el paso anterior.
```
aws lex-models create-slot-type-version \
--region region \
--name FlowerTypes \
--checksum "checksum"
```
La respuesta de Amazon Lex es la siguiente. Registre el número de versión para el paso siguiente.
```
{
"version": "1",
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"createdDate": timestamp,
"lastUpdatedDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Paso siguiente
[Paso 2: Publicar la intención (AWS CLI)](gs-cli-publish-intent.md)
# Paso 2: Publicar la intención (AWS CLI)
Antes de publicar una intención, tiene que publicar todos los tipos de slot a los que esta haga referencia. Los tipos de slot deben ser versiones numeradas, no la versión `$LATEST`.
En primer lugar, actualice la intención `OrderFlowers` para que utilice la versión del tipo de slot `FlowerTypes` que ha publicado en el paso anterior. Después publique una nueva versión de la intención `OrderFlowers`.
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para publicar una versión de una intención (AWS CLI)**
1. En el AWS CLI, obtén la `$LATEST` versión de la `OrderFlowers` intención y guárdala en un archivo:
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4.json
```
1. Abra el archivo **OrderFlowers\$1V4.json** en un editor de texto. Elimine los campos `createdDate`, `lastUpdatedDate` y `version`. Busque el tipo de slot `FlowerTypes` y cambie la versión por el número de versión que ha registrado en el paso anterior. El siguiente fragmento del archivo **OrderFlowers\$1V4.json** muestra la ubicación del cambio:
```
{
"slotType": "FlowerTypes",
"name": "FlowerType",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What type of flowers?",
"contentType": "PlainText"
}
]
},
"priority": 1,
"slotTypeVersion": "version",
"sampleUtterances": []
},
```
1. En el AWS CLI, guarda la revisión de la intención:
```
aws lex-models put-intent \
--name OrderFlowers \
--cli-input-json file://OrderFlowers_V4.json
```
1. Obtenga la suma de comprobación de la última revisión de la intención:
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4a.json
```
El siguiente fragmento de la respuesta muestra la suma de comprobación de la intención. Guárdelo para el siguiente paso.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "$LATEST",
```
1. Publicar una nueva versión de la intención:
```
aws lex-models create-intent-version \
--region region \
--name OrderFlowers \
--checksum "checksum"
```
El siguiente fragmento de la respuesta muestra la nueva versión de comprobación de la intención. Registre el número de versión para el paso siguiente.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "version",
```
## Paso siguiente
[Paso 3: Publicar el bot (AWS CLI)](gs-cli-publish-bot.md)
# Paso 3: Publicar el bot (AWS CLI)
Una vez que publicados todos los tipos de slot y las intenciones que se utilizan en el bot, puede publicar el bot.
Actualice el bot `OrderFlowersBot` para usar la intención `OrderFlowers` que ha actualizado en el paso anterior. Después, publique una nueva versión del bot `OrderFlowersBot`.
**nota**
El siguiente AWS CLI ejemplo está formateado para Unix, Linux y macOS. Para Windows, cambie `"\$LATEST"` por `$LATEST` y sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación al final de cada línea por el signo de intercalación (^).
**Para publicar una versión de un bot, (AWS CLI)**
1. En el AWS CLI, obtén la `$LATEST` versión del `OrderFlowersBot` bot y guárdala en un archivo:
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot_V4.json
```
1. Abra el archivo **OrderFlowersBot\$1V4.json** en un editor de texto. Elimine los campos `createdDate`, `lastUpdatedDate`, `status` y `version`. Busque la intención `OrderFlowers` y cambie la versión por el número de versión que ha registrado en el paso anterior. El siguiente fragmento de **OrderFlowersBot\$1V4.json** muestra la ubicación del cambio.
```
"intents": [
{
"intentVersion": "version",
"intentName": "OrderFlowers"
}
```
1. En el AWS CLI, guarda la nueva revisión del bot. Anote el número de versión que devuelve la llamada a `put-bot`.
```
aws lex-models put-bot \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot_V4.json
```
1. Consiga la suma de comprobación de la última revisión del bot. Utilice el número de versión devuelto en el paso 3.
```
aws lex-models get-bot \
--region region \
--version-or-alias version \
--name OrderFlowersBot > OrderFlowersBot_V4a.json
```
El siguiente fragmento de la respuesta muestra la suma de comprobación del bot. Guárdelo para el siguiente paso.
```
"name": "OrderFlowersBot",
"locale": "en-US",
"checksum": "checksum",
```
1. Publicar una nueva versión del bot:
```
aws lex-models create-bot-version \
--region region \
--name OrderFlowersBot \
--checksum "checksum"
```
El siguiente fragmento de la respuesta muestra la nueva versión de comprobación del bot.
```
"checksum": "checksum",
"abortStatement": {
...
},
"version": "1",
"lastUpdatedDate": timestamp,
```
## Paso siguiente
[Ejercicio 5: Crear un alias (AWS CLI)](gs-cli-create-alias.md)
# Ejercicio 5: Crear un alias (AWS CLI)
Un alias es un puntero hacia una versión específica de un bot. Con un alias, puede actualizar fácilmente la versión que usan las aplicaciones cliente. Para obtener más información, consulte [Control de versiones y alias](versioning-aliases.md). Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Para crear un alias (AWS CLI)**
1. En el AWS CLI, obtén la versión del `OrderFlowersBot` bot en la que creaste[Ejercicio 4: Publicar una versión (AWS CLI)](gs-cli-publish.md).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias version > OrderFlowersBot_V5.json
```
1. En un editor de texto, abra **OrderFlowersBot\$1v5.json**. Busque y registre el número de versión.
1. En el AWS CLI, crea el alias del bot:
```
aws lex-models put-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot \
--bot-version version
```
A continuación se muestra la respuesta del servidor:
```
{
"name": "PROD",
"createdDate": timestamp,
"checksum": "checksum",
"lastUpdatedDate": timestamp,
"botName": "OrderFlowersBot",
"botVersion": "1"
}}
```
## Paso siguiente
[Ejercicio 6: Limpieza (AWS CLI)](gs-cli-clean-up.md)
# Ejercicio 6: Limpieza (AWS CLI)
Elimine los recursos que ha creado y limpie la cuenta.
Puede eliminar únicamente los recursos que no se usan. En general, debería eliminar los recursos en el orden que se indica a continuación.
1. Elimine los alias para liberar los recursos de los bots.
1. Eliminar bots para liberar los recursos de las intenciones.
1. Eliminar intenciones para liberar los recursos de los tipos de slot.
1. Elimine el tipo de slot.
Para ejecutar los comandos de este ejercicio, debe conocer la región donde se ejecutarán los comandos. Para obtener una lista de regiones, consulte [Cuotas de creación de modelos](gl-limits.md#gl-limits-model-building).
**Para limpiar la cuenta (AWS CLI)**
1. En la línea de AWS CLI comandos, elimina el alias:
```
aws lex-models delete-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot
```
1. En la línea de AWS CLI comandos, elimina el bot:
```
aws lex-models delete-bot \
--region region \
--name OrderFlowersBot
```
1. En la línea de AWS CLI comandos, elimina la intención:
```
aws lex-models delete-intent \
--region region \
--name OrderFlowers
```
1. En la línea de AWS CLI comandos, elimine el tipo de ranura:
```
aws lex-models delete-slot-type \
--region region \
--name FlowerTypes
```
Ha eliminado todos los recursos que ha creado y ha limpiado su cuenta.