Tutoriel : Création d'une API REST Calc avec deux intégrations de service AWS et une intégration Lambda autre que de proxy - Amazon API Gateway

Tutoriel : Création d'une API REST Calc avec deux intégrations de service AWS et une intégration Lambda autre que de proxy

Le tutoriel de prise en main de l'intégration autre que de proxy utilise exclusivement l'intégration Lambda Function. L'intégration Lambda Function est un cas particulier du type d'intégration AWS Service qui effectue la majeure partie de la configuration de l'intégration à votre place, par exemple en ajoutant automatiquement les autorisations basées sur les ressources requises pour appeler la fonction Lambda. Ici, deux des trois intégrations utilisent l'intégration AWS Service. Ce type d'intégration offre davantage de contrôle, mais vous devez exécuter manuellement les tâches telles que la création et la spécification d'un rôle IAM contenant les autorisations appropriées.

Dans ce tutoriel, vous allez créer une fonction Lambda Calc pour implémenter les opérations arithmétiques de base, en acceptant et en renvoyant des données d'entrée et de sortie au format JSON. Ensuite, vous allez créer une API REST et l'intégrer à la fonction Lambda de différentes manières :

  1. En exposant une méthode GET sur la ressource /calc pour appeler la fonction Lambda, en fournissant les données d'entrée en tant que paramètres de chaîne de requête. (Intégration AWS Service)

  2. En exposant une méthode POST sur la ressource /calc pour appeler la fonction Lambda, en fournissant les données d'entrée dans la charge utile de la demande de méthode. (Intégration AWS Service)

  3. En exposant une méthode GET sur les ressources /calc/{operand1}/{operand2}/{operator} imbriquées pour appeler la fonction Lambda, en fournissant les données d'entrée en tant que paramètres de chemin. (Intégration Lambda Function)

Outre ce tutoriel, vous pouvez vous reporter au fichier de définitions OpenAPI pour l'API Calc, que vous pouvez importer dans API Gateway en suivant les instructions de Configuration d'une API REST à l'aide d'OpenAPI.

Création d'un compte AWS

Avant de commencer ce tutoriel, vous avez besoin d'un compte AWS.

Si vous ne disposez d'aucun compte AWS, effectuez les étapes suivantes pour en créer un.

Pour s'inscrire à un compte AWS

  1. Ouvrez https://portal.aws.amazon.com/billing/signup.

  2. Suivez les instructions en ligne.

    Dans le cadre de la procédure d'inscription, vous recevrez un appel téléphonique et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

Création d'un rôle IAM assumable

Pour que votre API invoque votre fonction Lambda Calc, vous devez disposer d'un rôle IAM assumable API Gateway, qui est un rôle IAM ayant la relation de confiance suivante :

{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "apigateway.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }

Le rôle que vous créez doit avoir une autorisation Lambda InvokeFunction. Dans le cas contraire, l'appelant d'API recevra une réponse 500 Internal Server Error. Pour accorder cette autorisation au rôle, vous devez lui attacher la stratégie IAM suivante :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "*" } ] }

Voici comment procéder :

