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