$contextVariables pour les modèles de données, les autorisateurs, les modèles de mappage et la journalisation des CloudWatch accès Exemple de modèle de variable $context Variables $context pour la journalisation des accès uniquement Variables $input Exemples de modèles de variable $input $stageVariables Variables $util

APIModèle de mappage de passerelle et référence à la variable de journalisation des accès

Cette section fournit des informations de référence sur les variables et les fonctions définies par Amazon API Gateway pour une utilisation avec les modèles de données, les autorisateurs, les modèles de mappage et la journalisation des CloudWatch accès. Pour obtenir des informations détaillées sur l'utilisation de ces variables et fonctions, consultez Modèles de mappage pour REST APIs. Pour plus d'informations sur le langage de modèle Velocity (VTL), consultez la VTLréférence.

Rubriques

$contextVariables pour les modèles de données, les autorisateurs, les modèles de mappage et la journalisation des CloudWatch accès
Exemple de modèle de variable $context
Variables $context pour la journalisation des accès uniquement
Variables $input
Exemples de modèles de variable $input
$stageVariables
Variables $util

Note

Pour les variables $method et $integration, consultez Référence de mappage des données de API demande et de réponse Amazon API Gateway.

`$context`Variables pour les modèles de données, les autorisateurs, les modèles de mappage et la journalisation des CloudWatch accès

Les $context variables suivantes peuvent être utilisées dans les modèles de données, les autorisateurs, les modèles de mappage et la journalisation des CloudWatch accès. APIGateway peut ajouter des variables de contexte supplémentaires.

Pour les $context variables qui ne peuvent être utilisées que dans la journalisation des CloudWatch accès, voirVariables $context pour la journalisation des accès uniquement.

