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.
# Tutoriel : Création d'une API REST de calculatrice avec deux intégrations AWS de services et une intégration Lambda sans proxy
Le [Didacticiel : création d’une API REST avec une intégration Lambda sans proxy](getting-started-lambda-non-proxy-integration.md) 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 une grande partie de la configuration de l’intégration pour vous, comme l’ajout automatique des autorisations basées sur les ressources requises pour invoquer 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 didacticiel, 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 avec 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 l’entrée en tant que paramètres de chaîne de requête. (Intégration `AWS Service`)
1. En exposant une méthode `POST` sur la ressource `/calc` pour appeler la fonction Lambda, en fournissant l’entrée dans la charge utile de la demande de méthode. (Intégration `AWS Service`)
1. 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 didacticiel, vous pouvez vous reporter au [fichier de définitions OpenAPI](api-as-lambda-proxy-export-swagger-with-extensions.md) pour l’API `Calc`, que vous pouvez importer dans API Gateway en suivant les instructions de [Développez REST APIs à l'aide d'OpenAPI dans API Gateway](api-gateway-import-api.md).
**Topics**
+ [Création d’un rôle IAM assumable](#api-as-lambda-proxy-setup-iam-role-policies)
+ [Création d’une fonction Lambda `Calc`](#api-as-lambda-proxy-create-lambda-function)
+ [Test de la fonction Lambda `Calc`](#api-as-lambda-proxy-test-lambda-function-)
+ [Création d’une API `Calc`](#api-as-lambda-proxy-create-api-resources)
+ [Intégration 1 : Création d’une méthode `GET` avec des paramètres de requête pour appeler la fonction Lambda](#api-as-lambda-proxy-expose-get-method-with-query-strings-to-call-lambda-function)
+ [Intégration 2 : Création d’une méthode `POST` avec une charge utile JSON pour appeler la fonction Lambda](#api-as-lambda-proxy-expose-post-method-with-json-body-to-call-lambda-function)
+ [Intégration 3 : Création d’une méthode `GET` avec des paramètres de chemin pour appeler la fonction Lambda](#api-as-lambda-proxy-expose-get-method-with-path-parameters-to-call-lambda-function)
+ [Définitions OpenAPI de l’exemple d’API intégré avec une fonction Lambda](api-as-lambda-proxy-export-swagger-with-extensions.md)
## 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 :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Le rôle que vous créez doit disposer de l'autorisation Lambda [InvokeFunction](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). 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 politique IAM suivante :
------
#### [ JSON ]
****
```
{
"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.
1. Sélectionnez **Roles**.
1. Choisissez **Create Role (Créer le rôle)**.
1. Sous **Sélectionner un type d’entité de confiance**, choisissez **AWS Service**.
1. Sous **Choose the service that will use this role (Choisir le service qui utilisera ce rôle)**, choisissez **Lambda**.
1. Sélectionnez **Next: Permissions (Suivant : autorisations)**.
1. Choisissez **Create Policy (Créer une politique)**.
Une nouvelle fenêtre de console **Create Policy (Créer une politique)** s’ouvre. Dans cette fenêtre, procédez de la façon suivante :
1. Dans l’onglet **JSON**, remplacez la politique existante par la suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
1. Choisissez **Examiner une politique**.
1. Sous **Review Policy (Examiner une politique)**, procédez comme suit :
1. Pour **Nom**, tapez un nom, par exemple **lambda\$1execute**.
1. Choisissez **Créer une politique**.
1. 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 politiques d’autorisations)**, choisissez votre politique **lambda\$1execute** dans la liste déroulante.
Si votre politique 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.)
1. Choisissez **Next:Tags (Suivant : balises)**.
1. Choisissez **Next: Review (Suivant : vérifier)**.
1. Sous **Role name (Nom du rôle)**, saisissez un nom tel que **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Choisissez **Créer un rôle**.
1. Choisissez votre rôle **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** dans la liste.
1. Choisissez l’onglet **Trust relationships**.
1. Choisissez **Modifier la relation d’approbation**.
1. Remplacez la politique existante comme suit :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Choisissez **Update Trust Policy**.
1. 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)**.
1. Choisissez **Créer à partir de zéro**.
1. Pour **Nom**, saisissez **Calc**.
1. Pour **Exécution**, choisissez le dernier environnement d’exécution **Node.js** ou **Python** compatible.
1. Pour toutes les autres options, utilisez le paramètre par défaut.
1. Choisissez **Créer une fonction**.
1. Copiez la fonction Lambda suivante dans votre environnement d’exécution préféré et collez-la dans l’éditeur de code de la console Lambda.
------
#### [ Node.js ]
```
export const handler = async function (event, context) {
console.log("Received event:", JSON.stringify(event));
if (
event.a === undefined ||
event.b === undefined ||
event.op === undefined
) {
return "400 Invalid Input";
}
const res = {};
res.a = Number(event.a);
res.b = Number(event.b);
res.op = event.op;
if (isNaN(event.a) || isNaN(event.b)) {
return "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":
if (res.b == 0) {
return "400 Divide by Zero";
} else {
res.c = res.a / res.b;
}
break;
default:
return "400 Invalid Operator";
}
return res;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
try:
(event['a']) and (event['b']) and (event['op'])
except KeyError:
return '400 Invalid Input'
try:
res = {
"a": float(
event['a']), "b": float(
event['b']), "op": event['op']}
except ValueError:
return '400 Invalid Operand'
if event['op'] == '+':
res['c'] = res['a'] + res['b']
elif event['op'] == '-':
res['c'] = res['a'] - res['b']
elif event['op'] == '*':
res['c'] = res['a'] * res['b']
elif event['op'] == '/':
if res['b'] == 0:
return '400 Divide by Zero'
else:
res['c'] = res['a'] / res['b']
else:
return '400 Invalid Operator'
return res
```
------
1. Sous Execution role (Rôle d’exécution), choisissez **Choose an existing role (Choisir un rôle existant)**.
1. Entrez l’ARN du rôle **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** que vous avez créé précédemment.
1. 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. Choisissez l’onglet **Test**.
1. Entrez **calc2plus5** comme nom de l’événement de test.
1. Remplacez la définition de l’événement de test par ce qui suit :
```
{
"a": "2",
"b": "5",
"op": "+"
}
```
1. Choisissez **Save (Enregistrer)**.
1. Sélectionnez **Test (Tester)**.
1. 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.
**Pour créer une API**
1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. 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)**.
1. Sous **API name (Nom de l’API)**, saisissez **LambdaCalc**.
1. (Facultatif) Sous **Description**, entrez une description.
1. Laissez **Type de point de terminaison d’API** défini sur **Régional**.
1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.
1. 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 être utile, en particulier si APIs elle permet le libre accès.
Une fois que vous avez créé une API, vous créez une ressource. En règle générale, les ressources API sont organisées dans une arborescence des ressources selon la logique de l’application. Pour cette étape, vous créez une ressource **/calc.**
**Pour créer une ressource **/calc****
1. Choisissez **Créer une ressource**.
1. Maintenez **Ressource proxy** désactivée.
1. Conservez **Chemin de la ressource** sous la forme `/`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **calc**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
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 être utile, en particulier si APIs elle permet le libre accès.
Dans cette méthode, Lambda exige que la requête `POST` soit utilisée pour invoquer 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.
**Pour créer une méthode `GET`**
1. Sélectionnez la ressource **/calc**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **GET**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS**.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda.
1. Pour **Service AWS**, sélectionnez **Lambda**.
1. Laissez **Sous-domaine AWS ** vide.
1. Pour **Méthode HTTP**, sélectionnez **POST**.
1. Pour **Type d’action**, sélectionnez **Utiliser un remplacement de chemin**. Cette option nous permet de spécifier l’ARN de l’action [Invoke (Appel)](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) pour exécuter notre fonction `Calc`.
1. Pour **Remplacement de chemin**, saisissez **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Pour** *account-id***, entrez votre Compte AWS identifiant. Pour***us-east-2***, entrez l' Région AWS endroit où vous avez créé votre fonction Lambda.
1. Pour **Rôle d’exécution**, saisissez l’ARN de rôle pour **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Ne modifiez pas les paramètres de **Cache d’informations d’identification** et de **Délai d’attente par défaut**.
1. Choisissez **Paramètres de requête de méthode**.
1. Pour **Validateur de requête**, sélectionnez **Valider les paramètres de chaîne de requête et les en-têtes**.
Ce paramètre renvoie un message d’erreur si le client ne spécifie pas les paramètres requis.
1. Choisissez **Paramètres de chaîne de requête d’URL**.
Maintenant, vous allez configurer les paramètres de chaîne de requête pour la méthode **GET** sur la ressource **/calc** de sorte qu’elle reçoive l’entrée au nom de la fonction Lambda du backend.
Pour créer les paramètres de chaîne de requête, procédez comme suit :
1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).
1. Pour **Nom**, saisissez **operand1**.
1. Activez **Obligatoire**.
1. Maintenez **Mise en cache** désactivée.
Répétez les mêmes étapes et créez une chaîne de requête nommée **operand2** et une chaîne de requête nommée **operator**.
1. Choisissez **Créer une méthode**.
Maintenant, vous créez un modèle de mappage afin de convertir les chaînes de requête fournies par le client en la charge utile de requête d’intégration, comme requis par la fonction `Calc`. Ce modèle mappe les trois paramètres de chaîne de requête déclarés dans **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.
**Pour mapper les paramètres d’entrée à la requête d’intégration**
1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.
1. Pour **Transmission du corps de requête**, sélectionnez **Lorsqu’aucun modèle n’est défini (recommandé)**.
1. Choisissez **Modèles de mappage**.
1. Sélectionnez **Add mapping template**.
1. Pour **Type de contenu**, entrez **application/json**.
1. Pour **Corps du modèle**, entrez le code suivant :
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}
```
1. Choisissez **Enregistrer**.
Vous pouvez maintenant tester votre méthode `GET` pour vérifier qu’elle a été correctement configurée pour invoquer la fonction Lambda.
**Pour tester la méthode `GET`**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Pour **Chaînes de requête**, saisissez **operand1=2&operand2=3&operator=\$1**.
1. Sélectionnez **Test**.
Les résultats doivent ressembler à ce qui suit :
![\[Création d’une API dans API Gateway en tant que proxy Lambda\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_new_console.png)
## 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 créer une méthode `POST` avec une charge utile JSON**
1. Sélectionnez la ressource **/calc**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **POST**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS**.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda.
1. Pour **Service AWS**, sélectionnez **Lambda**.
1. Laissez **Sous-domaine AWS ** vide.
1. Pour **Méthode HTTP**, sélectionnez **POST**.
1. Pour **Type d’action**, sélectionnez **Utiliser un remplacement de chemin**. Cette option nous permet de spécifier l’ARN de l’action [Invoke (Appel)](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) pour exécuter notre fonction `Calc`.
1. Pour **Remplacement de chemin**, saisissez **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Pour** *account-id***, entrez votre Compte AWS identifiant. Pour***us-east-2***, entrez l' Région AWS endroit où vous avez créé votre fonction Lambda.
1. Pour **Rôle d’exécution**, saisissez l’ARN de rôle pour **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Ne modifiez pas les paramètres de **Cache d’informations d’identification** et de **Délai d’attente par défaut**.
1. Choisissez **Créer une méthode**.
Maintenant, vous créez un modèle d’**entrée** pour décrire la structure des données d’entrée et valider le corps de la requête entrante.
**Pour créer un modèle d’entrée**
1. Dans le volet de navigation principal, choisissez **Modèles**.
1. Sélectionnez **Créer un modèle**.
1. Pour **Nom**, saisissez **input**.
1. Pour **Type de contenu**, entrez **application/json**.
Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez **\$1default**.
1. Pour **Schéma du modèle**, saisissez le modèle qui suit :
```
{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}
```
1. Sélectionnez **Créer un modèle**.
Vous créez maintenant un modèle de **sortie**. 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.
**Pour créer un modèle de sortie**
1. Sélectionnez **Créer un modèle**.
1. Pour **Nom**, saisissez **output**.
1. Pour **Type de contenu**, entrez **application/json**.
Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez **\$1default**.
1. Pour **Schéma du modèle**, saisissez le modèle qui suit :
```
{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}
```
1. Sélectionnez **Créer un modèle**.
Vous créez maintenant un modèle de **résultat**. 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 d’**entrée** et de **sortie** définis dans votre API.
**Pour créer un modèle de résultat**
1. Sélectionnez **Créer un modèle**.
1. Pour **Nom**, saisissez **result**.
1. Pour **Type de contenu**, entrez **application/json**.
Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez **\$1default**.
1. Pour **Schéma du modèle**, entrez le modèle suivant avec votre*restapi-id*. Votre *restapi-id* nom est répertorié entre parenthèses en haut de la console dans le flux suivant : `API Gateway > APIs > LambdaCalc (abc123).`
```
{
"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":"result"
}
```
1. Sélectionnez **Créer un modèle**.
Vous configurez maintenant la demande de méthode de votre méthode POST pour activer la validation de la demande sur le corps de requête entrante.
**Pour activer la validation de la demande sur la méthode POST**
1. Dans le volet de navigation principal, choisissez **Ressources**, puis sélectionnez la méthode `POST` dans l’arborescence de ressources.
1. Dans l’onglet **Demande de méthode**, sous **Paramètres de requête de méthode**, choisissez **Modifier**.
1. Pour **Validateur de requête**, sélectionnez **Valider le corps**.
1. Choisissez **Corps de la requête**, puis choisissez **Ajouter un modèle**.
1. Pour **Type de contenu**, entrez **application/json**.
Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez **\$1default**.
1. Pour **Modèle**, sélectionnez **entrée**.
1. Choisissez **Enregistrer**.
Vous pouvez maintenant tester votre méthode `POST` pour vérifier qu’elle a été correctement configurée pour invoquer la fonction Lambda.
**Pour tester la méthode `POST`**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Pour **Corps de la requête**, entrez la charge utile de JSON suivante.
```
{
"a": 1,
"b": 2,
"op": "+"
}
```
1. Sélectionnez **Tester)**.
Vous devriez voir la sortie suivante :
```
{
"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.
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\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/aws_proxy_lambda_create_api_resources_new_console.png)
**Pour créer une ressource **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1****
1. Choisissez **Créer une ressource**.
1. Pour **Chemin de ressource**, sélectionnez `/calc`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **\$1operand1\$1**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
1. Pour **Chemin de ressource**, sélectionnez `/calc/{operand1}/`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **\$1operand2\$1**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
1. Pour **Chemin de ressource**, sélectionnez `/calc/{operand1}/{operand2}/`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **\$1operator\$1**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
Cette fois, vous allez utiliser l’intégration Lambda intégrée dans la console API Gateway afin de configurer l’intégration de la méthode.
**Pour configurer une intégration de méthode**
1. Sélectionnez la ressource**/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **GET**.
1. Pour **Type d’intégration**, sélectionnez **Lambda**.
1. Maintenez **Intégration proxy Lambda** désactivée.
1. Pour la **fonction Lambda**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda et entrez. **Calc**
1. Maintenez **Délai d’expiration par défaut** activé.
1. Choisissez **Créer une méthode**.
Vous créez maintenant un modèle de mappage pour mapper les trois paramètres de chemin d’URL, déclarés lors de la création de la ressource **/calc/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, aux valeurs de propriété désignées de l’objet JSON. Étant 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.
**Pour créer un modèle de mappage**
1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.
1. Pour **Transmission du corps de requête**, sélectionnez **Lorsqu’aucun modèle n’est défini (recommandé)**.
1. Choisissez **Modèles de mappage**.
1. Pour **Type de contenu**, entrez **application/json**.
1. Pour **Corps du modèle**, entrez le code suivant :
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}
```
1. Choisissez **Enregistrer**.
Vous pouvez maintenant tester votre méthode `GET` pour vérifier qu’elle a été correctement configurée pour invoquer la fonction Lambda et transmettre le résultat d’origine via la réponse d’intégration sans mappage.
**Pour tester la méthode `GET`**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Pour **Chemin**, procédez comme suit :
1. Pour **opérande 1**, saisissez **1**.
1. Pour **opérande 2**, saisissez **1**.
1. Pour **opérateur**, saisissez **\$1**.
1. Sélectionnez **Test**.
1. Le résultat doit se présenter comme suit :
![\[Testez la méthode GET dans la console API Gateway.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_path_parm_new_console.png)
Ensuite, vous modélisez la structure de données de la charge utile de réponse de méthode après le schéma `result`.
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.
**Pour créer une réponse de méthode**
1. Dans l’onglet **Méthode de réponse**, sous **Réponse 200**, choisissez **Modifier**.
1. Sous **Corps de la réponse**, choisissez **Ajouter un modèle**.
1. Pour **Type de contenu**, entrez **application/json**.
1. Pour **Modèle**, sélectionnez **Résultat**.
1. Choisissez **Enregistrer**.
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.
**Pour créer un modèle de mappage**
1. Dans l’onglet **Réponse d’intégration**, sous **Par défaut - Réponse**, choisissez **Modifier**.
1. Choisissez **Modèles de mappage**.
1. Pour **Type de contenu**, entrez **application/json**.
1. Pour **Corps du modèle**, entrez le code suivant :
```
#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}
```
1. Choisissez **Enregistrer**.
**Pour tester le modèle de mappage**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Pour **Chemin**, procédez comme suit :
1. Pour **opérande 1**, saisissez **1**.
1. Pour **opérande 2**, saisissez **2**.
1. Pour **opérateur**, saisissez **\$1**.
1. Sélectionnez **Tester)**.
1. Le résultat ressemble à ce qui suit :
```
{
"input": {
"a": 1,
"b": 2,
"op": "+"
},
"output": {
"c": 3
}
}
```
À ce stade, vous pouvez appeler l’API uniquement à l’aide de la fonctionnalité **Tester** dans la console API Gateway. Afin de la rendre disponible votre API pour les clients, vous devez la déployer. 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 fonctionnalités ou les mises à jour ne seront pas disponibles pour les clients de votre API, comme suit :
**Pour déployer l’API**
1. Sélectionnez **Deploy API (Déployer une API)**.
1. Pour **Étape**, sélectionnez **Nouvelle étape**.
1. Sous **Stage name (Nom de l’étape)**, entrez **Prod**.
1. (Facultatif) Sous **Description**, entrez une description.
1. Choisissez **Déployer**.
1. (Facultatif) Sous **Détails de l’étape**, pour **Invoquer une URL**, vous pouvez choisir l’icône de copie pour copier l’URL d’invocation de votre API. Vous pouvez l’utiliser avec des outils tels que [Postman](https://www.postman.com) et [cURL](https://curl.se/) 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.
# Définitions OpenAPI de l’exemple d’API intégré avec une fonction Lambda
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2017-04-20T04:08:08Z",
"title": "LambdaCalc"
},
"host": "uojnr9hd57.execute-api.us-east-1.amazonaws.com",
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/calc": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "query",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
},
"headers": {
"operand_1": {
"type": "string"
},
"operand_2": {
"type": "string"
},
"operator": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-request-validator": "Validate query string parameters and headers",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.operator": "integration.response.body.op",
"method.response.header.operand_2": "integration.response.body.b",
"method.response.header.operand_1": "integration.response.body.a"
},
"responseTemplates": {
"application/json": "#set($res = $input.path('$'))\n{\n \"result\": \"$res.a, $res.b, $res.op => $res.c\",\n \"a\" : \"$res.a\",\n \"b\" : \"$res.b\",\n \"op\" : \"$res.op\",\n \"c\" : \"$res.c\"\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\", \n \"op\": \"$input.params('operator')\" \n}"
},
"type": "aws"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"in": "body",
"name": "Input",
"required": true,
"schema": {
"$ref": "#/definitions/Input"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-request-validator": "Validate body",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : $inputRoot.op,\n \"c\" : $inputRoot.c\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"type": "aws"
}
}
},
"/calc/{operand1}/{operand2}/{operator}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"input\" : {\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : \"$inputRoot.op\"\n },\n \"output\" : {\n \"c\" : $inputRoot.c\n }\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\",\n \"op\": #if($input.params('operator')=='%2F')\"/\"#{else}\"$input.params('operator')\"#end\n \n}"
},
"contentHandling": "CONVERT_TO_TEXT",
"type": "aws"
}
}
}
},
"definitions": {
"Input": {
"type": "object",
"required": [
"a",
"b",
"op"
],
"properties": {
"a": {
"type": "number"
},
"b": {
"type": "number"
},
"op": {
"type": "string",
"description": "binary op of ['+', 'add', '-', 'sub', '*', 'mul', '%2F', 'div']"
}
},
"title": "Input"
},
"Output": {
"type": "object",
"properties": {
"c": {
"type": "number"
}
},
"title": "Output"
},
"Result": {
"type": "object",
"properties": {
"input": {
"$ref": "#/definitions/Input"
},
"output": {
"$ref": "#/definitions/Output"
}
},
"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}
```
------