

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.

# Création d'une AWS Lambda fonction pour votre bot Amazon Lex V2
<a name="lambda-attach"></a>

Pour créer une fonction Lambda pour votre bot Amazon Lex V2, accédez AWS Lambda à votre AWS Management Console et créez une nouvelle fonction. Vous pouvez consulter le [guide du AWS Lambda développeur](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) pour plus de détails surAWS Lambda.

1. Connectez-vous à l'AWS Management Console et ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Choisissez **Fonctions** dans la barre latérale gauche.

1. Sélectionnez **Create function (Créer une fonction)**.

1. Vous pouvez sélectionner **Auteur à partir de zéro** pour commencer avec un minimum de code, **utiliser un plan** pour sélectionner un exemple de code pour les cas d'utilisation courants dans une liste, ou une **image de conteneur** pour sélectionner une image de conteneur à déployer pour votre fonction. Si vous sélectionnez **Auteur à partir de zéro**, procédez comme suit :

   1. Donnez à votre fonction un **nom de fonction** significatif pour décrire ce qu'elle fait.

   1. Choisissez une langue dans le menu déroulant sous **Runtime** pour y écrire votre fonction.

   1. Sélectionnez une **architecture de jeu d'**instructions pour votre fonction.

   1. Par défaut, Lambda crée un rôle avec des autorisations de base. Pour utiliser un rôle existant ou pour créer un rôle à l'aide de modèles de politique AWS, élargissez le menu **Modifier le rôle d'exécution par défaut** et sélectionnez une option.

   1. Développez le menu **Paramètres avancés** pour configurer d'autres options.

1. Sélectionnez **Create function (Créer une fonction)**.

L'image suivante montre ce que vous voyez lorsque vous créez une nouvelle fonction à partir de zéro :