Paramètre	Description
`$context.accountId`	L'identifiant du AWS compte du API propriétaire.
`$context.apiId`	L'identifiant que API Gateway attribue à votre. API
`$context.authorizer.claims.property`	Propriété des requêtes renvoyées depuis le groupe d'utilisateurs Amazon Cognito une fois que l'appelant de la méthode a été authentifié avec succès. Pour de plus amples informations, veuillez consulter Contrôlez l'accès aux API REST en utilisant les groupes d'utilisateurs Amazon Cognito comme autorisateur. Note L'appel de `$context.authorizer.claims` renvoie la valeur null.
`$context.authorizer.principalId`	Identification de l'utilisateur principal associée au jeton envoyé par le client et renvoyé par un autorisateur API Gateway Lambda (anciennement connu sous le nom d'autorisateur personnalisé). Pour de plus amples informations, veuillez consulter Utiliser les API autorisateurs Gateway Lambda.
`$context.authorizer.property`	La valeur sous forme de chaîne de la paire clé-valeur spécifiée de la `context` carte renvoyée par une fonction d'autorisation Gateway API Lambda. Par exemple, si le mécanisme d'autorisation retourne le mappage `context` suivant : `"context" : { "key": "value", "numKey": 1, "boolKey": true }` L'appel `$context.authorizer.key` renvoie la `"value"` chaîne, l'appel `$context.authorizer.numKey` renvoie la `"1"` chaîne et l'appel `$context.authorizer.boolKey` renvoie la `"true"` chaîne. Dans `property`, le seul caractère spécial pris en charge est le trait de soulignement`(_)`. Pour de plus amples informations, veuillez consulter Utiliser les API autorisateurs Gateway Lambda.
`$context.awsEndpointRequestId`	ID de demande du AWS point de terminaison.
`$context.deploymentId`	ID du API déploiement.
`$context.domainName`	Le nom de domaine complet utilisé pour invoquer leAPI. Il doit être identique à l'en-tête `Host` entrant.
`$context.domainPrefix`	Première étiquette de `$context.domainName`.
`$context.error.message`	Chaîne contenant un message d'erreur API Gateway. Cette variable ne peut être utilisée que pour une simple substitution de variables dans un modèle de GatewayResponsemappage corporel, qui n'est pas traité par le moteur Velocity Template Language, et dans la journalisation des accès. Pour plus d’informations, consultez Surveillez WebSocket API l'exécution à l'aide de CloudWatch métriques et Configuration de réponses de passerelle pour personnaliser des réponses d'erreur.
`$context.error.messageString`	La valeur entre guillemets de `$context.error.message`, à savoir `"$context.error.message"`.
`$context.error.responseType`	Un type de GatewayResponse. Cette variable ne peut être utilisée que pour une simple substitution de variables dans un modèle de GatewayResponsemappage corporel, qui n'est pas traité par le moteur Velocity Template Language, et dans la journalisation des accès. Pour plus d’informations, consultez Surveillez WebSocket API l'exécution à l'aide de CloudWatch métriques et Configuration de réponses de passerelle pour personnaliser des réponses d'erreur.
`$context.error.validationErrorString`	Chaîne contenant un message d'erreur de validation détaillé.
`$context.extendedRequestId`	L'ID étendu que API Gateway génère et attribue à la API demande. L’ID de requête étendu contient des informations utiles pour le débogage et le dépannage.
`$context.httpMethod`	La HTTP méthode utilisée. Les valeurs valides sont les suivantes : `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` et `PUT`.
`$context.identity.accountId`	L'ID de AWS compte associé à la demande.
`$context.identity.apiKey`	Pour les API méthodes qui nécessitent une API clé, cette variable est la API clé associée à la demande de méthode. Pour les méthodes qui ne nécessitent pas de API clé, cette variable est nulle. Pour de plus amples informations, veuillez consulter Plans d'utilisation et API clés pour REST APIs in API Gateway .
`$context.identity.apiKeyId`	L'ID de API clé associé à une API demande nécessitant une API clé.
`$context.identity.caller`	Identifiant principal de l'appelant qui a signé la demande. Pris en charge pour les ressources qui utilisent IAM l'autorisation.
`$context.identity.cognitoAuthenticationProvider`	Liste séparée par des virgules de tous les fournisseurs d'authentification Amazon Cognito utilisés par l'appelant à l'origine de la demande. Disponible uniquement si la demande a été signée avec les informations d'identification Amazon Cognito. Par exemple, pour une identité provenant d'un pool d'utilisateurs Amazon Cognito, `cognito-idp. region.amazonaws.com/user_pool_id,cognito-idp.region.amazonaws.com/user_pool_id:CognitoSignIn:token subject claim` Pour plus d'informations sur les fournisseurs d'authentification Amazon Cognito disponibles, consultez la section Utilisation des identités fédérées dans le manuel Amazon Cognito Developer Guide.
`$context.identity.cognitoAuthenticationType`	Type d'authentification Amazon Cognito de l'appelant effectuant la demande. Disponible uniquement si la demande a été signée avec les informations d'identification Amazon Cognito. Les valeurs possibles incluent `authenticated` pour les identités authentifiées et `unauthenticated` pour les identités non authentifiées.
`$context.identity.cognitoIdentityId`	ID d'identité Amazon Cognito de l'appelant effectuant la demande. Disponible uniquement si la demande a été signée avec les informations d'identification Amazon Cognito.
`$context.identity.cognitoIdentityPoolId`	ID de groupe d'identités Amazon Cognito de l'appelant effectuant la demande. Disponible uniquement si la demande a été signée avec les informations d'identification Amazon Cognito.
`$context.identity.principalOrgId`	ID d’organisation AWS.
`$context.identity.sourceIp`	Adresse IP source de la TCP connexion immédiate qui envoie la demande au point de terminaison de la API passerelle.
`$context.identity.clientCert.clientCertPem`	Le certificat client PEM codé que le client a présenté lors de l'TLSauthentification mutuelle. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.clientCert.subjectDN`	Nom distinctif de l'objet du certificat présenté par un client. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.clientCert.issuerDN`	Nom distinctif de l'émetteur du certificat présenté par un client. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.clientCert.serialNumber`	Numéro de série du certificat. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.clientCert.validity.notBefore`	Date avant laquelle le certificat n'est pas valide. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.clientCert.validity.notAfter`	Date après laquelle le certificat n'est pas valide. Présent lorsqu'un client accède à un API en utilisant un nom de domaine personnalisé TLS activé mutuellement. Présent uniquement dans les journaux d'accès en cas TLS d'échec de l'authentification mutuelle.
`$context.identity.vpcId`	L'VPCID de l'expéditeur de la VPC demande au point de terminaison de la API passerelle.
`$context.identity.vpceId`	L'ID du VPC point de VPC terminaison qui envoie la demande au point de terminaison de la API passerelle. Présent uniquement lorsque vous avez un privéAPI.
`$context.identity.user`	Identifiant principal de l'utilisateur qui sera autorisé à accéder aux ressources. Pris en charge pour les ressources qui utilisent IAM l'autorisation.
`$context.identity.userAgent`	L'`User-Agent`en-tête de l'APIappelant.
`$context.identity.userArn`	Le nom de ressource Amazon (ARN) de l'utilisateur effectif identifié après l'authentification. Pour de plus amples informations, veuillez consulter https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html.
`$context.isCanaryRequest`	Renvoie `true` si la demande était dirigée vers le canari et `false` si la demande n'était pas dirigée vers le canari. Présent uniquement lorsque vous avez activé un Canary.
`$context.path`	Chemin d'accès de la demande. Par exemple, pour une demande non proxy URL de`https://{rest-api-id}.execute-api.{region}.amazonaws.com/{stage}/root/child`, la `$context.path` valeur est`/{stage}/root/child`.
`$context.protocol`	Protocole de demande, par exemple, `HTTP/1.1`. Note APIGateway APIs peut accepter HTTP /2 requêtes, mais API Gateway envoie des demandes aux intégrations de backend en utilisant /1.1. HTTP Par conséquent, le protocole de demande est enregistré sous HTTP /1.1 même si un client envoie une demande utilisant HTTP /2.
`$context.requestId`	Un ID pour la demande. Les clients peuvent remplacer cet ID de demande. `$context.extendedRequestId`À utiliser pour un ID de demande unique généré par API Gateway.
`$context.requestOverride.header.header_name`	Remplacement de l'en-tête de la requête. Si ce paramètre est défini, il contient les en-têtes à utiliser à la place des HTTPen-têtes définis dans le volet Demande d'intégration. Pour de plus amples informations, veuillez consulter Utiliser un modèle de mappage pour remplacer les paramètres API de demande et de réponse et les codes d'état d'un.
`$context.requestOverride.path.path_name`	Remplacement du chemin de la requête. Si ce paramètre est défini, il contient le chemin de demande à utiliser au lieu des paramètres de URL chemin définis dans le volet Demande d'intégration. Pour de plus amples informations, veuillez consulter Utiliser un modèle de mappage pour remplacer les paramètres API de demande et de réponse et les codes d'état d'un.
`$context.requestOverride.querystring.querystring_name`	Remplacement de la chaîne d'interrogation de la requête. Si ce paramètre est défini, il contient les chaînes de requête à utiliser à la place des paramètres de chaîne de URL requête définis dans le volet Demande d'intégration. Pour de plus amples informations, veuillez consulter Utiliser un modèle de mappage pour remplacer les paramètres API de demande et de réponse et les codes d'état d'un.
`$context.responseOverride.header.header_name`	Remplacement de l'en-tête de la réponse. Si ce paramètre est défini, il contient l'en-tête qui est renvoyé à la place du Response header (En-tête de réponse) qui est défini comme le Default mapping (Mappage par défaut) dans le volet Integration Response (Réponse d'intégration). Pour de plus amples informations, veuillez consulter Utiliser un modèle de mappage pour remplacer les paramètres API de demande et de réponse et les codes d'état d'un.
`$context.responseOverride.status`	Remplacement du code de statut de la réponse. Si ce paramètre est défini, il contient le code du statut qui est renvoyé à la place du Method response status (Statut de la réponse de méthode) qui est défini comme le Default mapping (Mappage par défaut) dans le volet Integration Response (Réponse d'intégration). Pour de plus amples informations, veuillez consulter Utiliser un modèle de mappage pour remplacer les paramètres API de demande et de réponse et les codes d'état d'un.
`$context.requestTime`	L'heure CLFde la demande formatée ()`dd/MMM/yyyy:HH:mm:ss +-hhmm`.
`$context.requestTimeEpoch`	Heure de la demande au format Epoch, en millisecondes.
`$context.resourceId`	L'identifiant que API Gateway attribue à votre ressource.
`$context.resourcePath`	Chemin de votre ressource. Par exemple, pour la demande sans proxy URI de`https://{rest-api-id}.execute-api.{region}.amazonaws.com/{stage}/root/child`, La `$context.resourcePath` valeur est`/root/child`. Pour de plus amples informations, veuillez consulter Tutoriel : créer un REST API avec une HTTP intégration sans proxy.
`$context.stage`	L'étape de déploiement de la API demande (par exemple, `Beta` ou`Prod`).
`$context.wafResponseCode`	Réponse reçue de AWS WAF: `WAF_ALLOW` ou `WAF_BLOCK`. Ne sera pas défini si la scène n'est pas associée à un site WebACL. Pour de plus amples informations, veuillez consulter AWS WAF À utiliser pour protéger vos API REST dans API Gateway.
`$context.webaclArn`	L'ensemble ARN du site Web ACL utilisé pour décider d'autoriser ou de bloquer la demande. Ne sera pas défini si la scène n'est pas associée à un site WebACL. Pour de plus amples informations, veuillez consulter AWS WAF À utiliser pour protéger vos API REST dans API Gateway.

Exemple de modèle de variable `$context`

Vous souhaiterez peut-être utiliser $context des variables dans un modèle de mappage si votre API méthode transmet des données structurées à un backend qui exige que les données soient dans un format particulier.

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 :

Note

L'une des variables est une API clé. Cet exemple suppose que la méthode nécessite une API clé.


{
    "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"
}

La sortie 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'
}

Variables `$context` pour la journalisation des accès uniquement

Les variables $context ci-après sont disponibles uniquement pour la journalisation des accès Pour de plus amples informations, veuillez consulter Configurer la CloudWatch journalisation REST APIs dans API Gateway. (Pour WebSocket APIs, voirSurveillez WebSocket API l'exécution à l'aide de CloudWatch métriques.)

Paramètre	Description
`$context.authorize.error`	Message d'erreur d'autorisation.
`$context.authorize.latency`	Latence d'autorisation en millisecondes.
`$context.authorize.status`	Code d'état renvoyé à la suite d'une tentative d'autorisation.
`$context.authorizer.error`	Message d'erreur renvoyé par un mécanisme d'autorisation.
`$context.authorizer.integrationLatency`	Latence d'intégration de l'autorisateur en ms.
`$context.authorizer.integrationStatus`	Code d'état renvoyé par un mécanisme d'autorisation Lambda.
`$context.authorizer.latency`	Latence du mécanisme d'autorisation en millisecondes (ms).
`$context.authorizer.requestId`	ID de demande du AWS point de terminaison.
`$context.authorizer.status`	Code d'état renvoyé par un mécanisme d'autorisation.
`$context.authenticate.error`	Message d'erreur renvoyé à la suite d'une tentative d'authentification.
`$context.authenticate.latency`	Latence d'authentification en millisecondes.
`$context.authenticate.status`	Code d'état renvoyé à la suite d'une tentative d'authentification.
`$context.customDomain.basePathMatched`	Le chemin d'un API mappage auquel correspond une demande entrante. Applicable lorsqu'un client utilise un nom de domaine personnalisé pour accéder à unAPI. Par exemple, si un client envoie une demande à`https://api.example.com/v1/orders/1234`, et que la demande correspond au API mappage avec le chemin`v1/orders`, la valeur est`v1/orders`. Pour en savoir plus, consultez Associez API les étapes à un nom de domaine personnalisé pour REST APIs.
`$context.endpointType`	Le type de point de terminaison duAPI.
`$context.integration.error`	Message d'erreur renvoyé à partir d'une intégration.
`$context.integration.integrationStatus`	Pour l'intégration du proxy Lambda, le code d'état est renvoyé par le code de fonction Lambda principal AWS Lambda, et non par le code de fonction Lambda principal.
`$context.integration.latency`	Latence d'intégration en millisecondes (ms). Équivalent à `$context.integrationLatency`.
`$context.integration.requestId`	ID de demande du AWS point de terminaison. Équivalent à `$context.awsEndpointRequestId`.
`$context.integration.status`	Code d'état renvoyé à partir d'une intégration. Pour les intégrations de proxy Lambda, code d'état que votre code de fonction Lambda renvoie.
`$context.integrationLatency`	Latence d'intégration en millisecondes (ms).
`$context.integrationStatus`	Pour l'intégration du proxy Lambda, ce paramètre représente le code d'état renvoyé par le code de fonction Lambda principal AWS Lambda, et non par le code de fonction Lambda principal.
`$context.responseLatency`	Latence de la réponse en millisecondes (ms).
`$context.responseLength`	La longueur de la charge utile de la réponse en octets.
`$context.status`	Statut de la réponse de la méthode.
`$context.waf.error`	Le message d'erreur renvoyé par AWS WAF.
`$context.waf.latency`	La AWS WAF latence en ms.
`$context.waf.status`	Le code d'état renvoyé par AWS WAF.
`$context.xrayTraceId`	ID du suivi X-Ray. Pour de plus amples informations, veuillez consulter Configuration AWS X-Ray avec les API REST API Gateway.

Variables `$input`

La variable $input représente la charge utile de la demande de méthode et les paramètres devant être traités par un modèle de mappage. Il fournit les fonctions suivantes :

Variable et fonction	Description
`$input.body`	Renvoie la charge utile de la demande brute sous forme de chaîne. Vous pouvez l'utiliser `$input.body` pour conserver des nombres à virgule flottante entiers, tels que`10.00`.
`$input.json(x)`	Cette fonction évalue une JSONPath expression et renvoie les résultats sous forme de JSON chaîne. Par exemple, `$input.json('$.pets')` renvoie une JSON chaîne représentant la `pets` structure. Pour plus d'informations surJSONPath, voir JSONPathou JSONPathpour Java.
`$input.params()`	Renvoie une carte de tous les paramètres de demande. Nous vous recommandons d'utiliser `$util.escapeJavaScript` pour désinfecter le résultat afin d'éviter une attaque potentielle par injection. Pour un contrôle total de la désinfection des requêtes, utilisez une intégration proxy sans modèle et gérez la désinfection des requêtes dans votre intégration.
`$input.params(x)`	Renvoie la valeur d'un paramètre de demande de méthode à partir du chemin, de la chaîne de requête ou d'une valeur d'en-tête (dans cet ordre) avec une chaîne de nom de paramètre `x`. Nous vous recommandons d'utiliser `$util.escapeJavaScript` pour désinfecter le paramètre afin d'éviter une attaque potentielle par injection. Pour un contrôle total de la désinfection des paramètres, utilisez une intégration proxy sans modèle et gérez la désinfection des requêtes dans votre intégration.
`$input.path(x)`	Prend une chaîne JSONPath d'expression (`x`) et renvoie une représentation sous forme d'JSONobjet du résultat. Cela vous permet d'accéder aux éléments de la charge utile et de les manipuler de manière native dans le langage de modèle Apache Velocity () VTL. Par exemple, si l'expression `$input.path('$.pets')` renvoie un objet comme suit : `[ { "id": 1, "type": "dog", "price": 249.99 }, { "id": 2, "type": "cat", "price": 124.99 }, { "id": 3, "type": "fish", "price": 0.99 } ]` `$input.path('$.pets').size()` renvoie `"3"`. Pour plus d'informations surJSONPath, voir JSONPathou JSONPathpour Java.

Exemples de modèles de variable `$input`

Les exemples suivants montrent comment utiliser les $input variables dans les modèles de mappage. Vous pouvez utiliser une intégration fictive ou une intégration Lambda sans proxy qui renvoie l'événement d'entrée à API Gateway pour essayer ces exemples.

Exemple de modèle de mappage de paramètres

L'exemple suivant transmet tous les paramètres de demande, y compris pathquerystring, etheader, au point de terminaison d'intégration via une JSON charge utile :


#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
  }
}

