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.
# Exemples d’utilisation de variables pour transformer des modèles de mappage pour API Gateway
Les exemples suivants montrent comment utiliser les variables `$context`, `input` et `util` dans des modèles de mappage. Vous pouvez utiliser une intégration simulée ou une intégration Lambda sans proxy qui renvoie l’événement d’entrée dans API Gateway. Pour obtenir la liste de toutes les variables prises en charge pour les transformations de données, consultez [Variables pour les transformations de données pour API Gateway](api-gateway-mapping-template-reference.md).
## Exemple 1 : transmission de plusieurs variables `$context` au point de terminaison d’intégration
L’exemple suivant illustre un modèle de mappage qui mappe les variables `$context` entrantes aux variables de backend avec des noms légèrement différents dans une charge utile de la demande d’intégration :
```
{
"stage" : "$context.stage",
"request_id" : "$context.requestId",
"api_id" : "$context.apiId",
"resource_path" : "$context.resourcePath",
"resource_id" : "$context.resourceId",
"http_method" : "$context.httpMethod",
"source_ip" : "$context.identity.sourceIp",
"user-agent" : "$context.identity.userAgent",
"account_id" : "$context.identity.accountId",
"api_key" : "$context.identity.apiKey",
"caller" : "$context.identity.caller",
"user" : "$context.identity.user",
"user_arn" : "$context.identity.userArn"
}
```
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{
stage: 'prod',
request_id: 'abcdefg-000-000-0000-abcdefg',
api_id: 'abcd1234',
resource_path: '/',
resource_id: 'efg567',
http_method: 'GET',
source_ip: '192.0.2.1',
user-agent: 'curl/7.84.0',
account_id: '111122223333',
api_key: 'MyTestKey',
caller: 'ABCD-0000-12345',
user: 'ABCD-0000-12345',
user_arn: 'arn:aws:sts::111122223333:assumed-role/Admin/carlos-salazar'
}
```
L’une des variables est une clé d’API. Dans cet exemple, on suppose que la méthode exige une clé d’API.
## Exemple 2 : transmission de tous les paramètres de la demande au point de terminaison d’intégration via des données utiles JSON
L’exemple suivant transmet tous les paramètres de la demande, y compris les paramètres `path`, `querystring` et `header`, au point de terminaison d’intégration via des données utiles JSON :
```
#set($allParams = $input.params())
{
"params" : {
#foreach($type in $allParams.keySet())
#set($params = $allParams.get($type))
"$type" : {
#foreach($paramName in $params.keySet())
"$paramName" : "$util.escapeJavaScript($params.get($paramName))"
#if($foreach.hasNext),#end
#end
}
#if($foreach.hasNext),#end
#end
}
}
```
Si une demande possède les paramètres d’entrée suivants :
+ Paramètre de chemin nommé `myparam`
+ Paramètres des chaînes de demande `querystring1=value1,value2`
+ En-têtes `"header1" : "value1"`.
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{"params":{"path":{"example2":"myparamm"},"querystring":{"querystring1":"value1,value2"},"header":{"header1":"value1"}}}
```
## Exemple 3 : transmission d’une sous-section d’une demande de méthode au point de terminaison d’intégration
L’exemple suivant utilise le paramètre d’entrée `name` pour récupérer uniquement le paramètre `name`, et le paramètre d’entrée `input.json('$')` pour récupérer l’intégralité du corps de la demande de méthode :
```
{
"name" : "$input.params('name')",
"body" : $input.json('$')
}
```
Pour une demande qui inclut les paramètres de chaîne de demande `name=Bella&type=dog` et le corps suivant :
```
{
"Price" : "249.99",
"Age": "6"
}
```
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{
"name" : "Bella",
"body" : {"Price":"249.99","Age":"6"}
}
```
Ce modèle de mappage supprime le paramètre de chaîne de requête `type=dog`.
Si l'entrée JSON contient des caractères non échappés qui ne peuvent pas être analysés JavaScript, API Gateway peut renvoyer une réponse 400. Appliquez `$util.escapeJavaScript($input.json('$'))` pour que les données d’entrée JSON puissent être analysées correctement.
L’exemple précédent avec application de `$util.escapeJavaScript($input.json('$'))` est le suivant :
```
{
"name" : "$input.params('name')",
"body" : "$util.escapeJavaScript($input.json('$'))"
}
```
Dans ce cas, le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{
"name" : "Bella",
"body": {"Price":"249.99","Age":"6"}
}
```
## Exemple 4 : Utiliser une JSONPath expression pour transmettre une sous-section d'une demande de méthode au point de terminaison d'intégration
L'exemple suivant utilise les JSONPath expressions pour récupérer uniquement le paramètre d'entrée `name` et le contenu `Age` du corps de la demande :
```
{
"name" : "$input.params('name')",
"body" : $input.json('$.Age')
}
```
Pour une demande qui inclut les paramètres de chaîne de demande `name=Bella&type=dog` et le corps suivant :
```
{
"Price" : "249.99",
"Age": "6"
}
```
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{
"name" : "Bella",
"body" : "6"
}
```
Ce modèle de mappage supprime le paramètre de chaîne de requête `type=dog` et le champ `Price` du corps.
Si la charge utile d'une demande de méthode contient des caractères non échappés qui ne peuvent pas être analysés, API JavaScript Gateway peut renvoyer une réponse. `400` Appliquez `$util.escapeJavaScript()` pour que les données d’entrée JSON puissent être analysées correctement.
L’exemple précédent avec application de `$util.escapeJavaScript($input.json('$.Age'))` est le suivant :
```
{
"name" : "$input.params('name')",
"body" : "$util.escapeJavaScript($input.json('$.Age'))"
}
```
Dans ce cas, le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{
"name" : "Bella",
"body": "\"6\""
}
```
## Exemple 5 : Utiliser une JSONPath expression pour transmettre des informations relatives à une demande de méthode au point de terminaison d'intégration
L’exemple suivant utilise `$input.params()`, `$input.path()` et `$input.json()` pour envoyer des informations sur une demande de méthode au point de terminaison d’intégration. Ce modèle de mappage utilise la méthode `size()` pour fournir le nombre d’éléments dans une liste.
```
{
"id" : "$input.params('id')",
"count" : "$input.path('$.things').size()",
"things" : $input.json('$.things')
}
```
Pour une demande qui inclut le paramètre de chemin `123` et le corps suivant :
```
{
"things": {
"1": {},
"2": {},
"3": {}
}
}
```
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{"id":"123","count":"3","things":{"1":{},"2":{},"3":{}}}
```
Si la charge utile d'une demande de méthode contient des caractères non échappés qui ne peuvent pas être analysés, API JavaScript Gateway peut renvoyer une réponse. `400` Appliquez `$util.escapeJavaScript()` pour que les données d’entrée JSON puissent être analysées correctement.
L’exemple précédent avec application de `$util.escapeJavaScript($input.json('$.things'))` est le suivant :
```
{
"id" : "$input.params('id')",
"count" : "$input.path('$.things').size()",
"things" : "$util.escapeJavaScript($input.json('$.things'))"
}
```
Le résultat de ce modèle de mappage doit ressembler à ce qui suit :
```
{"id":"123","count":"3","things":"{\"1\":{},\"2\":{},\"3\":{}}"}
```