Création d'un rôle IAM assumable API Gateway

  1. Connectez-vous à la console IAM.

  2. Sélectionnez Roles.

  3. Choisissez Create Role (Créer le rôle).

  4. Sous Select type of trusted entity (Sélectionner le type d'entité de confiance), choisissez AWS service (Service AWS).

  5. Sous Choisir le service qui utilisera ce rôle, choisissez Lambda.

  6. Choisissez Next: Permissions (Suivant : Autorisations).

  7. Choisissez Create Policy (Créer une stratégie).

    Une nouvelle fenêtre de console Create Policy (Créer une stratégie) s'ouvre. Dans cette fenêtre, procédez de la façon suivante :

    1. Dans l'onglet JSON, remplacez la stratégie existante par la stratégie suivante :

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "*" } ] }
    2. Choisissez Examiner une stratégie.

    3. Sous Review Policy (Examiner une stratégie), procédez comme suit :

      1. Pour Nom, tapez un nom, par exemple lambda_execute.

      2. Choisissez Create Policy (Créer une stratégie).

  8. Dans la fenêtre de console d'origine Create Role (Créer un rôle), procédez comme suit :

    1. Sous Attach permissions policies (Attacher des stratégies d'autorisations), choisissez votre stratégie lambda_execute dans la liste déroulante.

      Si votre stratégie n'est pas répertoriée dans la liste, cliquez sur le bouton d'actualisation en haut de la liste. (N'actualisez pas la page du navigateur.)

    2. Choisissez Suivant : Balises.

    3. Choisissez Next: Review.

    4. Sous Role name (Nom du rôle), saisissez un nom tel que lambda_invoke_function_assume_apigw_role.

    5. Choisissez Create Role (Créer le rôle).

  9. Choisissez votre rôle lambda_invoke_function_assume_apigw_role dans la liste.

  10. Choisissez l'onglet Trust relationships.

  11. Choisissez Modifier la relation d'approbation.

  12. Remplacez la stratégie existante comme suit :

    { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com", "apigateway.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
  13. Choisissez Update Trust Policy.

  14. Notez l'ARN du rôle que vous venez de créer. Vous en aurez besoin ultérieurement.

Création d'une fonction Lambda Calc

Vous créerez ensuite une fonction Lambda à l'aide de la console Lambda.

  1. Dans la console Lambda, choisissez Create function (Créer une fonction).

  2. Choisissez Créer à partir de zéro.

  3. Pour Nom, entrez Calc.

  4. Définissez Exécution sur un environnement d'exécution Node.js pris en charge.

  5. Sélectionnez Create function.

  6. Copiez la fonction Lambda suivante et collez-la dans l'éditeur de code de la console Lambda.

    console.log('Loading the Calc function'); exports.handler = function(event, context, callback) { console.log('Received event:', JSON.stringify(event, null, 2)); if (event.a === undefined || event.b === undefined || event.op === undefined) { callback("400 Invalid Input"); } var res = {}; res.a = Number(event.a); res.b = Number(event.b); res.op = event.op; if (isNaN(event.a) || isNaN(event.b)) { callback("400 Invalid Operand"); } switch(event.op) { case "+": case "add": res.c = res.a + res.b; break; case "-": case "sub": res.c = res.a - res.b; break; case "*": case "mul": res.c = res.a * res.b; break; case "/": case "div": res.c = res.b===0 ? NaN : Number(event.a) / Number(event.b); break; default: callback("400 Invalid Operator"); break; } callback(null, res); };
  7. Sous Execution role (Rôle d'exécution), choisissez Choose an existing role (Choisir un rôle existant).

  8. Entrez l'ARN du rôle lambda_invoke_function_assume_apigw_role que vous avez créé précédemment.

  9. Choisissez Deploy (Déployer).

Cette fonction nécessite deux opérandes (a et b) et un opérateur (op) à partir du paramètre d'entrée event. L'entrée est un objet JSON au format suivant :

{ "a": "Number" | "String", "b": "Number" | "String", "op": "String" }

Cette fonction renvoie le résultat calculé (c) et les données d'entrée. En cas d'entrée non valide, la fonction renvoie la valeur null ou la chaîne « Opération non valide » en tant que résultat. La sortie est au format JSON suivant :

{ "a": "Number", "b": "Number", "op": "String", "c": "Number" | "String" }

Vous devez tester la fonction dans la console Lambda avant de l'intégrer à l'API dans l'étape suivante.

Test de la fonction Lambda Calc

Voici comment tester la fonction Calc dans la console Lambda :

  1. Dans le menu déroulant Saved test events (Événements de test enregistrés), choisissez Configure test events (Configurer des événements de test).

  2. Entrez calc2plus5 comme nom de l'événement de test.

  3. Remplacez la définition de l'événement de test par ce qui suit :

    { "a": "2", "b": "5", "op": "+" }
  4. Choisissez Save.

  5. Sélectionnez Test.

  6. Développez Résultat de l'exécution : réussite. Vous devez voir ce qui suit :

    { "a": 2, "b": 5, "op": "+", "c": 7 }

Création d'une API Calc

La procédure suivante explique comment créer une API pour la fonction Lambda Calc que vous venez de créer. Dans les sections suivantes, vous allez y ajouter des ressources et des méthodes.

Création de l'API Calc

  1. Connectez-vous à la console API Gateway à l'adresse https://console.aws.amazon.com/apigateway.

  2. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous REST API (API REST), choisissez Build (Création). Lorsque la fenêtre contextuelle Create Example API (Créer API exemple) s'affiche, cliquez sur OK.

    Si ce n'est pas la première fois que vous utilisez API Gateway, choisissez Create API (Créer une API). Sous REST API (API REST), choisissez Build (Création).

  3. Sous Create new API (Créer une API), choisissez New API (Nouvelle API).

  4. Sous API name (Nom de l'API), saisissez LambdaCalc.

  5. Laissez le champ Description vide, et le champ Endpoint Type (Type de point de terminaison) défini sur Regional (Régional).

  6. Sélectionnez Create API (Créer une API).

Intégration 1 : Création d'une méthode GET avec des paramètres de requête pour appeler la fonction Lambda

Lorsque vous créez une méthode GET qui transmet les paramètres de chaîne de requête à la fonction Lambda, vous permettez à l'API d'être appelée à partir d'un navigateur. Cette approche peut s'avérer utile, en particulier pour les API qui autorisent un accès ouvert.

Pour configurer la méthode GET avec les paramètres de chaîne de requête

  1. Dans la console API Gateway, sous la section Resources (Ressources) de votre API LambdaCalc, choisissez /.

  2. Dans le menu déroulant Actions, choisissez Create Resource (Créer une ressource).

  3. Sous Resource Name (Nom de la ressource), entrez calc.

  4. Choisissez Create Resource.

  5. Choisissez la ressource /calc que vous venez de créer.

  6. Dans le menu déroulant Actions, choisissez Create Method (Créer une méthode).

  7. Dans le menu déroulant Method (Méthode) qui s'affiche, choisissez GET.

  8. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

  9. Dans le volet Set up (Configuration) qui s'affiche :

    1. Pour Integration type (Type d'intégration), choisissez AWS Service (Service AWS).

    2. Pour AWS Region (Région AWS), choisissez la région (par exemple, us-west-2) où vous avez créé la fonction Lambda.

    3. Pour AWS Service (Service AWS), choisissez Lambda.

    4. Laissez AWS Subdomain (Sous-domaine AWS) vide, car notre fonction Lambda n'est pas hébergée dans un sous-domaine AWS.

    5. Pour HTTP method (Méthode HTTP), choisissez POST, puis l'icône de coche pour enregistrer votre choix. Lambda exige que la demande POST soit utilisée pour appeler une fonction Lambda. Cet exemple montre que la méthode HTTP dans une demande de méthode de serveur frontal peut être différente de la demande d'intégration sur le backend.

    6. Choisissez Use path override pour Action Type. Cette option nous permet de spécifier l'ARN de l'action Invoke (Appel) pour exécuter notre fonction Calc.

    7. Entrez /2015-03-31/functions/arn:aws:lambda:region:account-id:function:Calc/invocations dans Path override (Remplacement de chemin), où region correspond à la région dans laquelle vous avez créé votre fonction Lambda et account-id est le numéro du compte AWS.

    8. Pour Execution role (Rôle d'exécution), saisissez l'ARN du rôle IAM lambda_invoke_function_assume_apigw_role que vous avez créé précédemment.

    9. Laissez Content Handling (Gestion de contenu) défini sur Passthrough (Transmettre), car cette méthode ne traitera pas de données binaires.

    10. Laissez la case Use default timeout (Utiliser le délai d'attente par défaut) cochée.

    11. Choisissez Save.

  10. Sélectionnez Method Request.

    Maintenant, vous allez configurer les paramètres de requête pour la méthode GET sur /calc de sorte qu'elle reçoive l'entrée au nom de la fonction Lambda du backend.

    1. Choisissez l'icône en forme de crayon en regard de Request Validator (Validateur de demande) et choisissez Validate query string parameters and headers (Valider les paramètres de chaîne de requête et les en-têtes) dans le menu déroulant. Ce paramètre renvoie un message d'erreur pour indiquer que les paramètres requis sont manquants si le client ne les spécifie pas. Vous ne serez pas facturé pour l'appel vers le serveur principal.

    2. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

    3. Développez la section URL Query String Parameters.

    4. Sélectionnez Add query string.

    5. Pour Nom, tapez operand1.

    6. Sélectionnez l'icône représentant une coche pour enregistrer le paramètre.

    7. Répétez les étapes précédentes pour créer des paramètres nommés operand2 et operator.

    8. Vérifiez l'option Required pour chaque paramètre pour vous assurer qu'ils sont validés.

  11. Choisissez Method Execution (Exécution de la méthode), puis Integration Request (Demande d'intégration) pour configurer le modèle de mappage afin de convertir les chaînes de requête fournies par le client en la charge utile de demande d'intégration, comme requis par la fonction Calc.

    1. Développez la section Mapping Templates.

    2. Choisissez When no template matches the request Content-Type header (Lorsqu'aucun modèle ne correspond à l'en-tête Content-Type de la demande) pour Request body passthrough (Transmission du corps de la demande).

    3. Sous Content-Type, choisissez Add mapping template (Ajouter un modèle de mappage).

    4. Saisissez application/json, puis cliquez sur l'icône de coche pour ouvrir l'éditeur de modèle.

    5. Choisissez Yes, secure this integration pour continuer.

    6. Copiez le script de mappage suivant dans l'éditeur de modèle de mappage :

      { "a": "$input.params('operand1')", "b": "$input.params('operand2')", "op": "$input.params('operator')" }

      Ce modèle mappe les trois paramètres de chaîne de requête déclarés dans Method Request (Demande de méthode) aux valeurs de propriété désignées de l'objet JSON en tant que données d'entrée de la fonction Lambda du backend. L'objet JSON transformé sera inclus en tant que charge utile de la demande d'intégration.

    7. Choisissez Save.

  12. Sélectionnez Method Execution (Exécution de la méthode).

  13. Vous pouvez maintenant tester votre méthode GET pour vérifier qu'elle a été correctement configurée pour appeler la fonction Lambda :

    1. Pour Query Strings (Chaînes de requête), saisissez operand1=2&operand2=3&operator=+.

    2. Sélectionnez Test.

      Les résultats doivent ressembler à ce qui suit :

      
                                Création d'une API dans API Gateway en tant que proxy Lambda

Intégration 2 : Création d'une méthode POST avec une charge utile JSON pour appeler la fonction Lambda

En créant une méthode POST avec une charge utile JSON pour appeler la fonction Lambda, vous faites en sorte que le client doive fournir les données d'entrée nécessaires à la fonction du backend dans le corps de la demande. Pour vous assurer que le client charge les données d'entrée correctes, vous allez activer la validation de demande sur la charge utile.

Pour configurer la méthode POST avec une charge utile JSON pour invoquer une fonction Lambda

  1. Accédez à la console API Gateway.

  2. Choisissez APIs.

  3. Choisissez l'API LambdaCalc que vous avez créée précédemment.

  4. Choisissez la ressource /calc dans le volet Resources (Ressources).

  5. Dans le menu Actions, sélectionnez Create Method (Créer une méthode).

  6. Choisissez POST dans la liste déroulante Method (Méthode).

  7. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

  8. Dans le volet Set up (Configuration) qui s'affiche :

    1. Pour Integration type (Type d'intégration), choisissez AWS Service (Service AWS).

    2. Pour AWS Region (Région AWS), choisissez la région (par exemple, us-west-2) où vous avez créé la fonction Lambda.

    3. Pour AWS Service (Service AWS), choisissez Lambda.

    4. Laissez AWS Subdomain (Sous-domaine AWS) vide, car notre fonction Lambda n'est pas hébergée dans un sous-domaine AWS.

    5. Dans le champ HTTP Method, sélectionnez POST. Cet exemple montre que la méthode HTTP dans une demande de méthode de serveur frontal peut être différente de la demande d'intégration sur le backend.

    6. Sous Action, sélectionnez Use path override pour Action Type (Type d'action). Cette option permet de spécifier l'ARN de l'action Invoke (Appel) pour exécuter votre fonction Calc.

    7. Pour Path override (Remplacement de chemin), entrez /2015-03-31/functions/arn:aws:lambda:region:account-id:function:Calc/invocations, où region correspond à la région dans laquelle vous avez créé votre fonction Lambda et account-id est le numéro du compte AWS.

    8. Pour Execution role (Rôle d'exécution), saisissez l'ARN du rôle IAM lambda_invoke_function_assume_apigw_role que vous avez créé précédemment.

    9. Laissez Content Handling (Gestion de contenu) défini sur Passthrough (Transmettre), car cette méthode ne traitera pas de données binaires.

    10. Laissez la case Use Default Timeout (Utiliser le délai d'attente par défaut) cochée.

    11. Choisissez Enregistrer.

  9. Choisissez Models (Modèles) sous votre API LambdaCalc dans le panneau de navigation principal de la console API Gateway afin de créer des modèles de données pour l'entrée et la sortie de la méthode :

    1. Choisissez Create dans le volet Models. Tapez Input dans Model name (Nom du modèle), saisissez application/json dans Content type (Type de contenu) et copiez la définition de schéma suivante dans le champ Model schema (Schéma du modèle) :

      { "type":"object", "properties":{ "a":{"type":"number"}, "b":{"type":"number"}, "op":{"type":"string"} }, "title":"Input" }

      Ce modèle décrit la structure des données d'entrée et sera utilisé pour valider le corps de la demande entrante.

    2. Sélectionnez Create model.

    3. Choisissez Create dans le volet Models. Tapez Output dans Model name (Nom du modèle), saisissez application/json dans Content type (Type de contenu) et copiez la définition de schéma suivante dans le champ Model schema (Schéma du modèle) :

      { "type":"object", "properties":{ "c":{"type":"number"} }, "title":"Output" }

      Ce modèle décrit la structure de données de la sortie calculée à partir du serveur principal. Elle peut être utilisée pour mapper les données de réponse d'intégration à un autre modèle. Ce didacticiel s'appuie sur le comportement de transmission et n'utilise pas ce modèle.

    4. Recherchez l'ID de votre API en haut de l'écran de la console et notez-le. Il s'affiche entre parenthèses après le nom de l'API.

    5. Dans le volet Models (Modèles), choisissez Create (Créer).

    6. Entrez Result dans Model name (Nom du modèle).

    7. Entrez application/json dansContent type (Type de contenu).

    8. Copiez la définition de schéma suivante, où restapi-id est l'ID d'API REST que vous avez noté précédemment, dans la zone Model schema (Schéma du modèle) :

      { "type":"object", "properties":{ "input":{ "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/Input" }, "output":{ "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/Output" } }, "title":"Output" }

      Ce modèle décrit la structure de données des données de réponse renvoyées. Il fait référence aux schémas Input et Output définis dans l'API spécifiée (restapi-id). Là encore, ce modèle n'est pas utilisé dans ce didacticiel, car il s'appuie sur le comportement de transmission.

    9. Sélectionnez Create model.

  10. Dans le panneau de navigation principal, sous votre API LambdaCalc, sélectionnez Resources (Ressources).

  11. Dans le volet Resources (Ressources), sélectionnez la méthode POST pour votre API.

  12. Sélectionnez Method Request.

  13. Dans les paramètres de configuration Method Request, procédez comme suit pour activer la validation de demande sur le corps de demande entrante :

    1. Choisissez l'icône de crayon en regard de Request Validator pour choisir Validate body. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

    2. Développez la section Request Body et choisissez Add model

    3. Tapez application/json dans le champ de saisie Content-Type et choisissez Input dans la liste déroulante de la colonne Model name. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

  14. Pour tester votre méthode POST, procédez de la façon suivante :

    1. Sélectionnez Method Execution (Exécution de la méthode).

    2. Sélectionnez Test.

  15. Copiez la charge utile JSON suivante dans Request Body (Corps de la demande) :

    { "a": 1, "b": 2, "op": "+" }
  16. Sélectionnez Test.

    La sortie suivante doit s'afficher dans Response Body (Corps de la demande) :

    { "a": 1, "b": 2, "op": "+", "c": 3 }

Intégration 3 : Création d'une méthode GET avec des paramètres de chemin pour appeler la fonction Lambda

Vous allez maintenant créer une méthode GET sur une ressource spécifiée par une séquence de paramètres de chemin pour appeler la fonction Lambda du backend. Les valeurs de paramètre de chemin spécifient les données d'entrée de la fonction Lambda. Vous allez utiliser un modèle de mappage afin de mapper les valeurs de paramètres de chemin entrantes à la charge utile de demande d'intégration requise.

Cette fois, vous allez utiliser la prise en charge de l'intégration Lambda intégrée dans la console API Gateway afin de configurer l'intégration de la méthode.

La structure de ressource d'API qui en résulte ressemble à ce qui suit :


                Création d'une API dans API Gateway en tant que proxy Lambda

Pour configurer une méthode GET avec des paramètres de chemin d'URL

  1. Accédez à la console API Gateway.

  2. Sous APIs, choisissez l'API LambdaCalc que vous avez créée précédemment.

  3. Dans le volet de navigation Resources (Ressources) de l'API, choisissez /calc.

  4. Dans le menu déroulant Actions, choisissez Create Resource (Créer une ressource).

  5. Pour Resource Name (Nom de la ressource), saisissez {operand1}.

  6. Pour Resource Path (Chemin d'accès à la ressource), entrez {operand1}.

  7. Choisissez Create Resource.

  8. Choisissez la ressource /calc/{operand1} que vous venez de créer.

  9. Dans le menu déroulant Actions, choisissez Create Resource (Créer une ressource).

  10. Pour Resource Name (Nom de la ressource), saisissez {operand2}.

  11. Pour Resource Path (Chemin d'accès à la ressource), entrez {operand2}.

  12. Choisissez Create Resource.

  13. Choisissez la ressource /calc/{operand1}/{operand2} que vous venez de créer.

  14. Dans le menu déroulant Actions, choisissez Create Resource (Créer une ressource).

  15. Pour Resource Path (Chemin d'accès à la ressource), entrez {operator}.

  16. Pour Resource Name (Nom de la ressource), saisissez {operator}.

  17. Choisissez Create Resource.

  18. Choisissez la ressource /calc/{operand1}/{operand2}/{operator} que vous venez de créer.

  19. Dans le menu déroulant Actions, sélectionnez Create Method (Créer une méthode).

  20. Choisissez GET dans le menu déroulant de la méthode.

  21. Dans le volet Setup, choisissez la valeur Lambda Function pour l'option Integration type, afin d'utiliser le processus de configuration rationalisé activé par la console.

  22. Choisissez une région (par exemple, us-west-2) pour Lambda Region (Région Lambda). Il s'agit de la région dans laquelle la fonction Lambda est hébergée.

  23. Choisissez votre fonction Lambda existante (Calc) pour Lambda Function (Fonction Lambda).

  24. Choisissez Save, OK pour approuver Add Permissions to Lambda Function.

  25. Sélectionnez Integration Request.

  26. Configurez le modèle de mappage comme suit :

    1. Développez la section Mapping Templates.

    2. Conservez la valeur When no template matches the requested Content-Type header (Quand aucun modèle ne correspond à l'en-tête Content-Type demandé).

    3. Sélectionnez Add mapping template.

    4. Tapez application/json pour Content-Type, puis choisissez l'icône de coche pour ouvrir l'éditeur de modèle.

    5. Choisissez Yes, secure this integration pour continuer.

    6. Copiez le script de mappage suivant dans l'éditeur de modèle :

      { "a": "$input.params('operand1')", "b": "$input.params('operand2')", "op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end }

      Ce modèle mappe les trois paramètres de chemin d'URL, déclarés lors de la création de la ressource /calc/{operand1}/{operand2}/{operator}, aux valeurs de propriété désignées de l'objet JSON. Etant donné que les chemins d'URL doivent être codés en URL, l'opérateur de division doit être spécifié sous la forme %2F au lieu de /. Ce modèle convertit %2F en '/' avant de le transmettre à la fonction Lambda.

    7. Choisissez Enregistrer.

    Quand la méthode est configurée correctement, les paramètres doivent plus ou moins ressembler à ce qui suit :

    
                        Configuration de la méthode GET avec des paramètres de chemin pour appeler la fonction Lambda
  27. Pour tester votre méthode GET, procédez de la façon suivante :

    1. Sélectionnez Method Execution (Exécution de la méthode).

    2. Sélectionnez Test.

    3. Saisissez 1, 1 et + dans les champs {operand1}, {operand2} et {operator}, respectivement.

    4. Sélectionnez Test.

    5. Le résultat doit se présenter comme suit :

      
                                Mappage des paramètres de chemin d'URL d'une demande de méthode à la charge utile de demande d'intégration pour appeler la fonction Lambda

    Le résultat de ce test montre la sortie d'origine de la fonction Lambda du backend, telle qu'elle a été transmise via la réponse d'intégration sans mappage, car il n'existe pas de modèle de mappage. Ensuite, vous allez modéliser la structure de données de la charge utile de réponse de méthode après le schéma Result.

  28. Par défaut, un modèle vide est attribué au corps de réponse de méthode. Cela entraînera la transmission du corps de réponse d'intégration sans mappage. Cependant, lorsque vous générez un kit SDK pour l'un des langages fortement typés, comme Java ou Objective-C, les utilisateurs de votre kit SDK recevront un objet vide comme résultat. Pour vous assurer que le client REST et les clients SDK reçoivent les résultats escomptés, vous devez modéliser les données de réponse à l'aide d'un schéma prédéfini. Ici, vous allez définir un modèle pour le corps de réponse de méthode et construire un modèle de mappage pour traduire le corps de réponse d'intégration en corps de réponse de méthode.

    1. Choisissez /calc/{operand1}/{operand2}/{operator}.

    2. Choisissez GET.

    3. Sélectionnez Method Execution (Exécution de la méthode).

    4. Sélectionnez Method Response (Réponse de méthode).

    5. Développez la réponse 200,

    6. Sous Response Body for 200 (Corps de la réponse pour 200), choisissez l'icône de crayon en regard du modèle pour le type de contenu application/json.

    7. Dans la liste déroulante Models (Modèles), choisissez Result.

    8. Pour enregistrer votre choix, sélectionnez l'icône représentant une coche.

    La définition du modèle pour le corps de réponse de méthode garantit que les données de réponse seront intégrées dans l'objet Result d'un kit SDK donné. Pour vous assurer que les données de réponse d'intégration sont mappées en conséquence, un modèle de mappage est nécessaire.

  29. Pour créer le modèle de mappage, procédez comme suit :

    1. Sélectionnez Method Execution (Exécution de la méthode).

    2. Choisissez Integration Response et développez l'entrée de réponse de méthode 200.

    3. Développez la section Mapping Templates.

    4. Choisissez application/json dans la liste Content-Type.

    5. Choisissez Result dans la liste déroulante Generate template pour afficher le plan de modèle Result.

    6. Modifiez le plan du modèle comme suit :

      #set($inputRoot = $input.path('$')) { "input" : { "a" : $inputRoot.a, "b" : $inputRoot.b, "op" : "$inputRoot.op" }, "output" : { "c" : $inputRoot.c } }
    7. Choisissez Save.

  30. Pour tester le modèle de mappage, procédez comme suit :

    1. Sélectionnez Method Execution (Exécution de la méthode).

    2. Sélectionnez Test.

    3. Saisissez 1, 2 et + dans les champs de saisie operand1, operand2 et operator, respectivement.

      La réponse d'intégration reçue de la fonction Lambda est maintenant mappée à un objet Result.

    4. Choisissez Test. Les résultats suivants s'affichent sous Response Body (Corps de la réponse) dans la console :

      { "input": { "a": 1, "b": 2, "op": "+" }, "output": { "c": 3 } }
  31. À ce stade, l'API peut être appelée uniquement par le biais de Test Invoke (Test d'appel) dans la console API Gateway. Afin de la rendre disponible pour les clients, vous devez la déployer comme suit :

    1. Dans le menu déroulant Actions, choisissez Deploy API (Déployer l'API).

    2. Choisissez [New Stage] (nouvelle étape) dans le menu déroulant Deployment Stage (Étape de déploiement).

    3. Sous Stage name (Nom de l'étape), entrez test.

    4. Choisissez Deploy (Déployer).

    5. Notez la valeur de Invoke URL en haut de la fenêtre de la console. Vous pouvez l'utiliser avec des outils tels que Postman et cURL pour tester votre API.

Note

Veillez toujours à redéployer votre API chaque fois que vous ajoutez, modifiez ou supprimez une ressource ou une méthode, mettez à jour un mappage de données ou mettez à jour des paramètres d'étape. Sinon, les nouvelles fonctions ou les mises à jour ne seront pas disponibles pour les clients de votre API.