Pour une demande qui inclut les paramètres d'entrée suivants :

Un paramètre de chemin nommé myparam
Paramètres de chaîne de requête querystring1=value1,value2&querystring2=value3
En-têtes "header1" : "value1""header2" : "value2","header3" : "value3".

La sortie de ce modèle de mappage doit ressembler à ce qui suit :


{
  "params" : {
        "path" : {
            "path" : "myparam"
                }
    ,        "querystring" : {
            "querystring1" : "value1,value2"
      ,            "querystring2" : "value3"
                }
    ,        "header" : {
            "header3" : "value3"
      ,            "header2" : "value2"
      ,            "header1" : "value1"
                }
          }
}

JSONexemple de modèle de mappage

Vous pouvez utiliser la variable $input pour obtenir les chaînes de requête et le corps de la demande avec ou sans l'aide de modèles. Vous souhaiterez peut-être également obtenir le paramètre et la charge utile, ou une sous-section de la charge utile. Les trois exemples suivants montrent comment procéder.

L'exemple suivant utilise un modèle de mappage pour obtenir une sous-section de la charge utile. Cet exemple permet d'obtenir le paramètre d'entrée, name puis le POST corps entier :


{
    "name" : "$input.params('name')",
    "body" : $input.json('$') 
}

Pour une demande qui inclut les paramètres de la chaîne de requête name=Bella&type=dog et le corps suivant :


