Avis de fin de support : le 15 septembre 2025, le support pour Amazon Lex V1 AWS sera interrompu. Après le 15 septembre 2025, vous ne pourrez plus accéder à la console Amazon Lex V1 ni aux ressources Amazon Lex V1. Si vous utilisez Amazon Lex V2, consultez plutôt le [guide Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser Amazon Lex
Amazon Lex fournit des opérations d'API que vous pouvez intégrer à vos applications existantes. Pour une liste des opérations prises en charge, consultez [Référence d’API](API_Reference.md). Vous pouvez utiliser les options suivantes :
+ AWS SDK — Lorsque vous utilisez le, SDKs vos demandes adressées à Amazon Lex sont automatiquement signées et authentifiées à l'aide des informations d'identification que vous fournissez. Ce choix est recommandé dans le cadre du développement de vos applications.
+ AWS CLI — Vous pouvez utiliser le AWS CLI pour accéder à n'importe quelle fonctionnalité d'Amazon Lex sans avoir à écrire de code.
+ Console AWS — La console est le moyen le plus simple de commencer à tester et à utiliser Amazon Lex
Si vous utilisez Amazon Lex pour la première fois, nous vous recommandons de lire[Amazon Lex : comment ça marche](how-it-works.md). d'abord.
**Topics**
+ [
# Étape 1 : configurer un AWS compte et créer un utilisateur administrateur
](gs-account.md)
+ [
# Étape 2 : configurer le AWS Command Line Interface
](gs-set-up-cli.md)
+ [
# Etape 3 : Démarrage (console)
](gs-console.md)
+ [
# Étape 4 : Démarrer (AWS CLI)
](gs-cli.md)
# Étape 1 : configurer un AWS compte et créer un utilisateur administrateur
Avant d'utiliser Amazon Lex pour la première fois, effectuez les tâches suivantes :
1. [Inscrivez-vous pour AWS](#gs-account-create)
1. [Créez un utilisateur](#gs-account-user)
## Inscrivez-vous pour AWS
Si vous avez déjà un AWS compte, ignorez cette tâche.
Lorsque vous vous inscrivez à Amazon Web Services (AWS), votre AWS compte est automatiquement inscrit à tous les services AWS, y compris Amazon Lex. Seuls les services que vous utilisez vous sont facturés.
Avec Amazon Lex, vous ne payez que pour les ressources que vous utilisez. Si vous êtes un nouveau AWS client, vous pouvez commencer à utiliser Amazon Lex gratuitement. Pour plus d'informations, consultez la page [Niveau d'offre gratuite d'AWS](https://aws.amazon.com/free/).
Si vous avez déjà un AWS compte, passez à la tâche suivante. Si vous n'avez pas de compte AWS , observez la procédure suivante pour en créer un.
**Pour créer un AWS compte**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
Notez votre identifiant de AWS compte, car vous en aurez besoin pour la prochaine tâche.
## Créez un utilisateur
Les services tels qu'Amazon Lex nécessitent que vous fournissiez des informations d'identification lorsque vous y accédez afin que le service puisse déterminer si vous êtes autorisé à accéder aux ressources détenues par ce service. AWS La console exige votre mot de passe. Toutefois, nous vous déconseillons d'accéder à AWS l'aide des informations d'identification de votre AWS compte. A la place, nous vous recommandons de procéder comme suit :
+ Utiliser Gestion des identités et des accès AWS (IAM) pour créer un utilisateur
+ Ajouter l'utilisateur à un groupe IAM doté d'autorisations administratives
+ Accordez des autorisations administratives à l'utilisateur que vous avez créé.
Vous pouvez ensuite y accéder à AWS l'aide d'une URL spéciale et des informations d'identification de l'utilisateur.
Les exercices de mise en route de ce guide présument que l'utilisateur (`adminuser`) dispose de privilèges d'administrateur. Suivez la procédure pour créer `adminuser` dans votre compte.
**Pour créer un administrateur et vous connecter à la console**
1. Créez un administrateur appelé `adminuser` dans votre compte AWS . Pour obtenir des instructions, consultez [la section Création de votre premier groupe d'utilisateurs et d'administrateurs](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) dans le *guide de l'utilisateur IAM*.
1. En tant qu'utilisateur, vous pouvez vous connecter à l' AWS Management Console aide d'une URL spéciale. Pour plus d’informations, consultez [Comment les utilisateurs se connectent à votre compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_how-users-sign-in.html) dans le *Guide de l’utilisateur IAM*.
Pour plus d’informations sur IAM, consultez les ressources suivantes :
+ [Gestion des identités et des accès AWS (JE SUIS)](https://aws.amazon.com/iam/)
+ [Commencer à utiliser IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html)
+ [Guide de l’utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
## Étape suivante
[Étape 2 : configurer le AWS Command Line Interface](gs-set-up-cli.md)
# Étape 2 : configurer le AWS Command Line Interface
Si vous préférez utiliser Amazon Lex avec le AWS Command Line Interface (AWS CLI), téléchargez-le et configurez-le.
**Important**
Vous n'en avez pas besoin AWS CLI pour effectuer les étapes des exercices de mise en route. Cependant, quelques-uns des exercices ultérieurs de ce guide utilisent l' AWS CLI. Si vous préférez commencer à l'aide de la console, vous pouvez ignorer cette étape et passer à [Etape 3 : Démarrage (console)](gs-console.md). Plus tard, lorsque vous en aurez besoin AWS CLI, revenez ici pour le configurer.
**Pour configurer le AWS CLI**
1. Téléchargez et configurez l’interface AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantes dans le *Guide de l'utilisateur de l'AWS Command Line Interface *:
+ [Mise en place avec le AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
+ [Configuration de l’interface AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) (français non garanti)
1. Ajoutez un profil nommé pour l'utilisateur administrateur à la fin du fichier de AWS CLI configuration. Vous utilisez ce profil lors de l'exécution de AWS CLI commandes. Pour plus d'informations sur les profils nommés, consultez la rubrique [Profils nommés](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) dans le *Guide de l'utilisateur 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
```
Pour obtenir la liste des AWS régions disponibles, consultez la section [Régions et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html) dans le *Référence générale d'Amazon Web Services*.
1. Vérifiez la configuration en saisissant la commande d'aide à l'invite de commande :
```
aws help
```
##
[Etape 3 : Démarrage (console)](gs-console.md)
# Etape 3 : Démarrage (console)
Le moyen le plus simple d'apprendre à utiliser Amazon Lex est d'utiliser la console. Pour vous aider à faire vos premiers pas, nous avons créé les exercices suivants, qui utilisent tous la console :
+ Exercice 1 — Créez un bot Amazon Lex à l'aide d'un plan, un bot prédéfini qui fournit toutes les configurations de bot nécessaires. Vous n'effectuez qu'un minimum de travail pour tester la end-to-end configuration.
En outre, vous utilisez le modèle de fonction Lambda, fourni par AWS Lambda, pour créer une fonction Lambda. Cette fonction est un hook de code qui utilise un code prédéfini compatible avec le bot.
+ Exercice 2 — Créez un bot personnalisé en le créant et en le configurant manuellement. Vous créez également une fonction Lambda sous forme de crochet de code. Un exemple de code est fourni.
+ Exercice 3 — Publiez un bot, puis créez-en une nouvelle version. Dans le cadre de cet exercice, vous allez créer un alias pointant vers la version du bot.
**Topics**
+ [
# Exercice 1 : créer un robot Amazon Lex à l'aide d'un plan (console)
](gs-bp.md)
+ [
# Exercice 2 : créer un robot Amazon Lex personnalisé
](getting-started-ex2.md)
+ [
# Exercice 3 : Publication d'une version et création d'un alias
](gettingstarted-ex3.md)
# Exercice 1 : créer un robot Amazon Lex à l'aide d'un plan (console)
Dans cet exercice, vous effectuez les opérations suivantes :
+ Créez votre premier bot Amazon Lex et testez-le dans la console Amazon Lex.
Pour cet exercice, vous allez utiliser le **OrderFlowers**plan. Pour obtenir des informations sur les modèles de présentation, consultez [Amazon Lex et AWS Lambda Blueprints](lex-lambda-blueprints.md).
+ Créez une AWS Lambda fonction et testez-la dans la console Lambda. Lors du traitement d'une demande, votre bot appelle cette fonction Lambda. Pour cet exercice, vous allez utiliser un plan Lambda (**lex-order-flowers-python**) fourni dans la AWS Lambda console pour créer votre fonction Lambda. Le code du plan montre comment vous pouvez utiliser la même fonction Lambda pour effectuer l'initialisation et la validation, et pour répondre à l'objectif. `OrderFlowers`
+ Mettez à jour le bot pour ajouter la fonction Lambda comme crochet de code afin de répondre à l'intention. Testez l' end-to-endexpérience.
Les sections suivantes expliquent les modèles.
## Amazon Lex Bot : présentation du plan
Vous utilisez le **OrderFlowers**plan pour créer un robot Amazon Lex. Pour plus d'informations sur la structure d'un bot, consultez. [Amazon Lex : comment ça marche](how-it-works.md) Le bot est préconfiguré comme suit :
+ **Intention** — OrderFlowers
+ **Types d'option** – un type d'option personnalisé appelé `FlowerTypes` avec des valeurs d'énumération : `roses`, `lilies` et `tulips`.
+ **Options** – L'intention nécessite les informations suivantes (c'est à dire des options) pour que le bot puisse traiter l'intention.
+ `PickupTime` (type prédéfini AMAZON.TIME)
+ `FlowerType`(type FlowerTypes personnalisé)
+ `PickupDate` (type prédéfini AMAZON.DATE)
+ **Enoncé** – Les exemples d'énoncés suivants indiquent l'intention de l'utilisateur :
+ « I would like to pick up flowers. »
+ « "I would like to order some flowers. »
+ **Invites** – une fois que le bot a identifié l'intention, il utilise les invites suivantes pour indiquer les options :
+ Invite de l'option `FlowerType` – « Quel type de fleurs souhaitez-vous commander ? »
+ Demande de `PickupDate` créneau — « Quel jour voulez-vous que le \$1FlowerType\$1 soit retiré ? »
+ Demander le `PickupTime` créneau — « À quelle heure voulez-vous que le \$1FlowerType\$1 soit retiré ? »
+ Déclaration de confirmation — « OK, votre \$1FlowerType\$1 sera prêt à être retiré le \$1PickupTime\$1 le \$1PickupDate\$1. Cela vous convient-il ? »
## AWS Lambda Fonction : Résumé du plan
Dans cet exercice, la fonction Lambda exécute à la fois des tâches d'initialisation, de validation et d'exécution. Par conséquent, après avoir créé la fonction Lambda, vous mettez à jour la configuration d'intention en spécifiant la même fonction Lambda en tant que crochet de code pour gérer à la fois les tâches d'initialisation, de validation et d'exécution.
+ En tant que crochet de code d'initialisation et de validation, la fonction Lambda effectue une validation de base. Par exemple, si l'utilisateur indique une heure de retrait en dehors des heures normales de bureau, la fonction Lambda demande à Amazon Lex de lui demander à nouveau l'heure.
+ Dans le cadre du crochet du code d'expédition, la fonction Lambda renvoie un message récapitulatif indiquant que la commande de fleurs a été passée (c'est-à-dire que l'intention a été remplie).
**Étape suivante**
[Étape 1 : créer un robot Amazon Lex (console)](gs-bp-create-bot.md)
# Étape 1 : créer un robot Amazon Lex (console)
Pour cet exercice, créez un bot pour commander des fleurs, appelé OrderFlowersBot.
Pour créer un bot Amazon Lex (console)
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. S'il s'agit de votre premier bot, choisissez **Get Started (Mise en route)**. Sinon, sur la page **Bots**, choisissez **Create (Créer)**.
1. Sur la page **Create your Lex bot**, saisissez les informations suivantes et choisissez **Créer**.
+ Choisissez le modèle **OrderFlowers**.
+ Laissez le nom du bot par défaut (OrderFlowers).
+ Pour **COPPA**, choisissez **No**.
+ Pour le **stockage des énoncés de l'utilisateur**, choisissez la réponse appropriée.
1. Choisissez **Créer**. La console envoie les demandes nécessaires à Amazon Lex pour enregistrer la configuration. La console affiche ensuite la fenêtre d'édition du bot.
1. Attendez la confirmation que le bot a été créé.
1. Testez le bot.
**Note**
Pour ce faire, tapez un texte dans la fenêtre de test ou, pour les navigateurs compatibles, en sélectionnant le micro dans la même fenêtre et en parlant.
Utilisez l'exemple de texte suivant pour engager une conversation avec le bot afin de commander des fleurs :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/OrderFlowers-NoLambda.png)
A partir de ces informations, le bot déduit l'intention `OrderFlowers` et vous invite à entrer des données d'option. Lorsque vous fournissez toutes les données d'option requises, le bot traite l'intention (`OrderFlowers`) en renvoyant toutes les informations à l'application cliente (dans ce cas, la console). La console affiche les informations dans la fenêtre de test.
En particulier :
+ Dans la déclaration « What day do you want the roses to be picked up? « , le terme « roses » s'affiche, car le message correspondant à l'option `pickupDate` est configuré à l'aide des substitutions, `{FlowerType}`. Vous pouvez vérifier cela dans la console.
+ La déclaration « Okay, your roses will be ready... » est celle que vous avez configurée comme invite de confirmation.
+ La dernière déclaration (« `FlowerType:roses...` ») correspond simplement aux données d'option qui sont renvoyées au client, dans ce cas, dans la fenêtre de test. Dans l'exercice suivant, vous utiliserez une fonction Lambda pour répondre à l'intention, auquel cas vous recevrez un message indiquant que la commande est exécutée.
**Étape suivante**
[Étape 2 (facultatif) : Vérification des détails du flux d'informations (console)](gs-bp-details-two-runtime-apis.md)
# Étape 2 (facultatif) : Vérification des détails du flux d'informations (console)
Cette section explique le flux d'informations entre un client et Amazon Lex pour chaque entrée utilisateur dans notre exemple de conversation.
L'exemple utilise la fenêtre de test de la console pour la conversation avec le bot.
**Pour ouvrir la fenêtre de test Amazon Lex**
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Choisissez le bot à tester.
1. Sur le côté droit de la console, choisissez **Tester le chatbot**.
Pour voir le flux d'informations pour le contenu vocal ou écrit, choisissez la rubrique appropriée.
**Topics**
+ [
# Étape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console)
](gs-bp-details-postcontent-flow.md)
+ [
# Étape 2b (facultatif) : Vérification des détails du flux d'informations saisies (console)
](gs-bp-details-part1.md)
# Étape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console)
Cette section explique le flux d'informations entre le client et Amazon Lex lorsque le client utilise la parole pour envoyer des demandes. Pour de plus amples informations, veuillez consulter [PostContent](API_runtime_PostContent.md).
1. L'utilisateur dit : I would like to order some flowers.
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à 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
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (`$LATEST`), son alias () et le nom d'utilisateur (chaîne aléatoire identifiant l'utilisateur). `OrderFlowers` `content`indique qu'il s'agit d'une demande d'`PostContent`API (et non d'une `PostText` demande).
+ En-têtes de demandes
+ `x-amz-lex-session-attributes`— La valeur codée en base64 représente « \$1\$1 ». Lorsque le client effectue la première demande, il n'existe aucun attribut de session.
+ `Content-Type` – Reflète le format audio.
+ Corps de la demande – Le flux audio d'entrée utilisateur (« I would like to order some flowers. »).
**Note**
Si l'utilisateur choisit d'envoyer un texte (« I would like to order some flowers ») à l'API `PostContent` au lieu de parler, le corps de la demande est l'entrée utilisateur. L'en-tête `Content-Type` est défini en conséquence :
```
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. À partir du flux d'entrée, Amazon Lex détecte l'intention (`OrderFlowers`). Il choisit alors l'une des options de l'intention (dans ce cas, `FlowerType`) et l'une de ses invites d'obtention de valeur, puis il envoie une réponse avec les en-têtes suivants :
```
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==
```
Les valeurs d'en-tête fournissent les informations suivantes :
+ `x-amz-lex-input-transcript` – Fournit la transcription du message audio (entrée utilisateur) à partir de la demande
+ `x-amz-lex-message`— Fournit la transcription de l'audio renvoyé par Amazon Lex dans la réponse
+ `x-amz-lex-slots` – La version encodée en base 64 des options et valeurs :
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes` – La version encodée en base 64 des attributs de session (\$1\$1)
Le client lit le message audio dans le corps de réponse.
1. L'utilisateur dit : roses
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à 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")
```
Le corps de la demande est le flux audio de l'entrée utilisateur (roses). `sessionAttributes` reste vide.
1. Amazon Lex interprète le flux d'entrée dans le contexte de l'intention actuelle (il se souvient qu'il a demandé à cet utilisateur des informations relatives au `FlowerType` slot). Amazon Lex met d'abord à jour la valeur de l'emplacement en fonction de l'intention actuelle. Il choisit ensuite un autre emplacement (`PickupDate`), ainsi que l'un de ses messages invite (When do you want to pick up the roses?), puis renvoie une réponse avec les en-têtes suivants :
```
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=
```
Les valeurs d'en-tête fournissent les informations suivantes :
+ `x-amz-lex-slots` – La version encodée en base 64 des options et valeurs :
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes` – La version encodée en base 64 des attributs de session (\$1\$1)
Le client lit le message audio dans le corps de réponse.
1. L'utilisateur dit : tomorrow
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à 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")
```
Le corps de la demande est le flux audio de l'entrée utilisateur (« tomorrow »). `sessionAttributes` reste vide.
1. Amazon Lex interprète le flux d'entrée dans le contexte de l'intention actuelle (il se souvient qu'il a demandé à cet utilisateur des informations relatives au `PickupDate` slot). Amazon Lex met à jour la valeur de slot (`PickupDate`) en fonction de l'intention actuelle. Il choisit ensuite une autre option pour laquelle obtenir une valeur (`PickupTime`) et l'une de ses invites d'obtention de valeur (When do you want to pick up the roses on 2017-03-18?), puis il renvoie une réponse avec les en-têtes suivants :
```
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
```
Les valeurs d'en-tête fournissent les informations suivantes :
+ `x-amz-lex-slots` – La version encodée en base 64 des options et valeurs :
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes` – La version encodée en base 64 des attributs de session (\$1\$1)
Le client lit le message audio dans le corps de réponse.
1. L'utilisateur dit : 6 pm
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à 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")
```
Le corps de la demande est le flux audio de l'entrée utilisateur (« 6 pm »). `sessionAttributes` reste vide.
1. Amazon Lex interprète le flux d'entrée dans le contexte de l'intention actuelle (il se souvient qu'il a demandé à cet utilisateur des informations relatives au `PickupTime` slot). Il met d'abord à jour la valeur d'option pour l'intention actuelle.
Amazon Lex détecte désormais qu'il possède des informations pour tous les emplacements. Cependant, l'intention `OrderFlowers` est configurée avec un message de confirmation. Amazon Lex a donc besoin d'une confirmation explicite de la part de l'utilisateur avant de pouvoir réaliser son intention. Il envoie une réponse avec les en-têtes suivants, demandant une confirmation avant de commander les fleurs :
```
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
```
Les valeurs d'en-tête fournissent les informations suivantes :
+ `x-amz-lex-slots` – La version encodée en base 64 des options et valeurs :
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes` – La version encodée en base 64 des attributs de session (\$1\$1)
Le client lit le message audio dans le corps de réponse.
1. L'utilisateur dit : Yes
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à 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")
```
Le corps de la demande est le flux audio de l'entrée utilisateur (« Yes »). `sessionAttributes` reste vide.
1. Amazon Lex interprète le flux d'entrée et comprend que l'utilisateur souhaite poursuivre la commande. L'intention `OrderFlowers` est configurée avec `ReturnIntent` comme activité d'exécution. Cela demande à Amazon Lex de renvoyer toutes les données d'intention au client. Amazon Lex renvoie une réponse contenant les informations suivantes :
```
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==
```
L'en-tête de réponse `x-amz-lex-dialog-state` est défini sur `ReadyForFulfillment`. Le client peut alors traiter l'intention.
1. A présent, retestez le bot. Pour établir un nouveau contexte (nouvel utilisateur), choisissez le lien **Effacer** dans la console. Fournissez des données pour l'intention `OrderFlowers` et incluez des données non valides. Par exemple :
+ Jasmine comme type de fleur (ce n'est pas l'un des types de fleur pris en charge)
+ Yesterday comme jour pendant lequel vous souhaitez récupérer les fleurs
Notez que le bot accepte ces valeurs parce que vous n'avez pas de code pour initialiser et valider les données utilisateur. Dans la section suivante, vous allez ajouter une fonction Lambda à cet effet. Notez ce qui suit à propos de la fonction Lambda :
+ Elle valide les données d'option après chaque entrée utilisateur. Elle traite l'intention à la fin. Autrement dit, le bot traite la commande de fleurs et renvoie un message à l'utilisateur au lieu de simplement renvoyer les données d'option au client. Pour de plus amples informations, veuillez consulter [Utilisation des fonctions Lambda](using-lambda.md).
+ Elle définit également les attributs de session. Pour en savoir plus sur les attributs de session, consultez [PostText](API_runtime_PostText.md).
Une fois que vous avez terminé la section de mise en route, vous pouvez faire les exercices suivants ([Exemples supplémentaires : création de robots Amazon Lex](additional-exercises.md) ). [Réservez un voyage](ex-book-trip.md) utilise des attributs de session pour partager des informations entre les intentions afin d'engager une conversation dynamique avec l'utilisateur.
**Étape suivante**
[Étape 3 : Création d'une fonction Lambda (console)](gs-bp-create-lambda-function.md)
# Étape 2b (facultatif) : Vérification des détails du flux d'informations saisies (console)
Cette section décrit le flux d'informations entre le client et Amazon Lex dans lequel le client utilise l'API `PostText` pour envoyer des demandes. Pour de plus amples informations, veuillez consulter [PostText](API_runtime_PostText.md).
1. L'utilisateur tape : I would like to order some flowers
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à 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": {}
}
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (`OrderFlowers`), l'alias du bot (`$LATEST`) et le nom d'utilisateur (chaîne aléatoire identifiant l'utilisateur). Le code `text` de fin indique qu'il s'agit d'une demande d'API `PostText` (et non `PostContent`).
+ Corps de la demande – Inclut l'entrée utilisateur (`inputText`) et un champ `sessionAttributes` vide. Lorsque le client effectue la première demande, il n'existe aucun attribut de session. La fonction Lambda initiera ces attributs ultérieurement.
1. À partir du`inputText`, Amazon Lex détecte l'intention (`OrderFlowers`). Cette intention ne comporte aucun crochet de code (c'est-à-dire les fonctions Lambda) pour l'initialisation et la validation des entrées ou du traitement des données par l'utilisateur.
Amazon Lex choisit l'un des emplacements de l'intention (`FlowerType`) pour obtenir la valeur. Il sélectionne aussi l'une des invites d'obtention de valeur pour l'option (toutes faisant partie de la configuration d'intention), puis il renvoie la réponse suivante au client. La console affiche le message dans la réponse à l'utilisateur.
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-10.png)
Le client affiche le message dans la réponse.
1. L'utilisateur tape : roses
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. `sessionAttributes` reste vide.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle : le service se souvient qu'il a demandé à l'utilisateur concerné des informations sur le slot. `FlowerType` Amazon Lex met d'abord à jour la valeur de l'emplacement en fonction de l'intention actuelle, puis choisit un autre emplacement (`PickupDate`) avec l'un de ses messages d'invite : quel jour souhaitez-vous que les roses soient récupérées ? — `` pour le slot.
Amazon Lex renvoie ensuite la réponse suivante :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-20.png)
Le client affiche le message dans la réponse.
1. L'utilisateur tape : tomorrow
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. `sessionAttributes` reste vide.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle : le service se souvient qu'il a demandé à l'utilisateur concerné des informations sur le slot. `PickupDate` Amazon Lex met à jour la valeur de slot (`PickupDate`) en fonction de l'intention actuelle. Il choisit une autre option pour laquelle obtenir une valeur (`PickupTime`). Il renvoie l'une des questions d'identification de valeur : livrer les roses à quelle heure le 05/01/2017 ? — `` au client.
Amazon Lex renvoie ensuite la réponse suivante :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-30.png)
Le client affiche le message dans la réponse.
1. L'utilisateur tape : 6 pm
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. `sessionAttributes` reste vide.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle : le service se souvient qu'il a demandé à l'utilisateur concerné des informations sur le slot. `PickupTime` Amazon Lex met d'abord à jour la valeur de l'emplacement en fonction de l'intention actuelle. Amazon Lex détecte désormais qu'il possède des informations pour tous les emplacements.
L'intention `OrderFlowers` est configurée avec un message de confirmation. Amazon Lex a donc besoin d'une confirmation explicite de la part de l'utilisateur avant de pouvoir réaliser son intention. Amazon Lex envoie le message suivant au client pour lui demander une confirmation avant de commander les fleurs :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-40.png)
Le client affiche le message dans la réponse.
1. L'utilisateur tape : Yes
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. `sessionAttributes` reste vide.
1. Amazon Lex interprète le `inputText` dans le contexte de la confirmation de l'intention actuelle. Il comprend que l'utilisateur souhaite continuer avec la commande. L'`OrderFlowers`intention est configurée `ReturnIntent` comme activité d'exécution (il n'existe aucune fonction Lambda pour répondre à l'intention). Par conséquent, Amazon Lex renvoie les données d'emplacement suivantes au client.
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex a défini le `dialogState` paramètre sur`ReadyForFulfillment`. Le client peut alors traiter l'intention.
1. Maintenant, retestez le bot. Pour ce faire, vous devez choisir le lien **Effacer** dans la console pour établir un nouveau contexte (nouvel utilisateur). A présent, en fournissant des données pour l'intention de commande de fleurs, essayez de fournir des données non valides. Par exemple :
+ Jasmine comme type de fleur (ce n'est pas l'un des types de fleur pris en charge).
+ Yesterday comme jour pendant lequel vous souhaitez récupérer les fleurs.
Notez que le bot accepte ces valeurs car vous n'avez aucun code pour les données initialize/validate utilisateur. Dans la section suivante, vous allez ajouter une fonction Lambda à cet effet. Notez ce qui suit à propos de la fonction Lambda :
+ La fonction Lambda valide les données du slot après chaque saisie par l'utilisateur. Elle traite l'intention à la fin. Autrement dit, le bot traite la commande de fleur et renvoie un message à l'utilisateur au lieu de simplement renvoyer des données d'option au client. Pour de plus amples informations, veuillez consulter [Utilisation des fonctions Lambda](using-lambda.md).
+ La fonction Lambda définit également les attributs de session. Pour en savoir plus sur les attributs de session, consultez [PostText](API_runtime_PostText.md).
Une fois que vous avez terminé la section de mise en route, vous pouvez faire les exercices suivants ([Exemples supplémentaires : création de robots Amazon Lex](additional-exercises.md) ). [Réservez un voyage](ex-book-trip.md) utilise des attributs de session pour partager des informations entre les intentions afin d'engager une conversation dynamique avec l'utilisateur.
**Étape suivante**
[Étape 3 : Création d'une fonction Lambda (console)](gs-bp-create-lambda-function.md)
# Étape 3 : Création d'une fonction Lambda (console)
Créez une fonction Lambda (à l'aide du **lex-order-flowers-python**plan) et effectuez un appel de test à l'aide d'exemples de données d'événement dans la console. AWS Lambda
Vous revenez à la console Amazon Lex et vous ajoutez la fonction Lambda comme crochet de code pour répondre à l'`OrderFlowers`objectif `OrderFlowersBot` que vous avez créé dans la section précédente.
**Pour créer une fonction Lambda (console)**
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Choisissez **Créer une fonction**.
1. Sur la page **Créer une fonction**, choisissez **Use a blueprint (Utiliser un plan)**. Tapez **lex-** dans la zone de texte du filtre, puis appuyez sur `Enter` pour rechercher et choisir le plan `lex-order-flowers-python`.
Les plans de fonction Lambda sont fournis à la fois dans Node.js et Python. Pour cet exercice, utilisez le modèle basé sur Python.
1. Sur la page **Basic information (Informations de base)**, effectuez les opérations suivantes.
+ Entrez le nom d'une fonction Lambda ()`OrderFlowersCodeHook`.
+ Pour le rôle d'exécution, choisissez **Create a new role with basic Lambda permissions**.
+ Laissez les autres valeurs par défaut.
1. Sélectionnez **Create function** (Créer une fonction).
1. Si vous utilisez une langue autre que l'anglais (États-Unis) (en-US), mettez à jour les noms d'intention comme décrit dans[Mettre à jour un plan pour un environnement régional spécifique](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testez la fonction Lambda.
1. Choisissez **Select a test events (Sélectionner un événement de test)**, **Configure test event (Configurer un événement de test)**.
1. Choisissez **Lex-Order Flowers** dans la liste **Event template (Modèle d'événement)**. Cet exemple d'événement correspond au request/response modèle Amazon Lex (voir[Utilisation des fonctions Lambda](using-lambda.md)). Donnez un nom à l'événement de test (`LexOrderFlowersTest`).
1. Choisissez **Créer**.
1. Choisissez **Test** pour tester le hook de code.
1. Vérifiez que la fonction Lambda s'est correctement exécutée. Dans ce cas, la réponse correspond au modèle de réponse Amazon Lex.
**Étape suivante**
[Étape 4 : ajouter la fonction Lambda en tant que crochet de code (console)](gs-bp-create-integrate.md)
# Étape 4 : ajouter la fonction Lambda en tant que crochet de code (console)
Dans cette section, vous allez mettre à jour la configuration de l' OrderFlowersintention d'utiliser la fonction Lambda comme suit :
+ Utilisez d'abord la fonction Lambda comme crochet de code pour réaliser l'`OrderFlowers`intention. Vous testez le bot et vérifiez que vous avez reçu un message d'expédition de la part de la fonction Lambda. Amazon Lex n'invoque la fonction Lambda qu'une fois que vous avez fourni les données relatives à tous les emplacements requis pour commander des fleurs.
+ Configurez la même fonction Lambda en tant que crochet de code pour effectuer l'initialisation et la validation. Vous testez et vérifiez que la fonction Lambda effectue la validation (lorsque vous fournissez des données d'emplacement).
**Pour ajouter une fonction Lambda en tant que crochet de code (console)**
1. Dans la console Amazon Lex, sélectionnez le **OrderFlowers**bot. La console indique l'**OrderFlowers**intention. Assurez-vous que la version d'intention est définie sur `$LATEST`, car c'est la seule version que nous pouvons modifier.
1. Ajoutez la fonction Lambda comme crochet du code d'expédition et testez-la.
1. Dans l'éditeur, choisissez la **AWS Lambda fonction** **Fulfillment**, puis sélectionnez la fonction Lambda que vous avez créée à l'étape précédente ()`OrderFlowersCodeHook`. Cliquez **sur OK** pour autoriser Amazon Lex à appeler la fonction Lambda.
Vous configurez cette fonction Lambda en tant que crochet de code pour répondre à l'objectif. Amazon Lex n'invoque cette fonction qu'après avoir reçu toutes les données de créneau nécessaires de la part de l'utilisateur pour répondre à son intention.
1. Spécifiez un **message de fin de conversation**.
1. Sélectionnez **Créer**.
1. Testez le bot à l'aide de la conversation précédente.
La dernière déclaration « Merci, votre commande de roses... » est une réponse de la fonction Lambda que vous avez configurée en tant que crochet de code. Dans la section précédente, il n'y avait aucune fonction Lambda. Vous utilisez maintenant une fonction Lambda pour réellement répondre à l'`OrderFlowers`intention.
1. Ajoutez la fonction Lambda en tant que crochet de code d'initialisation et de validation, puis testez.
L'exemple de code de fonction Lambda que vous utilisez peut à la fois valider et exécuter les saisies par l'utilisateur. L'événement d'entrée que reçoit la fonction Lambda comporte un champ (`invocationSource`) que le code utilise pour déterminer la partie du code à exécuter. Pour de plus amples informations, veuillez consulter [Format d'événement et de réponse d'entrée de la fonction Lambda](lambda-input-response-format.md).
1. Sélectionnez la dernière version (\$1LATEST) de l'intention `OrderFlowers`. C'est la seule version que vous pouvez mettre à jour.
1. Dans l'éditeur, choisissez **Initialization and validation** dans **Options**.
1. Sélectionnez à nouveau la même fonction Lambda.
1. Sélectionnez **Créer**.
1. Testez le bot.
Vous êtes maintenant prêt à converser avec Amazon Lex, comme indiqué dans l'image suivante. Pour tester la partie validation, choisissez l'heure 18 h, et votre fonction Lambda renvoie une réponse (« Nos heures d'ouverture sont de 10 h à 17 h ») et vous invite à nouveau. Une fois que vous avez fourni toutes les données d'emplacement valides, la fonction Lambda exécute la commande.
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Étape suivante**
[Étape 5 (facultatif) : Vérification des détails du flux d'informations (console)](gs-bp-details-after-lambda.md)
# Étape 5 (facultatif) : Vérification des détails du flux d'informations (console)
Cette section explique le flux d'informations entre le client et Amazon Lex pour chaque entrée utilisateur, y compris l'intégration de la fonction Lambda.
**Note**
La section part du principe que le client envoie des demandes à Amazon Lex à l'aide de l'API `PostText` d'exécution et affiche les détails des demandes et des réponses en conséquence. Pour un exemple du flux d'informations entre le client et Amazon Lex dans lequel le client utilise l'`PostContent`API, consultez[Étape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console)](gs-bp-details-postcontent-flow.md).
Pour plus d'informations sur l'API d'exécution `PostText`, et obtenir des détails supplémentaires sur les demandes et les réponses illustrées dans les étapes suivantes, consultez [PostText](API_runtime_PostText.md).
1. Utilisateur : I would like to order some flowers.
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à 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": {}
}
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (`OrderFlowers`), l'alias du bot (`$LATEST`) et le nom d'utilisateur (chaîne aléatoire identifiant l'utilisateur). Le code `text` de fin indique qu'il s'agit d'une demande d'API `PostText` (et non `PostContent`).
+ Corps de la demande – Inclut l'entrée utilisateur (`inputText`) et un champ `sessionAttributes` vide. Lorsque le client effectue la première demande, il n'existe aucun attribut de session. La fonction Lambda initiera ces attributs ultérieurement.
1. À partir du`inputText`, Amazon Lex détecte l'intention (`OrderFlowers`). Cette intention est configurée avec une fonction Lambda en tant que crochet de code pour l'initialisation et la validation des données utilisateur. Amazon Lex invoque donc cette fonction Lambda en transmettant les informations suivantes sous forme de données d'événement :
```
{
"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"
}
}
```
Pour de plus amples informations, veuillez consulter [Format d'un événement d'entrée](lambda-input-response-format.md#using-lambda-input-event-format).
Outre les informations envoyées par le client, Amazon Lex inclut également les données supplémentaires suivantes :
+ `messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
+ `invocationSource`— Indique l'objectif de l'appel de la fonction Lambda. Dans ce cas, il s'agit d'effectuer l'initialisation et la validation des données utilisateur. À l'heure actuelle, Amazon Lex sait que l'utilisateur n'a pas fourni toutes les données de créneau conformément à son intention.
+ Informations `currentIntent`, pour lesquelles toutes les valeurs d'option sont définies sur null.
1. Pour l'instant, toutes les valeurs d'option sont null. La fonction Lambda n'a rien à valider. La fonction Lambda renvoie la réponse suivante à Amazon Lex :
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Pour plus d'informations sur le format de réponse, consultez [Format de la réponse](lambda-input-response-format.md#using-lambda-response-format).
Notez ce qui suit :
+ `dialogAction.type`— En définissant cette valeur sur`Delegate`, la fonction Lambda délègue la responsabilité de décider de la prochaine ligne de conduite à Amazon Lex.
**Note**
Si la fonction Lambda détecte un élément lors de la validation des données utilisateur, elle indique à Amazon Lex la marche à suivre, comme indiqué dans les étapes suivantes.
1. Selon le`dialogAction.type`, Amazon Lex décide de la prochaine ligne de conduite. Comme aucune des options n'est remplie, il décide d'obtenir la valeur pour l'option `FlowerType`. Il sélectionne aussi l'une des invites d'obtention de valeur (« What type of flowers would you like to order? ») pour l'option, puis il renvoie la réponse suivante au client :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-10.png)
Le client affiche le message dans la réponse.
1. Utilisateur : roses
1. Le client envoie la [PostText](API_runtime_PostText.md) demande suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. `sessionAttributes` reste vide.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle. Le service se souvient qu'il avait demandé à cet utilisateur des informations sur l'option `FlowerType`. Il met à jour la valeur du slot dans l'intention actuelle et appelle la fonction Lambda avec les données d'événement suivantes :
```
{
"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"
}
}
```
Notez ce qui suit :
+ `invocationSource` – Continue d'être `DialogCodeHook` (nous validons simplement les données utilisateur).
+ `currentIntent.slots`— Amazon Lex a changé le `FlowerType` slot en roses.
1. Selon la `invocationSource` valeur de`DialogCodeHook`, la fonction Lambda effectue la validation des données utilisateur. Elle la reconnaît `roses` comme une valeur d'emplacement valide (et la définit `Price` comme un attribut de session) et renvoie la réponse suivante à Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Notez ce qui suit :
+ `sessionAttributes`— La fonction Lambda a ajouté `Price` (des roses) en tant qu'attribut de session.
+ `dialogAction.type` – Est défini sur `Delegate`. Les données utilisateur étant valides, la fonction Lambda indique à Amazon Lex de choisir le plan d'action suivant.
1. Selon le`dialogAction.type`, Amazon Lex choisit la prochaine ligne de conduite. Amazon Lex sait qu'il a besoin de plus de données d'emplacement. Il choisit donc le prochain emplacement vide (`PickupDate`) ayant la priorité la plus élevée en fonction de la configuration prévue. Amazon Lex sélectionne l'un des messages d'incitation à valeur ajoutée : « Quel jour voulez-vous que les roses soient cueillies ? » —pour cet emplacement en fonction de la configuration d'intention, puis renvoie la réponse suivante au client :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-20.png)
Le client affiche simplement le message dans la réponse – « What day do you want the roses to be picked up? ».
1. Utilisateur : tomorrow
1. Le client envoie la [PostText](API_runtime_PostText.md) demande suivante à Amazon Lex :
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur ; le client retransmet les attributs de session au service.
1. Amazon Lex se souvient du contexte, à savoir qu'il s'agissait de collecter des données pour le slot. `PickupDate` Dans ce contexte, il sait que la valeur `inputText` est pour l'option `PickupDate`. Amazon Lex invoque ensuite la fonction Lambda en envoyant l'événement suivant :
```
{
"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 a mis à jour le en `currentIntent.slots` définissant la `PickupDate` valeur. Notez également que le service transmet le `sessionAttributes` tel quel à la fonction Lambda.
1. Selon la `invocationSource` valeur de`DialogCodeHook`, la fonction Lambda effectue la validation des données utilisateur. Il reconnaît que la valeur de l'`PickupDate`emplacement est valide et renvoie la réponse suivante à Amazon Lex :
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Notez ce qui suit :
+ `sessionAttributes` – Pas de modification.
+ `dialogAction.type` – Est défini sur `Delegate`. Les données utilisateur étaient valides et la fonction Lambda indique à Amazon Lex de choisir le plan d'action suivant.
1. Selon le`dialogAction.type`, Amazon Lex choisit la prochaine ligne de conduite. Amazon Lex sait qu'il a besoin de plus de données d'emplacement. Il choisit donc le prochain emplacement vide (`PickupTime`) ayant la priorité la plus élevée en fonction de la configuration prévue. Amazon Lex sélectionne l'un des messages d'invite (« Livrez les roses à quelle heure le 05/01/2017 ? ») pour cet emplacement en fonction de la configuration d'intention et renvoie la réponse suivante au client :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-30.png)
Le client affiche le message dans la réponse : « Livrez les roses à quelle heure le 05/01/2017 ? »
1. Utilisateur : 4 pm
1. Le client envoie la [PostText](API_runtime_PostText.md) demande suivante à 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"
}
}
```
Dans le corps de la demande, `inputText` fournit l'entrée utilisateur. Le client transmet les attributs de session (`sessionAttributes`) dans la demande.
1. Amazon Lex comprend le contexte. Il comprend qu'il obtenait des données pour l'option `PickupTime`. Dans ce contexte, il sait que la `inputText` valeur est pour le `PickupTime` slot. Amazon Lex invoque ensuite la fonction Lambda en envoyant l'événement suivant :
```
{
"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 a mis à jour le en `currentIntent.slots` définissant la `PickupTime` valeur.
1. Selon la `invocationSource` valeur de`DialogCodeHook`, la fonction Lambda effectue la validation des données utilisateur. Il reconnaît que la valeur de l'`PickupDate`emplacement est valide et renvoie la réponse suivante à Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Notez ce qui suit :
+ `sessionAttributes` – Aucune modification dans l'attribut de session.
+ `dialogAction.type` – Est défini sur `Delegate`. Les données utilisateur étant valides, la fonction Lambda indique à Amazon Lex de choisir le plan d'action suivant.
1. À l'heure actuelle, Amazon Lex sait qu'il dispose de toutes les données relatives aux emplacements. Cette intention est configurée avec un message de confirmation. Amazon Lex envoie donc la réponse suivante à l'utilisateur pour lui demander une confirmation avant de réaliser son intention :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-45.png)
Le client affiche simplement le message dans la réponse et attend la réponse de l'utilisateur.
1. Utilisateur : Yes
1. Le client envoie la [PostText](API_runtime_PostText.md) demande suivante à 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 interprète le `inputText` dans le contexte de la confirmation de l'intention actuelle. Amazon Lex comprend que l'utilisateur souhaite poursuivre la commande. Cette fois, Amazon Lex invoque la fonction Lambda pour répondre à son intention en envoyant l'événement suivant, qui définit `invocationSource` le `FulfillmentCodeHook` to dans l'événement envoyé à la fonction Lambda. Amazon Lex définit également la valeur `confirmationStatus` à`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"
}
}
```
Notez ce qui suit :
+ `invocationSource`— Cette fois, Amazon Lex a défini cette valeur sur`FulfillmentCodeHook`, demandant à la fonction Lambda de répondre à l'intention.
+ `confirmationStatus` – Est défini sur `Confirmed`.
1. Cette fois, la fonction Lambda répond à l'`OrderFlowers`intention et renvoie la réponse suivante :
```
{
"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"
}
}
}
```
Notez ce qui suit :
+ Définit le `dialogAction.type` — La fonction Lambda définit cette valeur sur`Close`, indiquant à Amazon Lex de ne pas s'attendre à une réponse de l'utilisateur.
+ `dialogAction.fulfillmentState` – Est défini sur Fulfilled et inclut un `message` approprié à transmettre à l'utilisateur.
1. Amazon Lex examine le `fulfillmentState` et renvoie la réponse suivante au client.
Amazon Lex renvoie ensuite ce qui suit au client :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs-1-details-48.png)
Remarque :
+ `dialogState`— Amazon Lex définit cette valeur sur`fulfilled`.
+ `message`— est le même message que celui fourni par la fonction Lambda.
Le client affiche le message.
1. Maintenant, retestez le bot. Pour établir un nouveau contexte (nouvel utilisateur), choisissez le lien **Effacer** dans la fenêtre de test. A présent, fournissez des données d'option non valides pour l'intention `OrderFlowers`. Cette fois, la fonction Lambda effectue la validation des données, rétablit la valeur nulle des données d'emplacement non valide et demande à Amazon Lex de demander à l'utilisateur de fournir des données valides. Par exemple, essayez ce qui suit :
+ Jasmine comme type de fleur (ce n'est pas l'un des types de fleur pris en charge).
+ Yesterday comme jour pendant lequel vous souhaitez récupérer les fleurs.
+ Après avoir passé votre commande, entrez un autre type de fleur au lieu de répondre « yes » pour confirmer la commande. En réponse, la fonction Lambda met à jour l'attribut `Price` in the session, en conservant le total cumulé des commandes de fleurs.
La fonction Lambda exécute également l'activité d'exécution.
**Étape suivante**
[Étape 6 : Mise à jour de la configuration de l'intention pour ajouter un énoncé (console)](gs-bp-utterance.md)
# Étape 6 : Mise à jour de la configuration de l'intention pour ajouter un énoncé (console)
Le bot `OrderFlowers` est configuré avec seulement deux énoncés. Cela fournit des informations limitées permettant à Amazon Lex de créer un modèle d'apprentissage automatique qui reconnaît les intentions de l'utilisateur et y répond. Essayez de taper « Je veux commander des fleurs », comme dans la fenêtre de test suivante. Amazon Lex ne reconnaît pas le texte et répond par « Je ne vous ai pas compris, que voudriez-vous faire ? » Vous pouvez améliorer le modèle d'apprentissage machine en y ajoutant davantage d'énoncés.
![\[La fenêtre de test indique un énoncé manqué.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-120.png)
Chaque énoncé que vous ajoutez fournit à Amazon Lex davantage d'informations sur la manière de répondre à vos utilisateurs. Il n'est pas nécessaire d'ajouter un énoncé exact, Amazon Lex généralise à partir des exemples que vous fournissez pour reconnaître à la fois les correspondances exactes et les entrées similaires.
**Pour ajouter un énoncé (console)**
1. Ajoutez l'énoncé « Je veux des fleurs » à l'intention en le saisissant dans la section **Exemples d'énoncés** de l'éditeur d'intention, comme dans l'image suivante, puis en cliquant sur l'icône plus à côté du nouvel énoncé.
![\[Éditeur d'intention avec le nouvel énoncé.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-130.png)
1. Compilez le bot pour qu'il applique les modifications apportées. Choisissez **Création**, puis**Création** à nouveau.
1. Testez le bot pour confirmer qu'il reconnaît le nouvel énoncé. Dans la fenêtre de test, comme dans l'image suivante, tapez « Je souhaite commander des fleurs ». Amazon Lex reconnaît la phrase et répond par « Quel type de fleurs souhaitez-vous commander ? ».
![\[L'éditeur d'intention reconnaît le nouvel énoncé.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-140.png)
**Étape suivante**
[Étape 7 (facultatif) : Nettoyage (console)](gs-bp-cleaning-up.md)
# Étape 7 (facultatif) : Nettoyage (console)
Supprimez à présent les ressources que vous avez créées et nettoyez votre compte.
Vous pouvez supprimer uniquement les ressources qui ne sont pas en cours d'utilisation. En règle générale, vous devez supprimer les ressources dans l'ordre suivant :
+ Supprimer les bots pour libérer les ressources d'intention.
+ Supprimer les intentions pour libérer les ressources de type d'option.
+ Supprimer les types d'option en dernier.
**Pour nettoyer votre compte (console)**
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Dans la liste des robots, cochez la case à côté de **OrderFlowers**.
1. Pour supprimer le bot, choisissez **Supprimer**, puis **Continuer** dans la boîte de dialogue de confirmation.
1. Dans le volet de gauche, choisissez **Intents**.
1. Dans la liste des intentions, choisissez **OrderFlowersIntent**.
1. Pour supprimer l'intention, choisissez **Supprimer**, puis **Continuer** dans la boîte de dialogue de confirmation.
1. Dans le volet de gauche, choisissez **Slot types**.
1. Dans la liste des types d'options, choisissez **Flowers**.
1. Pour supprimer le type d'option, choisissez **Supprimer**, puis **Continuer** dans la boîte de dialogue de confirmation.
Vous avez supprimé toutes les ressources Amazon Lex que vous avez créées et nettoyé votre compte. Si vous le souhaitez, vous pouvez utiliser la [console Lambda](https://console.aws.amazon.com/lambda) pour supprimer la fonction Lambda utilisée dans cet exercice.
# Exercice 2 : créer un robot Amazon Lex personnalisé
Dans cet exercice, vous allez utiliser la console Amazon Lex pour créer un bot personnalisé qui commande des pizzas (`OrderPizzaBot`). La configuration du bot implique l'ajout d'une intention personnalisée (`OrderPizza`), la définition de types d'option personnalisés et la définition des options requises pour traiter une commande de pizza (pâte, taille, etc.). Pour plus d'informations sur les types d'option et les options, consultez [Amazon Lex : comment ça marche](how-it-works.md).
**Topics**
+ [
# Étape 1 : Créer une fonction Lambda
](gs2-prepare.md)
+ [
# Etape 2 : Création d'un bot
](gs2-create-bot.md)
+ [
# Etape 3 : Création et test du bot
](gs2-build-and-test.md)
+ [
# Etape 4 (facultative) : Nettoyage
](gs2-clean-up.md)
# Étape 1 : Créer une fonction Lambda
Créez d'abord une fonction Lambda qui exécute une commande de pizza. Vous spécifiez cette fonction dans votre bot Amazon Lex, que vous créez dans la section suivante.
**Pour créer une fonction Lambda**
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Choisissez **Créer une fonction**.
1. Sur la page **Create function**, sélectionnez **Author from scratch**.
Comme vous créez une fonction Lambda à l'aide du code personnalisé qui vous est fourni dans le cadre de cet exercice, vous pouvez choisir le créer la fonction à partir de zéro.
Procédez comme suit :
1. Saisissez le nom (`PizzaOrderProcessor`).
1. Pour **Runtime (Exécution)**, choisissez la dernière version de Node.js.
1. Pour **Role**, choisissez **Create new role from template(s)**.
1. Entrez un nom pour le nouveau rôle (`PizzaOrderProcessorRole`).
1. Choisissez **Créer une fonction**.
1. Sur la page de fonction, procédez comme suit :
Dans la section **Function code**, choisissez **Edit code inline**, puis copiez le code de fonction Node.js suivant et collez-le dans la fenêtre.
```
'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. Choisissez **Enregistrer**.
## Testez la fonction Lambda à l'aide d'exemples de données d'événement
Dans la console, testez la fonction Lambda en utilisant des exemples de données d'événement pour l'invoquer manuellement.
**Pour tester la fonction Lambda :**
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Sur la page de la **fonction Lambda**, sélectionnez la fonction Lambda (`PizzaOrderProcessor).`
1. Sur la page de fonction, dans la liste des événements de test, choisissez **Configure test events**.
1. Sur la page **Configure test event**, procédez de la façon suivante :
1. Choisissez **Create new test event**.
1. Dans le champ **Event name**, entrez un nom pour l'événement, par exemple (`PizzaOrderProcessorTest`).
1. Copiez l'événement Amazon Lex suivant dans la fenêtre.
```
{
"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. Choisissez **Créer**.
AWS Lambda crée le test et vous revenez à la page des fonctions. Choisissez **Test** et Lambda exécute votre fonction Lambda.
Dans la zone de résultat, choisissez **Détails**. La console affiche la sortie suivante dans le volet **Execution result**.
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Okay, I have ordered your large meat pizza on thin crust."
}
}
```
## Étape suivante
[Etape 2 : Création d'un bot](gs2-create-bot.md)
# Etape 2 : Création d'un bot
Au cours de cette étape, vous créez un bot pour traiter les commandes de pizza.
**Topics**
+ [
# Création du bot
](gs2-create-bot-create.md)
+ [
# Création d'une intention
](gs2-create-bot-intent.md)
+ [
# Création des types d'option
](gs2-create-bot-slot-types.md)
+ [
# Configuration de l'intention
](gs2-create-bot-configure-intent.md)
+ [
# Configuration du robot
](gs2-create-bot-configure-bot.md)
# Création du bot
Créez le bot `PizzaOrderingBot` avec le minimum d'informations nécessaires. Vous ajouterez une intention (action que l'utilisateur souhaite effectuer) au bot ultérieurement.
**Pour créer le bot**
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Créez un bot.
1. Si vous créez votre premier bot, choisissez **Mise en route**. Sinon, choisissez **Bots**, puis **Create**.
1. Sur la page **Create your Lex bot**, choisissez **Custom bot** et saisissez les informations suivantes :
+ **Nom du bot** : PizzaOrderingBot
+ **Langue** : Choisissez la langue et les paramètres régionaux de votre bot.
+ **Output voice** : Salli
+ **Session timeout ** : 5 minutes
+ **COPPA** : Choisissez la réponse appropriée.
+ **Stockage des énoncés de l'utilisateur : choisissez la réponse appropriée.**
1. Choisissez **Créer**.
La console envoie à Amazon Lex une demande de création d'un nouveau bot. Amazon Lex définit la version du bot sur`$LATEST`. Après avoir créé le bot, Amazon Lex affiche l'onglet Bot **Editor**, comme dans l'image suivante :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-20.png)
+ La version du bot, **Latest**, est située à côté du nom du bot dans la console. Les nouvelles ressources Amazon Lex ont `$LATEST` comme version. Pour de plus amples informations, veuillez consulter [Versions et alias](versioning-aliases.md).
+ Aucune intention ni aucun type d'option n'apparaissent dans la mesure où vous n'en avez pas encore créés.
+ **Création** et **Publication** sont des activités au niveau du bot. Une fois que vous avez configuré la totalité du bot, vous pourrez en savoir plus sur ces activités.
## Étape suivante
[Création d'une intention](gs2-create-bot-intent.md)
# Création d'une intention
A présent, créez l'intention `OrderPizza` (action que l'utilisateur souhaite réaliser) avec le minimum d'informations nécessaires. Vous ajouterez les types d'options pour l'intention et configurerez cette dernière ultérieurement.
**Pour créer une intention**
1. Dans la console Amazon Lex, choisissez le signe plus (\$1) à côté de **Intents**, puis choisissez **Create new intent**.
1. Dans la boîte de dialogue **Create intent**, saisissez le nom de l'intention (`OrderPizza`), puis choisissez **Add**.
La console envoie une demande à Amazon Lex pour créer l'`OrderPizza`intention. Dans cet exemple, vous créez des options pour l'intention après avoir créé des types d'options.
## Étape suivante
[Création des types d'option](gs2-create-bot-slot-types.md)
# Création des types d'option
Créez les types d'options (ou valeurs de paramètres) que l'intention `OrderPizza` utilisera.
**Pour créer des types d'option**
1. Dans le menu de gauche, choisissez le signe plus (\$1) à côté de **Slot types**.
1. Dans la boîte de dialogue **Add slot type**, ajoutez les informations suivantes :
+ **Slot type name** : Crusts
+ **Description** : Available crusts
+ Choisissez **Restrict to Slot values and Synonyms**.
+ **Valeur** — Type**thick**. Appuyez sur la touche de tabulation dans le type de champ **Synonym (Synonyme)****stuffed**. Cliquez sur le signe plus (\$1). Tapez **thin**, puis choisissez le signe plus (\$1) à nouveau.
La boîte de dialogue doit ressembler à l'image suivante :
![\[Boîte de dialogue de modification des types d'options.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-25a.png)
1. Choisissez **Add slot to intent**.
1. Sur la page **Intent**, choisissez **Required**. Remplacez le nom de l'option **slotOne** par **crust**. Remplacez l'invite par **What kind of crust would you like?**
1. Répétez les étapes [Step 1](#slotTypeStart) à [Step 4](#slotTypeFinish) à l'aide des valeurs contenues dans le tableau suivant :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/gs2-create-bot-slot-types.html)
## Étape suivante
[Configuration de l'intention](gs2-create-bot-configure-intent.md)
# Configuration de l'intention
Configurez l'intention `OrderPizza` pour répondre à la demande de commande d'une pizza d'un utilisateur.
**Pour configurer une intention**
+ Sur la page **OrderPizza**de configuration, configurez l'intention comme suit :
+ **Exemples d'énoncés** — Tapez les chaînes suivantes. Des accolades \$1\$1 entourent les noms d'option.
+ Je veux commander une pizza s'il vous plaît
+ Je veux commander une pizza
+ Je veux commander une pizza \$1pizzaKind\$1
+ Je veux commander une pizza \$1size\$1 \$1pizzaKind\$1
+ I want a \$1size\$1 \$1crust\$1 crust \$1pizzaKind\$1 pizza
+ Puis-je avoir une pizza s'il vous plaît
+ Puis-je avoir une pizza \$1pizzaKind\$1
+ Puis-je avoir une pizza \$1size\$1 \$1pizzaKind\$1
+ **Lambda initialization and validation** : conservez le paramètre par défaut.
+ **Confirmation prompt** : conservez le paramètre par défaut.
+ **Exécution** — Effectuez les tâches suivantes :
+ Choisissez la **fonction AWS Lambda **.
+ Sélectionnez **PizzaOrderProcessor**.
+ Si la boîte de dialogue **Ajouter une autorisation à la fonction Lambda** s'affiche, cliquez **sur OK** pour autoriser l'`OrderPizza`intention à appeler la fonction Lambda`PizzaOrderProcessor`.
+ Laissez **None** sélectionné.
L'intention doit ressembler à ce qui suit :
![\[Éditeur de l'intention.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-70c.png)
## Étape suivante
[Configuration du robot](gs2-create-bot-configure-bot.md)
# Configuration du robot
Configurez le traitement des erreurs pour le bot `PizzaOrderingBot`.
1. Accédez au bot `PizzaOrderingBot`. Choisissez **Editeur**, puis sélectionnez **Gestion des erreurs**, comme dans l'image suivante :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-80.png)
1. Utilisez l'onglet **Editor** pour configurer le traitement des erreurs pour le bot.
+ Les informations que vous fournissez dans les mappages **Clarification Prompts** sont liées à la configuration [clarificationPrompt](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-clarificationPrompt) du bot.
Lorsqu'Amazon Lex ne parvient pas à déterminer l'intention de l'utilisateur, le service renvoie une réponse contenant ce message.
+ Les informations que vous fournissez dans le mappage d'expressions **Hang-up** sont liées à la configuration [abortStatement](https://docs.aws.amazon.com/lex/latest/dg/API_PutBot.html#lex-PutBot-request-abortStatement) du bot.
Si le service ne parvient pas à déterminer l'intention de l'utilisateur après un certain nombre de demandes consécutives, Amazon Lex renvoie une réponse contenant ce message.
Laissez les valeurs par défaut.
## Étape suivante
[Etape 3 : Création et test du bot](gs2-build-and-test.md)
# Etape 3 : Création et test du bot
Assurez-vous que le bot fonctionne, en le compilant et en le testant.
**Pour compiler et tester le bot**
1. Pour compiler le bot `PizzaOrderingBot`, choisissez **Création**.
Amazon Lex crée un modèle d'apprentissage automatique pour le bot. Lorsque vous testez le bot, la console utilise l'API d'exécution pour renvoyer les données saisies par l'utilisateur à Amazon Lex. Amazon Lex utilise ensuite le modèle d'apprentissage automatique pour interpréter les données saisies par l'utilisateur.
La création peut prendre un certain temps.
1. Pour tester le bot, dans la fenêtre **Test Bot**, commencez à communiquer avec votre bot Amazon Lex.
+ Par exemple, vous pouvez dire ou taper ce qui suit :
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-110.png)
+ Utilisez les exemples d'énoncés que vous avez configurés dans l'intention `OrderPizza` pour tester le bot. Par exemple, voici l'un des exemples d'énoncés que vous avez configurés pour l'intention `PizzaOrder` :
```
I want a {size} {crust} crust {pizzaKind} pizza
```
Pour le tester, tapez ce qui suit :
```
I want a large thin crust cheese pizza
```
Lorsque vous tapez « Je veux commander une pizza », Amazon Lex détecte l'intention (`OrderPizza`). Amazon Lex demande ensuite des informations sur les créneaux.
Une fois que vous avez fourni toutes les informations d'emplacement, Amazon Lex appelle la fonction Lambda que vous avez configurée à cette fin.
La fonction Lambda renvoie un message (« OK, j'ai commandé votre... ») à Amazon Lex, qu'Amazon Lex vous renvoie.
## Vérification de la réponse
Sous la fenêtre de discussion se trouve un volet qui vous permet de consulter la réponse d'Amazon Lex. Ce volet fournit des informations complètes sur l'état du bot. Celles-ci changent à mesure que vous interagissez avec le bot. Le contenu des volets indique l'état actuel de l'opération.
+ **État du dialogue** : état actuel de la conversation avec l'utilisateur. `ElicitIntent`, `ElicitSlot`, `ConfirmIntent` ou `Fulfilled` sont les différentes options possibles.
+ **Résumé** — Affiche une vue simplifiée de la boîte de dialogue qui indique les valeurs des créneaux correspondant à l'objectif à atteindre afin que vous puissiez suivre le flux d'informations. Cette option indique le nom de l'intention, le nombre d'options ainsi que le nombre d'options remplies, et une liste de toutes les options et de leurs valeurs associées. Voir l'image suivante :
![\[Le volet d'inspection du résumé des réponses de la console Amazon Lex.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-115.png)
+ **Détail** — Affiche la réponse JSON brute du chatbot pour vous donner une vision plus approfondie de l'interaction avec le bot et de l'état actuel du dialogue lorsque vous testez et déboguez votre chatbot. Si vous tapez quelque chose dans la fenêtre de chat, le volet de vérification affiche la réponse JSON à partir de l'opération [PostText](API_runtime_PostText.md). Si vous parlez à la fenêtre de chat, le volet de vérification affiche les en-têtes de réponse à partir de l'opération [PostContent](API_runtime_PostContent.md). Voir l'image suivante :
![\[Volet de vérification de la réponse dans la console.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs1-116.png)
## Étape suivante
[Etape 4 (facultative) : Nettoyage](gs2-clean-up.md)
# Etape 4 (facultative) : Nettoyage
Supprimez les ressources que vous avez créées et nettoyez votre compte pour ne pas encourir de frais supplémentaires.
Vous pouvez supprimer uniquement les ressources qui ne sont pas en cours d'utilisation. Par exemple, vous ne pouvez pas supprimer un type d'option qui est référencé par une intention. Vous ne pouvez pas supprimer une intention qui est référencée par un bot.
Supprimez les ressources dans l'ordre suivant :
+ Supprimer les bots pour libérer les ressources d'intention.
+ Supprimer les intentions pour libérer les ressources de type d'option.
+ Supprimer les types d'option en dernier.
**Pour nettoyer votre compte**
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Dans la liste des bots, choisissez **PizzaOrderingBot**.
1. Pour supprimer le bot, choisissez **Supprimer**, puis **Continuer**.
1. Dans le volet de gauche, choisissez **Intents**.
1. Dans la liste des intentions, choisissez **OrderPizza**.
1. Pour supprimer l'intention, choisissez **Supprimer**, puis **Continuer**.
1. Dans le menu de gauche, choisissez **Slot types**.
1. Dans la liste des types d'options, choisissez **Crusts**.
1. Pour supprimer le type d'option, choisissez **Supprimer**, puis **Continuer**.
1. Répétez [Step 8](#chooseSlots) et [Step 9](#deleteSlots) pour les types d'option `Sizes` et `PizzaKind`.
Vous avez supprimé toutes les ressources que vous avez créées et nettoyé votre compte.
## Étapes suivantes
+ [Publiez une version et créez un alias.](https://docs.aws.amazon.com/lex/latest/dg/gettingstarted-ex3.html)
+ [Créez un bot Amazon Lex à l'aide du AWS Command Line Interface](https://docs.aws.amazon.com/lex/latest/dg/gs-cli.html)
# Exercice 3 : Publication d'une version et création d'un alias
Dans les exercices de mise en route 1 et 2, vous avez créé un bot et vous l'avez testé. Dans cet exercice, vous effectuez les opérations suivantes :
+ Publiez une nouvelle version du bot. Amazon Lex prend une copie instantanée de la `$LATEST` version pour publier une nouvelle version.
+ Créez un alias qui renvoie vers la nouvelle version.
Pour plus d'informations sur la gestion des versions et les alias, consultez [Versions et alias](versioning-aliases.md).
Pour publier une version d'un bot que vous avez créée pour cet exercice, procédez comme suit :
1. Dans la console Amazon Lex, choisissez l'un des robots que vous avez créés.
Vérifiez que la console indique la version de bot `$LATEST` à côté du nom du bot.
1. Choisissez **Publish**.
1. Dans l'assistant **Publish *botname***, spécifiez l'alias **BETA**, puis choisissez **Publish (Publier)**.
1. Vérifiez que la console Amazon Lex affiche la nouvelle version à côté du nom du bot, comme dans l'image suivante.
![\[\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/gs2-final.png)
Maintenant que vous avez un bot fonctionnel avec une version et un alias publiés, vous pouvez déployer le bot (dans votre application mobile ou intégrer le bot dans Facebook Messenger). Pour obtenir un exemple, consultez [Intégration d'un robot Amazon Lex à Facebook Messenger](fb-bot-association.md).
# Étape 4 : Démarrer (AWS CLI)
Au cours de cette étape, vous allez AWS CLI utiliser le pour créer, tester et modifier un bot Amazon Lex. Pour effectuer ces exercices, vous devez être familiarisé avec l'interface de ligne de commande et vous devez disposer d'un éditeur de texte. Pour de plus amples informations, consultez [Étape 2 : configurer le AWS Command Line Interface](gs-set-up-cli.md).
+ Exercice 1 — Créez et testez un robot Amazon Lex. Cet exercice fournit tous les objets JSON dont vous avez besoin pour créer un type d'option personnalisé, une intention et un bot. Pour de plus amples informations, consultez [Amazon Lex : comment ça marche](how-it-works.md).
+ Exercice 2 — Mettez à jour le bot que vous avez créé dans l'exercice 1 pour ajouter un exemple d'énoncé supplémentaire. Amazon Lex utilise des exemples d'énoncés pour créer le modèle d'apprentissage automatique pour votre bot.
+ Exercice 3 — Mettez à jour le bot que vous avez créé dans l'exercice 1 pour ajouter une fonction Lambda afin de valider les entrées de l'utilisateur et de répondre à l'intention.
+ Exercice 4 — Publiez une version du type de slot, de l'intention et des ressources de bot que vous avez créées dans l'exercice 1. Une version est un instantané d'une ressource qui ne peut pas être modifié.
+ Exercice 5 — Créez un alias pour le bot que vous avez créé dans l'exercice 1.
+ Exercice 6 — Nettoyez votre compte en supprimant le type d'emplacement, l'intention et le bot que vous avez créés dans l'exercice 1, ainsi que l'alias que vous avez créé dans l'exercice 5.
**Topics**
+ [
# Exercice 1 : créer un robot Amazon Lex (AWS CLI)
](gs-cli-create.md)
+ [
# Exercice 2 : Ajout d'un nouvel énoncé (AWS CLI)
](gs-cli-update-utterance.md)
+ [
# Exercice 3 : Ajouter une fonction Lambda ()AWS CLI
](gs-cli-update-lambda.md)
+ [
# Exercice 4 : Publication d'une version (AWS CLI)
](gs-cli-publish.md)
+ [
# Exercice 5 : Création d'un alias (AWS CLI)
](gs-cli-create-alias.md)
+ [
# Exercice 6 : Nettoyage (AWS CLI)
](gs-cli-clean-up.md)
# Exercice 1 : créer un robot Amazon Lex (AWS CLI)
En général, lorsque vous créez des bots, vous devez effectuer les actions suivantes :
1. Créez des types d'options pour définir les informations que le bot utilisera.
1. Créez des intentions qui définissent les actions utilisateur que le bot prendra en charge. Utilisez les types d'options personnalisés que vous avez créés précédemment pour définir les options, ou paramètres, que votre intention nécessite.
1. Créez un bot qui utilise les intentions que vous avez définies.
Dans cet exercice, vous allez créer et tester un nouveau bot Amazon Lex à l'aide de la CLI. Utilisez les structures JSON que nous fournissons pour créer le bot. Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Topics**
+ [
# Étape 1 : Création d'un rôle lié aux services (AWS CLI)
](gs-create-role.md)
+ [
# Étape 2 : Création d'un type d'option personnalisé (AWS CLI)
](gs-create-flower-types.md)
+ [
# Étape 3 : Création d'une intention (AWS CLI)
](gs-cli-create-order-flowers.md)
+ [
# Étape 4 : Création d'un bot (AWS CLI)
](gs-cli-create-order-flowers-bot.md)
+ [
# Étape 5 : Test d'un bot (AWS CLI)
](gs-create-test.md)
# Étape 1 : Création d'un rôle lié aux services (AWS CLI)
Amazon Lex assume des rôles Gestion des identités et des accès AWS liés aux services pour appeler les AWS services au nom de vos robots. Les rôles, qui se trouvent dans votre compte, sont liés aux cas d'utilisation d'Amazon Lex et disposent d'autorisations prédéfinies. Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon Lex](using-service-linked-roles.md).
Si vous avez déjà créé un bot Amazon Lex à l'aide de la console, le rôle lié au service a été créé automatiquement. Passez à [Étape 2 : Création d'un type d'option personnalisé (AWS CLI)](gs-create-flower-types.md).
**Pour créer un rôle lié à un service (AWS CLI)**
1. Dans le AWS CLI, tapez la commande suivante :
```
aws iam create-service-linked-role --aws-service-name lex.amazonaws.com
```
1. Vérifiez la stratégie avec la commande suivante :
```
aws iam get-role --role-name AWSServiceRoleForLexBots
```
La réponse est :
## Étape suivante
[Étape 2 : Création d'un type d'option personnalisé (AWS CLI)](gs-create-flower-types.md)
# Étape 2 : Création d'un type d'option personnalisé (AWS CLI)
Créez un type d'option personnalisé avec des valeurs d'énumération pour les fleurs qui peuvent être commandées. Vous utiliserez ce type d'option à l'étape suivante lorsque vous créerez l'intention `OrderFlowers`. Un *type d'option* définit les valeurs possibles pour une option (paramètre) de l'intention.
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Pour créer un type d'option personnalisé (AWS CLI)**
1. Créez un fichier texte nommé **FlowerTypes.json**. Copiez le code JSON de [FlowerTypes.json](gs-cli-create-flower-types-json.md) dans ce fichier texte.
1. Appelez l'[PutSlotType](API_PutSlotType.md)opération à l'aide du AWS CLI pour créer le type d'emplacement. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws lex-models put-slot-type \
--region region \
--name FlowerTypes \
--cli-input-json file://FlowerTypes.json
```
La réponse du serveur est :
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"checksum": "checksum",
"version": "$LATEST",
"lastUpdatedDate": timestamp,
"createdDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Étape suivante
[Étape 3 : Création d'une intention (AWS CLI)](gs-cli-create-order-flowers.md)
# FlowerTypes.json
Le code suivant représente les données JSON requises pour créer le type d'option personnalisé `FlowerTypes` :
```
{
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"description": "Types of flowers to pick up"
}
```
# Étape 3 : Création d'une intention (AWS CLI)
Créez une intention pour le bot `OrderFlowersBot` et fournissez trois options, ou paramètres. Les options permettent au bot de traiter l'intention :
+ `FlowerType` est un type de d'option personnalisé qui spécifie les types de fleurs qui peuvent être commandés.
+ `AMAZON.DATE` et `AMAZON.TIME` sont des types d'options prédéfinis permettent de demander à l'utilisateur la date et l'heure de livraison des fleurs.
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Pour créer l'intention `OrderFlowers` (AWS CLI)**
1. Créez un fichier texte nommé **OrderFlowers.json**. Copiez le code JSON de [OrderFlowers.json](gs-cli-create-order-flowers-json.md) dans ce fichier texte.
1. Dans le AWS CLI, appelez l'[PutIntent](API_PutIntent.md)opération pour créer l'intention. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers.json
```
Le serveur répond avec les éléments suivants :
## Étape suivante
[Étape 4 : Création d'un bot (AWS CLI)](gs-cli-create-order-flowers-bot.md)
# OrderFlowers.json
Le code suivant représente les données JSON requises pour créer l'intention `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"
}
```
# Étape 4 : Création d'un bot (AWS CLI)
Le bot `OrderFlowersBot` possède une seule intention, à savoir l'intention `OrderFlowers` que vous avez créée dans l'étape précédente. Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST`.
**Pour créer le bot `OrderFlowersBot` (AWS CLI)**
1. Créez un fichier texte nommé **OrderFlowersBot.json**. Copiez le code JSON de [OrderFlowersBot.json](gs-cli-create-order-flowers-bot-json.md) dans ce fichier texte.
1. Dans le AWS CLI, appelez l'[PutBot](API_PutBot.md)opération pour créer le bot. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot.json
```
La réponse du serveur est indiquée ci-dessous. Lorsque vous créez ou mettez à jour le bot, le champ `status` est défini sur `BUILDING`. Cela signifie que le bot n'est pas prêt à être utilisé. Pour déterminer lorsque le bot sera prêt à être utilisé, utilisez l'opération [GetBot](API_GetBot.md) à l'étape suivante.
1. Pour déterminer si votre nouveau bot est prêt à être utilisé, exécutez la commande suivante. Répétez cette commande jusqu'à ce que le champ `status` renvoie `READY`. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST"
```
Recherchez le champ `status` dans la répons :
```
{
"status": "READY",
...
}
```
## Étape suivante
[Étape 5 : Test d'un bot (AWS CLI)](gs-create-test.md)
# OrderFlowersBot.json
Le code suivant fournit les données JSON requises pour créer le bot `OrderFlowers` Amazon Lex :
```
{
"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"
}
```
# Étape 5 : Test d'un bot (AWS CLI)
Pour tester le bot, vous pouvez utiliser un test basé sur une entrée de texte ou une entrée vocale.
**Topics**
+ [
# Test du bot avec une entrée de texte (AWS CLI)
](gs-create-test-text.md)
+ [
# Test du bot avec une entrée vocale (AWS CLI)
](gs-create-test-speech.md)
# Test du bot avec une entrée de texte (AWS CLI)
Pour vérifier que le bot fonctionne correctement avec une entrée de texte, utilisez l'opération [PostText](API_runtime_PostText.md). Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas de service d'exécution](gl-limits.md#gl-limits-runtime).
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour utiliser un texte afin de tester le bot (AWS CLI)**
1. Dans le AWS CLI, entamez une conversation avec le `OrderFlowersBot` bot. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
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 reconnaît l'intention de l'utilisateur et entame une conversation en renvoyant la réponse suivante :
```
{
"slotToElicit": "FlowerType",
"slots": {
"PickupDate": null,
"PickupTime": null,
"FlowerType": null
},
"dialogState": "ElicitSlot",
"message": "What type of flowers would you like to order?",
"intentName": "OrderFlowers"
}
```
1. Exécutez les commandes suivantes pour terminer la conversation avec le 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"
```
Une fois que vous avez confirmé la commande, Amazon Lex envoie une réponse d'expédition pour terminer la conversation :
```
{
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
},
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers"
}
```
## Étape suivante
[Test du bot avec une entrée vocale (AWS CLI)](gs-create-test-speech.md)
# Test du bot avec une entrée vocale (AWS CLI)
Pour tester le bot à l'aide de fichiers audio, utilisez l'opération [PostContent](API_runtime_PostContent.md). Vous générez les fichiers audio à l'aide des opérations Amazon Polly. text-to-speech
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes Amazon Lex et Amazon Polly seront exécutées. Pour obtenir la liste des régions pour Amazon Lex, consultez[Quotas de service d'exécution](gl-limits.md#gl-limits-runtime). Pour obtenir la liste des régions pour Amazon Polly, voir [AWS Régions et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region) dans le manuel *Amazon Web Services* General Reference.
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour utiliser une entrée vocale afin de tester le bot (AWS CLI)**
1. Dans le AWS CLI, créez un fichier audio à l'aide d'Amazon Polly. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws polly synthesize-speech \
--region region \
--output-format pcm \
--text "i would like to order flowers" \
--voice-id "Salli" \
IntentSpeech.mpg
```
1. Pour envoyer le fichier audio à Amazon Lex, exécutez la commande suivante. Amazon Lex enregistre le son de la réponse dans le fichier de sortie spécifié.
```
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 répond en demandant le premier emplacement. Il enregistre la réponse audio dans le fichier de sortie spécifié.
```
{
"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. Pour commander des roses, créez le fichier audio suivant et envoyez-le à 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. Pour définir la date de livraison, créez le fichier audio suivant et envoyez-le à 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. Pour définir le délai de livraison, créez le fichier audio suivant et envoyez-le à 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. Pour confirmer la livraison, créez le fichier audio suivant et envoyez-le à 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
```
Une fois que vous avez confirmé la livraison, Amazon Lex envoie une réponse confirmant la réalisation de l'intention :
```
{
"contentType": "text/plain;charset=utf-8",
"dialogState": "ReadyForFulfillment",
"intentName": "OrderFlowers",
"inputTranscript": "yes",
"slots": {
"PickupDate": "2017-05-16",
"PickupTime": "10:00",
"FlowerType": "roses"
}
}
```
## Étape suivante
[Exercice 2 : Ajout d'un nouvel énoncé (AWS CLI)](gs-cli-update-utterance.md)
# Exercice 2 : Ajout d'un nouvel énoncé (AWS CLI)
Pour améliorer le modèle d'apprentissage automatique qu'Amazon Lex utilise pour reconnaître les demandes de vos utilisateurs, ajoutez un autre exemple d'énoncé au bot.
L'ajout d'un nouvel énoncé se fait en quatre étapes.
1. Utilisez l'[GetIntent](API_GetIntent.md)opération pour obtenir une intention d'Amazon Lex.
1. Mettez à jour l'intention.
1. Utilisez cette [PutIntent](API_PutIntent.md) opération pour renvoyer l'intention mise à jour à Amazon Lex.
1. Utilisez les opération [GetBot](API_GetBot.md) et [PutBot](API_PutBot.md) pour reconstruire les bots qui utilisent cette intention.
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
La réponse générée par l'opération `GetIntent` contient le champ `checksum`, qui identifie une révision spécifique de l'intention. Vous devez fournir la valeur du total de contrôle lorsque vous utilisez l'opération [PutIntent](API_PutIntent.md) pour mettre à jour une intention. Dans le cas contraire, vous obtiendrez le message d'erreur suivant :
```
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.
```
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour mettre à jour l'intention `OrderFlowers` (AWS CLI)**
1. Dans le AWS CLI, obtenez l'intention auprès d'Amazon Lex. Amazon Lex envoie la sortie vers un fichier appelé **OrderFlowers-V2.json.**
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V2.json
```
1. Ouvrez **OrderFlowers-V2.json** dans un éditeur de texte.
1. Recherchez les champs `createdDate`, `lastUpdatedDate` et `version` et supprimez-les.
1. Ajoutez le texte suivant dans le champ `sampleUtterances` :
```
I want to order flowers
```
1. Enregistrez le fichier.
1. Envoyez l'intention mise à jour à Amazon Lex à l'aide de la commande suivante :
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V2.json
```
Amazon Lex envoie la réponse suivante :
Maintenant que vous avez mis à jour l'intention, reconstruisez les bots qui l'utilisent.
**Pour reconstruire le bot `OrderFlowersBot` (AWS CLI)**
1. Dans le AWS CLI, récupérez la définition du `OrderFlowersBot` bot et enregistrez-la dans un fichier à l'aide de la commande suivante :
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V2.json
```
1. Ouvrez **OrderFlowersBot-V2.json** dans un éditeur de texte. Supprimez les champs `createdDate`, `lastUpdatedDate`, `status` et `version`.
1. Dans un éditeur de texte, ajoutez la ligne suivante à la définition du bot :
```
"processBehavior": "BUILD",
```
1. Dans le AWS CLI, créez une nouvelle version du bot en exécutant la commande suivante pour :
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V2.json
```
La réponse du serveur est :
## Étape suivante
[Exercice 3 : Ajouter une fonction Lambda ()AWS CLI](gs-cli-update-lambda.md)
# Exercice 3 : Ajouter une fonction Lambda ()AWS CLI
Ajoutez une fonction Lambda qui valide les entrées de l'utilisateur et répond à l'intention de l'utilisateur à l'égard du bot.
L'ajout d'une expression Lambda est un processus en cinq étapes.
1. [Utilisez la [AddPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html)fonction Lambda pour activer l'`OrderFlowers`intention d'appeler l'opération Lambda Invoke.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html)
1. Utilisez l'[GetIntent](API_GetIntent.md)opération pour obtenir l'intention d'Amazon Lex.
1. Mettez à jour l'intention d'ajouter la fonction Lambda.
1. Utilisez cette [PutIntent](API_PutIntent.md) opération pour renvoyer l'intention mise à jour à Amazon Lex.
1. Utilisez les opération [GetBot](API_GetBot.md) et [PutBot](API_PutBot.md) pour reconstruire les bots qui utilisent cette intention.
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
Si vous ajoutez une fonction Lambda à une intention avant d'ajouter l'`InvokeFunction`autorisation, le message d'erreur suivant s'affiche :
```
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 réponse générée par l'opération `GetIntent` contient le champ `checksum`, qui identifie une révision spécifique de l'intention. Lorsque vous utilisez l'opération [PutIntent](API_PutIntent.md) pour mettre à jour une intention, vous devez fournir la valeur du total de contrôle. Dans le cas contraire, vous obtiendrez le message d'erreur suivant :
```
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.
```
Cet exercice utilise la fonction Lambda de. [Exercice 1 : créer un robot Amazon Lex à l'aide d'un plan (console)](gs-bp.md) Pour obtenir des instructions sur la création de la fonction Lambda, reportez-vous à la section. [Étape 3 : Création d'une fonction Lambda (console)](gs-bp-create-lambda-function.md)
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST`.
**Pour ajouter une fonction Lambda à une intention**
1. Dans le AWS CLI, ajoutez l'`InvokeFunction`autorisation correspondant à l'`OrderFlowers`intention :
```
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 envoie la réponse suivante :
```
{
"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. Obtenez l'intention auprès d'Amazon Lex. Amazon Lex envoie la sortie vers un fichier appelé**OrderFlowers-V3.json**.
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers-V3.json
```
1. Ouvrez le fichier **OrderFlowers-V3.json** dans un éditeur de texte.
1. Recherchez les champs `createdDate`, `lastUpdatedDate` et `version` et supprimez-les.
1. Mettez à jour le champ `fulfillmentActivity` :
```
"fulfillmentActivity": {
"type": "CodeHook",
"codeHook": {
"uri": "arn:aws:lambda:region:account ID:function:OrderFlowersCodeHook",
"messageVersion": "1.0"
}
}
```
1. Enregistrez le fichier.
1. Dans le AWS CLI, envoyez l'intention mise à jour à Amazon Lex :
```
aws lex-models put-intent \
--region region \
--name OrderFlowers \
--cli-input-json file://OrderFlowers-V3.json
```
Maintenant que vous avez mis à jour l'intention, reconstruisez le bot.
**Pour reconstruire le bot `OrderFlowersBot`**
1. Dans le AWS CLI, obtenez la définition du `OrderFlowersBot` bot et enregistrez-la dans un fichier :
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot-V3.json
```
1. Ouvrez **OrderFlowersBot-V3.json** dans un éditeur de texte. Supprimez les champs `createdDate`, `lastUpdatedDate`, `status` et `version`.
1. Dans l'éditeur de texte, ajoutez la ligne suivante à la définition du bot :
```
"processBehavior": "BUILD",
```
1. Dans le AWS CLI, créez une nouvelle version du bot :
```
aws lex-models put-bot \
--region region \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot-V3.json
```
La réponse du serveur est :
## Étape suivante
[Exercice 4 : Publication d'une version (AWS CLI)](gs-cli-publish.md)
# Exercice 4 : Publication d'une version (AWS CLI)
Vous allez à présent créer une version du bot réalisé dans l'exercice 1. Une *version* est un instantané du bot. Vous ne pouvez pas modifier une version après l'avoir créée. La seule version d'un bot que vous pouvez mettre à jour est la version `$LATEST`. Pour plus d'informations sur les versions, consultez [Versions et alias](versioning-aliases.md).
Avant de publier une version d'un bot, vous devez publier les intentions qu'il utilise. De même, vous devez publier les types d'options auxquels ces intentions se rapportent à. En général, pour publier une version d'un bot, vous devez suivre la procédure ci-dessous :
1. Publiez une version d'un type d'option avec l'opération [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md).
1. Publiez une version d'une intention avec l'opération [CreateIntentVersion](API_CreateIntentVersion.md).
1. Publiez une version d'un bot avec l'opération [CreateBotVersion](API_CreateBotVersion.md).
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Topics**
+ [
# Etape 1 : Publication du type d'option (AWS CLI)
](gs-cli-publish-slot-type.md)
+ [
# Étape 2 : Publication de l'intention (AWS CLI)
](gs-cli-publish-intent.md)
+ [
# Étape 3 : Publication du bot (AWS CLI)
](gs-cli-publish-bot.md)
# Etape 1 : Publication du type d'option (AWS CLI)
Avant de pouvoir publier une version de tous les intentions qui utilisent un type d'option, vous devez publier une version de ce dernier. Dans ce cas, vous publiez le type d'option `FlowerTypes`.
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour publier un type d'option (AWS CLI)**
1. Dans le AWS CLI, procurez-vous la dernière version du type de machine à sous :
```
aws lex-models get-slot-type \
--region region \
--name FlowerTypes \
--slot-type-version "\$LATEST"
```
La réponse d'Amazon Lex suit. Enregistrez le total de contrôle pour la révision actuelle de la version `$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. Publiez une version du type d'option. Utilisez le total de contrôle que vous avez enregistré à l'étape précédente.
```
aws lex-models create-slot-type-version \
--region region \
--name FlowerTypes \
--checksum "checksum"
```
La réponse d'Amazon Lex suit. Enregistrez le numéro de version pour l'étape suivante.
```
{
"version": "1",
"enumerationValues": [
{
"value": "tulips"
},
{
"value": "lilies"
},
{
"value": "roses"
}
],
"name": "FlowerTypes",
"createdDate": timestamp,
"lastUpdatedDate": timestamp,
"description": "Types of flowers to pick up"
}
```
## Étape suivante
[Étape 2 : Publication de l'intention (AWS CLI)](gs-cli-publish-intent.md)
# Étape 2 : Publication de l'intention (AWS CLI)
Avant de pouvoir publier une intention, vous devez publier tous les types d'options auxquels elle se rapporte. Les types d'options doivent être des versions numérotées, pas la version `$LATEST`.
Tout d'abord, mettez à jour l'intention `OrderFlowers` pour qu'elle utilise la version du type d'option `FlowerTypes` que vous avez publié dans l'étape précédente. Publiez ensuite une nouvelle version de l'intention `OrderFlowers`.
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour publier une version d'une intention (AWS CLI)**
1. Dans le AWS CLI, obtenez la `$LATEST` version de l'`OrderFlowers`intention et enregistrez-la dans un fichier :
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4.json
```
1. Dans un éditeur de texte, ouvrez le fichier **OrderFlowers\$1V4.json**. Supprimez les champs `createdDate`, `lastUpdatedDate` et `version`. Recherchez le type d'option `FlowerTypes` et remplacez la version par le numéro de version que vous avez enregistré dans l'étape précédente. Le fragment suivant du fichier **OrderFlowers\$1V4.json** montre l'emplacement de la modification :
```
{
"slotType": "FlowerTypes",
"name": "FlowerType",
"slotConstraint": "Required",
"valueElicitationPrompt": {
"maxAttempts": 2,
"messages": [
{
"content": "What type of flowers?",
"contentType": "PlainText"
}
]
},
"priority": 1,
"slotTypeVersion": "version",
"sampleUtterances": []
},
```
1. Dans le AWS CLI, enregistrez la révision de l'intention :
```
aws lex-models put-intent \
--name OrderFlowers \
--cli-input-json file://OrderFlowers_V4.json
```
1. Obtenez le total de contrôle de la dernière révision de l'intention :
```
aws lex-models get-intent \
--region region \
--name OrderFlowers \
--intent-version "\$LATEST" > OrderFlowers_V4a.json
```
Le fragment suivant de la réponse montre le total de contrôle de l'intention. Prenez-en note pour l'étape suivante.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "$LATEST",
```
1. Publiez une nouvelle version de l'intention :
```
aws lex-models create-intent-version \
--region region \
--name OrderFlowers \
--checksum "checksum"
```
Le fragment suivant de la réponse montre la nouvelle version de l'intention. Enregistrez le numéro de version pour l'étape suivante.
```
"name": "OrderFlowers",
"checksum": "checksum",
"version": "version",
```
## Étape suivante
[Étape 3 : Publication du bot (AWS CLI)](gs-cli-publish-bot.md)
# Étape 3 : Publication du bot (AWS CLI)
Une fois que vous avez publié tous les types d'options et toutes les intentions qui sont utilisés par votre bot, vous pouvez publier le bot.
Mettez à jour le bot `OrderFlowersBot` pour qu'il utilise l'intention `OrderFlowers` que vous avez mise à jour dans l'étape précédente. Publiez ensuite une nouvelle version du bot `OrderFlowersBot`.
**Note**
L' AWS CLI exemple suivant est formaté pour Unix, Linux et macOS. Pour Windows, remplacez `"\$LATEST"` par `$LATEST` et remplacez le caractère de continuation, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Pour publier une version d'un bot (AWS CLI)**
1. Dans le AWS CLI, récupérez la `$LATEST` version du `OrderFlowersBot` bot et enregistrez-la dans un fichier :
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias "\$LATEST" > OrderFlowersBot_V4.json
```
1. Dans un éditeur de texte, ouvrez le fichier **OrderFlowersBot\$1V4.json**. Supprimez les champs `createdDate`, `lastUpdatedDate`, `status` et `version`. Recherchez l'intention `OrderFlowers` et remplacez la version par le numéro de version que vous avez enregistré dans l'étape précédente. Le fragment suivant du fichier **OrderFlowersBot\$1V4.json** montre l'emplacement de la modification.
```
"intents": [
{
"intentVersion": "version",
"intentName": "OrderFlowers"
}
```
1. Dans le AWS CLI, enregistrez la nouvelle révision du bot. Notez le numéro de version renvoyé par l'appel à `put-bot`.
```
aws lex-models put-bot \
--name OrderFlowersBot \
--cli-input-json file://OrderFlowersBot_V4.json
```
1. Obtenez le total de contrôle de la dernière révision du bot. Utilisez le numéro de version renvoyé à l'étape 3.
```
aws lex-models get-bot \
--region region \
--version-or-alias version \
--name OrderFlowersBot > OrderFlowersBot_V4a.json
```
Le fragment suivant de la réponse montre le total de contrôle du bot. Prenez-en note pour l'étape suivante.
```
"name": "OrderFlowersBot",
"locale": "en-US",
"checksum": "checksum",
```
1. Publiez une nouvelle version du bot:
```
aws lex-models create-bot-version \
--region region \
--name OrderFlowersBot \
--checksum "checksum"
```
Le fragment suivant de la réponse montre la nouvelle version du bot.
```
"checksum": "checksum",
"abortStatement": {
...
},
"version": "1",
"lastUpdatedDate": timestamp,
```
## Étape suivante
[Exercice 5 : Création d'un alias (AWS CLI)](gs-cli-create-alias.md)
# Exercice 5 : Création d'un alias (AWS CLI)
Un alias est un pointeur vers une version spécifique d'un bot. Avec un alias, vous pouvez facilement mettre à jour la version que vos applications clientes utilisent. Pour plus d'informations, consultez [Versions et alias](versioning-aliases.md). Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Pour créer un alias (AWS CLI)**
1. Dans le AWS CLI, obtenez la version du `OrderFlowersBot` bot dans laquelle vous avez créé[Exercice 4 : Publication d'une version (AWS CLI)](gs-cli-publish.md).
```
aws lex-models get-bot \
--region region \
--name OrderFlowersBot \
--version-or-alias version > OrderFlowersBot_V5.json
```
1. Ouvrez **OrderFlowersBot\$1v5.json** dans un éditeur de texte. Recherchez le numéro de version et prenez-en note.
1. Dans le AWS CLI, créez l'alias du bot :
```
aws lex-models put-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot \
--bot-version version
```
La réponse du serveur est la suivante :
```
{
"name": "PROD",
"createdDate": timestamp,
"checksum": "checksum",
"lastUpdatedDate": timestamp,
"botName": "OrderFlowersBot",
"botVersion": "1"
}}
```
## Étape suivante
[Exercice 6 : Nettoyage (AWS CLI)](gs-cli-clean-up.md)
# Exercice 6 : Nettoyage (AWS CLI)
Supprimez les ressources que vous avez créées et nettoyez votre compte.
Vous pouvez supprimer uniquement les ressources qui ne sont pas en cours d'utilisation. En règle générale, vous devez supprimer les ressources dans l'ordre suivant.
1. Supprimez les alias pour libérer les ressources du bot.
1. Supprimer les bots pour libérer les ressources d'intention.
1. Supprimer les intentions pour libérer les ressources de type d'option.
1. Supprimez les types d'options.
Pour exécuter les commandes de cet exercice, vous devez connaître la région dans laquelle les commandes seront exécutées. Pour obtenir la liste des régions, consultez [Quotas liés à la création de modèle](gl-limits.md#gl-limits-model-building).
**Pour nettoyer votre compte (AWS CLI)**
1. Dans la ligne de AWS CLI commande, supprimez l'alias :
```
aws lex-models delete-bot-alias \
--region region \
--name PROD \
--bot-name OrderFlowersBot
```
1. Dans la ligne de AWS CLI commande, supprimez le bot :
```
aws lex-models delete-bot \
--region region \
--name OrderFlowersBot
```
1. Dans la ligne de AWS CLI commande, supprimez l'intention :
```
aws lex-models delete-intent \
--region region \
--name OrderFlowers
```
1. Depuis la ligne de AWS CLI commande, supprimez le type d'emplacement :
```
aws lex-models delete-slot-type \
--region region \
--name FlowerTypes
```
Vous avez supprimé toutes les ressources que vous avez créées et nettoyé votre compte.