![\[Une nouvelle fonction Lambda.\]](http://docs.aws.amazon.com/fr_fr/lexv2/latest/dg/images/lambda/lambda-new-function.png)


La fonction du gestionnaire Lambda varie en fonction de la langue que vous utilisez. Il prend au minimum un objet `event` JSON comme argument. Vous pouvez voir les champs fournis par Amazon Lex V2 à l'adresse[AWS Lambdaformat d'événement d'entrée pour Lex V2](lambda-input-format.md). `event` Modifiez la fonction de gestion pour finalement renvoyer un objet `response` JSON correspondant au format décrit dans[AWS Lambdaformat de réponse pour Lex V2](lambda-response-format.md).
+ Une fois que vous avez terminé d'écrire votre fonction, sélectionnez **Déployer** pour autoriser l'utilisation de la fonction.

N'oubliez pas que vous pouvez associer chaque alias de bot à au plus une fonction Lambda. Cependant, vous pouvez définir autant de fonctions que nécessaire pour votre bot dans le code Lambda et appeler ces fonctions dans la fonction du gestionnaire Lambda. Par exemple, alors que toutes les intentions d'un même alias de bot doivent appeler la même fonction Lambda, vous pouvez créer une fonction de routeur qui active une fonction distincte pour chaque intention. Voici un exemple de fonction de routeur que vous pouvez utiliser ou modifier pour votre application :

```
import os
import json
import boto3

# reuse client connection as global
client = boto3.client('lambda')

def router(event):
    intent_name = event['sessionState']['intent']['name']
    fn_name = os.environ.get(intent_name)
    print(f"Intent: {intent_name} -> Lambda: {fn_name}")
    if (fn_name):
        # invoke lambda and return result
        invoke_response = client.invoke(FunctionName=fn_name, Payload = json.dumps(event))
        print(invoke_response)
        payload = json.load(invoke_response['Payload'])
        return payload
    raise Exception('No environment variable for intent: ' + intent_name)

def lambda_handler(event, context):
    print(event)
    response = router(event)
    return response
```

**Quand utiliser les AWS Lambda fonctions dans les conversations avec un bot Amazon Lex V2**

Vous pouvez utiliser les fonctions Lambda aux points suivants lors d'une conversation avec un utilisateur :
+ Dans la réponse initiale, une fois l'intention reconnue. Par exemple, une fois que l'utilisateur a indiqué vouloir commander une pizza.
+ Après avoir obtenu une valeur de slot auprès de l'utilisateur. Par exemple, une fois que l'utilisateur a indiqué au bot la taille de la pizza qu'il souhaite commander.
+ Entre chaque nouvelle tentative pour obtenir un emplacement. Par exemple, si le client n'utilise pas une taille de pizza reconnue.
+ Lors de la confirmation d'une intention. Par exemple, lors de la confirmation d'une commande de pizza.
+ Pour réaliser une intention. Par exemple, pour commander une pizza.
+ Une fois l'intention atteinte, et avant que votre bot ne ferme la conversation. Par exemple, pour passer à l'intention de commander un verre.

**Topics**
+ [Associer une AWS Lambda fonction à un bot Amazon Lex V2 à l'aide de la console](lambda-attach-console.md)
+ [Associer une AWS Lambda fonction à un bot Amazon Lex V2 à l'aide des opérations d'API](lambda-attach-api.md)

# Associer une AWS Lambda fonction à un bot Amazon Lex V2 à l'aide de la console
<a name="lambda-attach-console"></a>

Vous devez d'abord associer une fonction Lambda à l'alias de votre bot Amazon Lex V2 avant de pouvoir l'invoquer. Vous ne pouvez associer qu'une seule fonction Lambda à chaque alias de bot. Procédez comme suit pour associer la fonction Lambda à l'aide de la console AWS. 

1. Connectez-vous à la console de gestion AWS et ouvrez la console Amazon Lex à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Choisissez **Bots** dans le panneau de gauche et dans la liste des robots, choisissez le nom du bot auquel vous souhaitez associer une fonction Lambda.

1. Dans le panneau de gauche, sélectionnez **Alias** dans le menu **Déploiement**.

1. Dans la liste des alias, choisissez le nom de l'alias auquel vous souhaitez associer une fonction Lambda.

1. Dans le panneau **Langues**, sélectionnez la langue dans laquelle vous souhaitez utiliser une fonction Lambda. Sélectionnez **Gérer les langues dans un alias** pour ajouter une langue si elle n'est pas présente dans le panneau.

1. Dans le menu déroulant **Source**, choisissez le nom de la fonction Lambda que vous souhaitez associer.

1. Dans le menu déroulant **Version ou alias de la fonction Lambda**, choisissez la version ou l'alias de la fonction Lambda que vous souhaitez utiliser. Sélectionnez ensuite **Save (Enregistrer)**. La même fonction Lambda est utilisée à toutes fins utiles dans un langage pris en charge par le bot.

**Configuration de l'intention d'Amazon Lex V2 d'appeler une fonction Lambda à l'aide de la console**

1. Après avoir sélectionné un bot, sélectionnez **Intents** dans le menu de gauche sous la langue du bot pour lequel vous souhaitez appeler la fonction Lambda.

1. Choisissez l'intention dans laquelle vous souhaitez appeler la fonction Lambda pour ouvrir l'éditeur d'intention.

1. Il existe deux options pour configurer le crochet de code Lambda :

   1. Pour appeler la fonction Lambda après chaque étape de la conversation, accédez à la section **Code hooks** en bas de l'éditeur d'intention et cochez la case **Utiliser une fonction Lambda pour l'initialisation et la validation**, comme dans l'image suivante :  
![\[Section des crochets de code de l'éditeur d'intention Amazon Lex V2.\]](http://docs.aws.amazon.com/fr_fr/lexv2/latest/dg/images/lambda/lambda-code-hooks-all.png)

   1. Vous pouvez également utiliser la section **Dialog code hook** dans les étapes de conversation au cours desquelles vous pouvez invoquer la fonction Lambda. La section **Dialog Code Hook** apparaît comme suit :  
![\[Section des crochets de code de l'éditeur d'intention Amazon Lex V2.\]](http://docs.aws.amazon.com/fr_fr/lexv2/latest/dg/images/lambda/lambda-code-hook-step.png)

      Il existe deux méthodes pour contrôler la manière dont Amazon Lex V2 appelle le code hook pour obtenir une réponse :
      + Activez le bouton **Actif** pour le marquer comme *actif* ou *inactif*. Lorsqu'un crochet de code est *actif*, Amazon Lex V2 l'appelle. Lorsque le crochet de code est *inactif*, Amazon Lex V2 n'exécute pas le crochet de code.
      + **Développez la section **relative au crochet de code de la boîte de dialogue** **Lambda et cochez la case Invoke Lambda function** pour la marquer comme activée ou désactivée.** Vous ne pouvez activer ou désactiver un crochet de code que lorsqu'il est marqué comme actif. Lorsqu'il est marqué comme *activé*, le crochet de code est exécuté normalement. Lorsqu'il est *désactivé*, le crochet de code n'est pas appelé et Amazon Lex V2 agit comme si le crochet de code avait été renvoyé correctement. Pour configurer les réponses une fois que le crochet de code de la boîte de dialogue a réussi, échoué ou expiré, sélectionnez Options **avancées**

      Le crochet de code Lambda peut être invoqué aux étapes de conversation suivantes :
      + Pour appeler la fonction comme **réponse initiale**, accédez à la section **Réponse initiale**, déployez la flèche à côté de **Réponse pour accuser réception de la demande de l'utilisateur**, puis sélectionnez **Options avancées**. Recherchez la section **Dialog code hook** en bas du menu qui apparaît.
      + Pour appeler la fonction après avoir sélectionné un **emplacement, faites défiler** l'écran jusqu'à la section **Machines** à sous, déployez la flèche à côté de l'**invite correspondant à l'emplacement**, puis sélectionnez Options **avancées**. Recherchez la section **Dialog code hook** en bas du menu qui apparaît, juste au-dessus des **valeurs par défaut**.

        Vous pouvez également invoquer la fonction après chaque élicitation. Pour ce faire, développez les **informations Bot Elicits** dans la section **Slot invites**, sélectionnez **Plus d'options d'invite** et cochez la case à côté de Invoke **Lambda code** hook après chaque sollicitation.
      + Pour appeler la fonction de **confirmation de l'intention**, accédez à la section **Confirmation**, déployez la flèche à côté de **Invites de confirmation de l'intention**, puis sélectionnez **Options avancées**. Recherchez la section **Dialog code hook** en bas du menu qui apparaît.
      + Pour appeler la fonction d'**exécution des intentions**, faites défiler la page jusqu'à la section **Exécution**. *Activez le bouton **Active** pour activer le crochet de code.* Déplacez la flèche à **côté de En cas d'expédition réussie**, puis sélectionnez **Options avancées**. *Cochez la case à côté de **Utiliser une fonction Lambda pour l'expédition dans la section Fulfillment** **Lambda code hook** pour activer le crochet de code.*

1. Une fois que vous avez défini les étapes de conversation auxquelles vous souhaitez invoquer la fonction Lambda, **créez** à nouveau le bot pour tester la fonction.

# Associer une AWS Lambda fonction à un bot Amazon Lex V2 à l'aide des opérations d'API
<a name="lambda-attach-api"></a>

Vous devez d'abord associer une fonction Lambda à l'alias de votre bot Amazon Lex V2 avant de pouvoir l'invoquer. Vous ne pouvez associer qu'une seule fonction Lambda à chaque alias de bot. Procédez comme suit pour associer la fonction Lambda à l'aide d'opérations d'API. 

Si vous créez un nouvel alias de bot, utilisez l'[CreateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotAlias.html)opération pour associer une fonction Lambda. Pour associer une fonction Lambda à un alias de bot existant, utilisez l'[UpdateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateBotAlias.html)opération. Modifiez le `botAliasLocaleSettings` champ pour qu'il contienne les paramètres appropriés :

```
{
    "botAliasLocaleSettings" : {
        locale: {
            "codeHookSpecification": {
                "lambdaCodeHook": {
                    "codeHookInterfaceVersion": "1.0",
                    "lambdaARN": "arn:aws:lambda:region:account-id:function:function-name"
                }
            },
            "enabled": true
        },
        ...
    }
}
```

1. Le `botAliasLocaleSettings` champ correspond à un objet dont les clés sont les paramètres régionaux auxquels vous souhaitez associer la fonction Lambda. Consultez [Langues et paramètres régionaux pris en charge](how-languages.md#supported-languages) la liste des paramètres régionaux pris en charge et les codes des clés valides.

1. `lambdaARN`Pour rechercher une fonction Lambda, ouvrez la AWS Lambda console d'[https://console.aws.amazon.com/lambda/accueil](https://console.aws.amazon.com/lambda/home), sélectionnez **Fonctions** dans la barre latérale gauche, puis sélectionnez la fonction à associer à l'alias du bot. Sur le côté droit de la **vue d'ensemble des fonctions**, trouvez le `lambdaARN` sous-onglet **Function ARN**. Il doit contenir une région, un identifiant de compte et le nom de la fonction.

1. Pour permettre à Amazon Lex V2 d'appeler la fonction Lambda pour l'alias, définissez le `enabled` champ sur. `true`

**Définition de l'intention d'Amazon Lex V2 d'invoquer une fonction Lambda à l'aide d'opérations d'API**

Pour configurer l'invocation de la fonction Lambda lors d'une intention, utilisez l'[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)opération si vous créez une nouvelle intention ou l'[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)opération si vous appelez la fonction dans une intention existante. Les champs qui contrôlent l'invocation de la fonction Lambda dans les opérations d'intention sont`dialogCodeHook`,`initialResponseSetting`, `intentConfirmationSetting` et. `fulfillmentCodeHook`

Si vous invoquez la fonction pendant l'élicitation d'un emplacement, utilisez l'[CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)opération si vous créez un nouvel emplacement ou l'[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)opération pour appeler la fonction dans un emplacement existant. Le champ qui contrôle l'invocation de la fonction Lambda dans les opérations de slot est celui `slotCaptureSetting` de l'objet. `valueElicitationSetting`

1. Pour configurer le crochet de code de la boîte de dialogue Lambda pour qu'il s'exécute après chaque tour de conversation, définissez le `enabled` champ de l'[DialogCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookSettings.html)objet suivant dans le `dialogCodeHook` champ comme suit : `true`

   ```
   "dialogCodeHook": {
       "enabled": boolean
   }
   ```

1. Vous pouvez également configurer le crochet de code de la boîte de dialogue Lambda pour qu'il ne s'exécute qu'à des moments spécifiques des conversations en modifiant le `codeHook` and/or `elicitationCodeHook` champ des structures correspondant aux étapes de conversation auxquelles vous souhaitez appeler la fonction. Pour utiliser le crochet de code de la boîte de dialogue Lambda pour répondre à une intention, utilisez le `fulfillmentCodeHook` champ dans l'opération [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)ou [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html). Les structures et les utilisations de ces trois types de code hooks sont les suivantes :

## Crochet à code
<a name="lambda-code-hook"></a>

Le `codeHook` champ définit les paramètres du crochet de code à exécuter à un stade donné de la conversation. Il s'agit d'un [DialogCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookInvocationSetting.html)objet dont la structure est la suivante :

```
"codeHook": {
    "active": boolean,
    "enableCodeHookInvocation": boolean,
    "invocationLabel": string,
    "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
}
```
+ Modifiez le `active` champ `true` pour qu'Amazon Lex V2 appelle le code hook à ce stade de la conversation.
+ Modifiez le `enableCodeHookInvocation` champ `true` pour Amazon Lex V2 afin de permettre au crochet de code de s'exécuter normalement. Si vous le marquez`false`, Amazon Lex V2 agit comme si le code hook avait été renvoyé avec succès.
+ `invocationLabel`Indique l'étape de dialogue à partir de laquelle le crochet de code est invoqué.
+ Utilisez le `postCodeHookSpecification` champ pour spécifier les actions et les messages qui se produisent après la réussite, l'échec ou l'expiration du délai d'expiration du crochet de code.

## elicitationCodeHook
<a name="lambda-elicitation-code-hook"></a>

Le `elicitationCodeHook` champ définit les paramètres du crochet de code à exécuter dans le cas où un ou plusieurs emplacements doivent être réactivés. Ce scénario peut se produire si l'obtention d'un créneau échoue ou si la confirmation de l'intention est refusée. Le `elicitationCodeHook` champ est un [ElicitationCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ElicitationCodeHookInvocationSetting.html)objet dont la structure est la suivante :

```
"elicitationCodeHook": {
    "enableCodeHookInvocation": boolean,
    "invocationLabel": string
}
```
+ Modifiez le `enableCodeHookInvocation` champ `true` pour Amazon Lex V2 afin de permettre au crochet de code de s'exécuter normalement. Si vous le marquez`false`, Amazon Lex V2 agit comme si le code hook avait été renvoyé avec succès.
+ `invocationLabel`Indique l'étape de dialogue à partir de laquelle le crochet de code est invoqué.

## fulfillmentCodeHook
<a name="lambda-fulfillment-code-hook"></a>

Le `fulfillmentCodeHook` champ définit les paramètres du crochet de code à exécuter pour répondre à l'intention. Il correspond à l'[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)objet suivant :

```
"fulfillmentCodeHook": {
    "active": boolean,
    "enabled": boolean,
    "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```
+ Modifiez le `active` champ `true` pour qu'Amazon Lex V2 appelle le code hook à ce stade de la conversation.
+ Modifiez le `enabled` champ `true` pour Amazon Lex V2 afin de permettre au crochet de code de s'exécuter normalement. Si vous le marquez`false`, Amazon Lex V2 agit comme si le code hook avait été renvoyé avec succès.
+ Utilisez le `fulfillmentUpdatesSpecification` champ pour spécifier les messages qui semblent informer l'utilisateur lors de la réalisation de l'intention et le moment qui leur est associé.
+ Utilisez le `postFulfillmentStatusSpecification` champ pour spécifier les messages et les actions qui se produisent après la réussite, l'échec ou l'expiration du délai d'expiration du crochet de code.

Vous pouvez invoquer le crochet de code Lambda aux points suivants d'une conversation en définissant les `enabled` champs `active` et`enableCodeHookInvocation`/sur : `true`

## Lors de la réponse initiale
<a name="lambda-hook-initial-response"></a>

Pour appeler la fonction Lambda dans la réponse initiale une fois l'intention reconnue, utilisez la `codeHook` structure dans le `initialResponse` champ de l'opération [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)or [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html). Le `initialResponse` champ correspond à l'[InitialResponseSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_InitialResponseSetting.html)objet suivant :

```
"initialResponse": {
    "codeHook": {
        "active": boolean,
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "initialResponse": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "nextStep": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
    "conditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html)
}
```

## Après l'obtention des créneaux ou pendant la réélection des créneaux
<a name="lambda-hook-elicit-slot"></a>

Pour appeler la fonction Lambda après avoir obtenu une valeur d'emplacement, utilisez le `slotCaptureSetting` champ situé dans le `valueElicitation` champ de l'opération or. [CreateSlot[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html) Le `slotCaptureSetting` champ correspond à l'[SlotCaptureSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SlotCaptureSetting.html)objet suivant :

```
"slotCaptureSetting": {
    "captureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "captureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "captureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
    "codeHook": {
        "active": true,
        "enableCodeHookInvocation": true,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "elicitationCodeHook": {
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string
    },
    "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html)
}
```
+ Pour appeler la fonction Lambda une fois que l'élicitation des emplacements est réussie, utilisez le champ. `codeHook`
+ Pour appeler la fonction Lambda après l'échec de l'élicitation des emplacements et qu'Amazon Lex V2 tente à nouveau de les activer, utilisez le champ. `elicitationCodeHook`

## Après confirmation ou refus de l'intention
<a name="lambda-hook-confirm-intent"></a>

Pour appeler la fonction Lambda lors de la confirmation d'une intention, utilisez le `intentConfirmationSetting` champ de l'opération [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)or [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html). Le `intentConfirmation` champ correspond à l'[IntentConfirmationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_IntentConfirmationSetting.html)objet suivant :

```
"intentConfirmationSetting": {
    "active": boolean,
    "codeHook": {
        "active": boolean,
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
        "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
    },
    "confirmationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "confirmationNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "confirmationResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialResponseSpecificationogState.html),
    "declinationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "declinationNextStep": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "declinationResponse": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
    "elicitationCodeHook": {
        "enableCodeHookInvocation": boolean,
        "invocationLabel": string,
    },
    "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
    "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
    "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
    "promptSpecification": [PromptSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PromptSpecification.html)
}
```
+ Pour appeler la fonction Lambda une fois que l'utilisateur a confirmé l'intention et ses emplacements, utilisez le `codeHook` champ.
+ Pour appeler la fonction Lambda une fois que l'utilisateur a refusé la confirmation de l'intention et qu'Amazon Lex V2 a tenté à nouveau d'obtenir des emplacements, utilisez le champ. `elicitationCodeHook`

## Pendant la réalisation de l'intention
<a name="lambda-hook-fulfill-intent"></a>

Pour appeler la fonction Lambda afin de répondre à une intention, utilisez le `fulfillmentCodeHook` champ dans l'opération [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)or [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html). Le `fulfillmentCodeHook` champ correspond à l'[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)objet suivant :

```
{
    "active": boolean,
    "enabled": boolean,
    "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
    "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```

3. Une fois que vous avez défini les étapes de conversation auxquelles vous devez invoquer la fonction Lambda, utilisez l'`BuildBotLocale`opération pour reconstruire le bot afin de tester la fonction.