{
    "Price" : "249.99",
    "Age": "6"
}

La sortie de ce modèle de mappage doit ressembler à ce qui suit :


{
    "name" : "Bella",
    "body" : {"Price":"249.99","Age":"6"}
}

Si l'JSONentrée 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 vous assurer que l'JSONentrée peut être analysée correctement.

L'exemple précédent avec $util.escapeJavaScript($input.json('$')) appliqué 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\"}
}

JSONPathexemple d'expression

L'exemple suivant montre comment transmettre une JSONPath expression à la json() méthode. Vous pouvez également lire une sous-section de l'objet du corps de votre demande en utilisant un . point, pour spécifier une propriété :


{
    "name" : "$input.params('name')",
    "body" : $input.json('$.Age')  
}

Pour une demande qui inclut les paramètres de la chaîne de requête name=Bella&type=dog et le corps suivant :


{
    "Price" : "249.99",
    "Age": "6"
}

La sortie de ce modèle de mappage doit ressembler à ce qui suit :


{
    "name" : "Bella",
    "body" : "6"
}

Si la charge utile d'une demande de méthode 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() pour vous assurer que l'JSONentrée peut être analysée correctement.

L'exemple précédent avec $util.escapeJavaScript($input.json('$.Age')) appliqué 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 de demande et de réponse

L'exemple suivant utilise $input.params()$input.path(), et $input.json() pour une ressource avec le chemin /things/{id} :


{
    "id" : "$input.params('id')",
    "count" : "$input.path('$.things').size()",
    "things" : $input.json('$.things')"
}

Pour une demande qui inclut le paramètre path 123 et le corps suivant :


{
      "things": {
            "1": {},
            "2": {},
            "3": {}
      }
}

La sortie de ce modèle de mappage doit ressembler à ce qui suit :


{"id":"123","count":"3","things":{"1":{},"2":{},"3":{}}}

L'exemple précédent avec $util.escapeJavaScript($input.json('$.things')) appliqué est le suivant :


{
     "id" : "$input.params('id')",
     "count" : "$input.path('$.things').size()",
     "things" : "$util.escapeJavaScript($input.json('$.things'))"
}

La sortie de ce modèle de mappage doit ressembler à ce qui suit :


{"id":"123","count":"3","things":"{\"1\":{},\"2\":{},\"3\":{}}"}

Pour plus d'exemples de mappage, consultez Modèles de mappage pour REST APIs.

`$stageVariables`

Les variables d'étape peuvent être utilisées dans le mappage de paramètres et les modèles de mappage, ainsi que comme espaces réservés ARNs et URLs utilisés dans les intégrations de méthodes. Pour de plus amples informations, veuillez consulter Utiliser des variables d'étape pour un REST API in API Gateway.

Syntaxe	Description
`$stageVariables.<variable_name>`, `$stageVariables['<variable_name>']` ou `${stageVariables['<variable_name>']}`	`<variable_name>` représente le nom d'une variable d'étape.

Variables `$util`

La variable $util contient les fonctions utilitaires à utiliser dans les modèles de mappage.

Note

Sauf indication contraire, le jeu de caractères par défaut est UTF -8.

Fonction	Description
`$util.escapeJavaScript()`	Échape les caractères d'une chaîne en utilisant les règles relatives aux JavaScript chaînes. Note Cette fonction convertit tout guillemet simple (`'`) en guillemet d'échappement (`\'`). Cependant, les guillemets simples échappés ne sont pas valides dansJSON. Ainsi, lorsque le résultat de cette fonction est utilisé dans une JSON propriété, vous devez reconvertir les guillemets simples (`\'`) échappés en guillemets simples () normaux (`'`). comme illustré dans l'exemple suivant : `"input" : "$util.escapeJavaScript(data).replaceAll("\\'","'")"`
`$util.parseJson()`	Prend « stringifié » JSON et renvoie une représentation sous forme d'objet du résultat. Vous pouvez utiliser le résultat de cette fonction pour accéder aux éléments de la charge utile et les manipuler de manière native dans le langage de modèle Apache Velocity ()VTL. Par exemple, si vous avez la charge utile suivante : `{"errorMessage":"{\"key1\":\"var1\",\"key2\":{\"arr\":[1,2,3]}}"}` et utilisez le modèle de mappage suivant : `#set ($errorMessageObj = $util.parseJson($input.path('$.errorMessage'))) { "errorMessageObjKey2ArrVal" : $errorMessageObj.key2.arr[0] }` vous obtenez la sortie suivante : `{ "errorMessageObjKey2ArrVal" : 1 }`
`$util.urlEncode()`	Convertit une chaîne au format « application/ x-www-form-urlencoded ».
`$util.urlDecode()`	Décode une chaîne « application/ x-www-form-urlencoded ».
`$util.base64Encode()`	Encode les données dans une chaîne encodée en base64.
`$util.base64Decode()`	Décode les données d'une chaîne encodée en base64.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Comportements de transfert direct

Réponses de passerelle