$contextVariabili per modelli di dati, autorizzatori, modelli di mappatura e registrazione degli accessi CloudWatch Esempio di modello di variabile $context Variabili $context solo per la registrazione degli accessi $input Variabili Esempi di modello di variabile $input $stageVariables $util Variabili

APIModello di mappatura del gateway e riferimento alla variabile di registrazione degli accessi

Questa sezione fornisce informazioni di riferimento per le variabili e le funzioni che Amazon API Gateway definisce per l'uso con modelli di dati, autorizzatori, modelli di mappatura e registrazione degli CloudWatch accessi. Per informazioni dettagliate su come usare queste variabili e funzioni, consulta Modelli di mappatura per REST APIs. Per ulteriori informazioni sul Velocity Template Language (VTL), consulta la pagina di riferimento. VTL

Argomenti

$contextVariabili per modelli di dati, autorizzatori, modelli di mappatura e registrazione degli accessi CloudWatch
Esempio di modello di variabile $context
Variabili $context solo per la registrazione degli accessi
$input Variabili
Esempi di modello di variabile $input
$stageVariables
$util Variabili

Nota

Per le variabili $method e $integration, consulta Riferimento alla mappatura dei dati di API richiesta e risposta di Amazon API Gateway.

`$context`Variabili per modelli di dati, autorizzatori, modelli di mappatura e registrazione degli accessi CloudWatch

Le seguenti $context variabili possono essere utilizzate nei modelli di dati, negli autorizzatori, nei modelli di mappatura e nella registrazione degli accessi. CloudWatch APIGateway potrebbe aggiungere variabili di contesto aggiuntive.

Per $context le variabili che possono essere utilizzate solo nella registrazione CloudWatch degli accessi, vedereVariabili $context solo per la registrazione degli accessi.

Parametro	Descrizione
`$context.accountId`	L'ID dell' AWS account del API proprietario.
`$context.apiId`	L'identificatore che API Gateway assegna al tuo. API
`$context.authorizer.claims.property`	Proprietà delle richieste restituite dal pool di utenti di Amazon Cognito dopo che l'intermediario del metodo viene autenticato correttamente. Per ulteriori informazioni, consulta Controlla l'accesso alle API REST utilizzando i pool di utenti di Amazon Cognito come autorizzatore. Nota La chiamata di `$context.authorizer.claims` restituisce null.
`$context.authorizer.principalId`	L'identificazione dell'utente principale associata al token inviato dal client e restituito da un autorizzatore API Gateway Lambda (precedentemente noto come autorizzatore personalizzato). Per ulteriori informazioni, consulta Usa gli API autorizzatori Gateway Lambda.
`$context.authorizer.property`	Il valore stringato della coppia chiave-valore specificata della `context` mappa restituito da una funzione di autorizzazione Gateway API Lambda. Ad esempio, se le autorizzazioni restituiscono la mappa `context` seguente: `"context" : { "key": "value", "numKey": 1, "boolKey": true }` La chiamata `$context.authorizer.key` restituisce la `"value"` stringa, la chiamata restituisce la stringa e la chiamata `$context.authorizer.numKey` restituisce la `"1"` stringa. `$context.authorizer.boolKey` `"true"` In `property`, l'unico carattere speciale supportato è il carattere di sottolineatura`(_)`. Per ulteriori informazioni, consulta Usa gli API autorizzatori Gateway Lambda.
`$context.awsEndpointRequestId`	L'ID della richiesta dell' AWS endpoint.
`$context.deploymentId`	L'ID della API distribuzione.
`$context.domainName`	Il nome di dominio completo utilizzato per richiamare ilAPI. Deve essere lo stesso dell'intestazione `Host` in ingresso.
`$context.domainPrefix`	Prima etichetta di `$context.domainName`.
`$context.error.message`	Una stringa contenente un messaggio di errore API Gateway. Questa variabile può essere utilizzata solo per la semplice sostituzione di variabili in un modello di GatewayResponsebody mapping, che non viene elaborato dal motore Velocity Template Language, e nella registrazione degli accessi. Per ulteriori informazioni, consulta Monitora WebSocket API l'esecuzione con CloudWatch metriche e Configurazione delle risposte del gateway per la personalizzazione delle risposte agli errori.
`$context.error.messageString`	Valore `$context.error.message` tra virgolette, ovvero `"$context.error.message"`.
`$context.error.responseType`	Un tipo di. GatewayResponse Questa variabile può essere utilizzata solo per la semplice sostituzione di variabili in un modello di GatewayResponsebody mapping, che non viene elaborato dal motore Velocity Template Language, e nella registrazione degli accessi. Per ulteriori informazioni, consulta Monitora WebSocket API l'esecuzione con CloudWatch metriche e Configurazione delle risposte del gateway per la personalizzazione delle risposte agli errori.
`$context.error.validationErrorString`	Stringa contenente un messaggio dettagliato di errore di convalida.
`$context.extendedRequestId`	L'ID esteso che API Gateway genera e assegna alla richiesta. API L’ID della richiesta esteso contiene ulteriori informazioni utili per il debug e la risoluzione dei problemi.
`$context.httpMethod`	Il HTTP metodo utilizzato. I valori validi sono: `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` e `PUT`.
`$context.identity.accountId`	L'ID AWS dell'account associato alla richiesta.
`$context.identity.apiKey`	Per API i metodi che richiedono una API chiave, questa variabile è la API chiave associata alla richiesta del metodo. Per i metodi che non richiedono una API chiave, questa variabile è nulla. Per ulteriori informazioni, consulta Piani di utilizzo e API chiavi per REST APIs in API Gateway .
`$context.identity.apiKeyId`	L'ID della API chiave associato a una API richiesta che richiede una API chiave.
`$context.identity.caller`	Identificatore dell'entità principale dell'intermediario che ha firmato la richiesta. Supportato per le risorse che utilizzano IAM l'autorizzazione.
`$context.identity.cognitoAuthenticationProvider`	Un elenco separato da virgole di tutti i provider di autenticazione Amazon Cognito utilizzati dal chiamante che effettua la richiesta. Disponibile solo se la richiesta è stata firmata con credenziali Amazon Cognito. Ad esempio, per un'identità di un pool di utenti Amazon Cognito, `cognito-idp. region.amazonaws.com/user_pool_id,cognito-idp.region.amazonaws.com/user_pool_id:CognitoSignIn:token subject claim` Per informazioni sui provider di autenticazione di Amazon Cognito disponibili, consulta Using Federated Identities nella Amazon Cognito Developer Guide.
`$context.identity.cognitoAuthenticationType`	Tipo di autenticazione Amazon Cognito dell'intermediario da cui proviene la richiesta. Disponibile solo se la richiesta è stata firmata con credenziali Amazon Cognito. I valori possibili includono `authenticated` per le identità autenticate e `unauthenticated` per le identità non autenticate.
`$context.identity.cognitoIdentityId`	ID identità di Amazon Cognito dell'intermediario da cui proviene la richiesta. Disponibile solo se la richiesta è stata firmata con credenziali Amazon Cognito.
`$context.identity.cognitoIdentityPoolId`	ID pool di identità di Amazon Cognito dell'intermediario da cui proviene la richiesta. Disponibile solo se la richiesta è stata firmata con credenziali Amazon Cognito.
`$context.identity.principalOrgId`	L'ID organizzazione AWS.
`$context.identity.sourceIp`	L'indirizzo IP di origine della TCP connessione immediata che effettua la richiesta all'endpoint Gateway. API
`$context.identity.clientCert.clientCertPem`	Il certificato client PEM con codifica che il client ha presentato durante l'autenticazione reciproca. TLS Presente quando un client accede a un API utilizzando un nome di dominio personalizzato con attivazione reciproca. TLS Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.clientCert.subjectDN`	Nome distinto dell'oggetto del certificato presentato da un client. Presente quando un client accede a un utente API utilizzando un nome di dominio personalizzato con mutua TLS attivazione. Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.clientCert.issuerDN`	Nome distinto dell'approvatore del certificato presentato da un cliente. Presente quando un client accede a un utente API utilizzando un nome di dominio personalizzato con mutua TLS attivazione. Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.clientCert.serialNumber`	Il numero di serie del certificato. Presente quando un client accede a un utente API utilizzando un nome di dominio personalizzato con mutua TLS attivazione. Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.clientCert.validity.notBefore`	La data prima della quale il certificato non è valido. Presente quando un client accede a un utente API utilizzando un nome di dominio personalizzato con mutua TLS attivazione. Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.clientCert.validity.notAfter`	La data dopo la quale il certificato non è valido. Presente quando un client accede a un utente API utilizzando un nome di dominio personalizzato con mutua TLS attivazione. Presente solo nei log di accesso se l'TLSautenticazione reciproca fallisce.
`$context.identity.vpcId`	L'VPCID di chi VPC effettua la richiesta all'endpoint API Gateway.
`$context.identity.vpceId`	L'ID dell'VPCendpoint che effettua la richiesta all'VPCendpoint Gateway. API Presente solo quando ne hai uno privato. API
`$context.identity.user`	Identificatore dell'entità principale dell'utente che sarà autorizzato per l'accesso alle risorse. Supportato per le risorse che utilizzano IAM l'autorizzazione.
`$context.identity.userAgent`	L'`User-Agent`intestazione del API chiamante.
`$context.identity.userArn`	L'Amazon Resource Name (ARN) dell'utente effettivo identificato dopo l'autenticazione. Per ulteriori informazioni, consulta https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html.
`$context.isCanaryRequest`	Indica `true` se la richiesta è stata indirizzata al canarino e `false` se la richiesta non è stata indirizzata al canarino. Presente solo quando hai un canarino abilitato.
`$context.path`	Percorso della richiesta. Ad esempio, per una richiesta non proxy URL di`https://{rest-api-id}.execute-api.{region}.amazonaws.com/{stage}/root/child`, il `$context.path` valore è. `/{stage}/root/child`
`$context.protocol`	Protocollo della richiesta, ad esempi, `HTTP/1.1`. Nota APIGateway APIs può accettare richieste HTTP /2, ma API Gateway invia richieste alle integrazioni di backend utilizzando /1.1. HTTP Di conseguenza, il protocollo di richiesta viene registrato come HTTP /1.1 anche se un client invia una richiesta che utilizza /2. HTTP
`$context.requestId`	L'ID della richiesta. I client possono sovrascrivere questo ID di richiesta. Utilizzalo `$context.extendedRequestId` per un ID di richiesta univoco generato da GatewayAPI.
`$context.requestOverride.header.header_name`	Sovrascrittura intestazione della richiesta. Se questo parametro è definito, contiene le intestazioni da utilizzare al posto delle HTTPintestazioni definite nel riquadro Integration Request. Per ulteriori informazioni, consulta Utilizza un modello di mappatura per sovrascrivere i parametri API di richiesta e risposta e i codici di stato di un utente.
`$context.requestOverride.path.path_name`	Sovrascrittura percorso della richiesta. Se questo parametro è definito, contiene il percorso della richiesta da utilizzare anziché i parametri del URL percorso definiti nel riquadro Richiesta di integrazione. Per ulteriori informazioni, consulta Utilizza un modello di mappatura per sovrascrivere i parametri API di richiesta e risposta e i codici di stato di un utente.
`$context.requestOverride.querystring.querystring_name`	Sovrascrittura stringa di query della richiesta. Se questo parametro è definito, contiene le stringhe di query di richiesta da utilizzare al posto dei parametri della stringa di URL query definiti nel riquadro Richiesta di integrazione. Per ulteriori informazioni, consulta Utilizza un modello di mappatura per sovrascrivere i parametri API di richiesta e risposta e i codici di stato di un utente.
`$context.responseOverride.header.header_name`	Sovrascrittura intestazione della risposta. Se definito, questo parametro contiene l'intestazione da restituire al posto della Response header (Intestazione di risposta) che è definita come la Default mapping (mappatura predefinita) nel riquadro Integration Response (Risposta integrazione). Per ulteriori informazioni, consulta Utilizza un modello di mappatura per sovrascrivere i parametri API di richiesta e risposta e i codici di stato di un utente.
`$context.responseOverride.status`	Sovrascrittura codice di stato della risposta. Se definito, questo parametro contiene il codice di stato da restituire al posto di Method response status (Stato risposta metodo) che è definito come la Default mapping (Mappatura predefinita) nel riquadro Integration Response (Risposta integrazione). Per ulteriori informazioni, consulta Utilizza un modello di mappatura per sovrascrivere i parametri API di richiesta e risposta e i codici di stato di un utente.
`$context.requestTime`	L'ora della richiesta in CLFformato -formattato (). `dd/MMM/yyyy:HH:mm:ss +-hhmm`
`$context.requestTimeEpoch`	L'ora della richiesta in formato epoca (Unix epoch) in millisecondi.
`$context.resourceId`	L'identificatore che API Gateway assegna alla tua risorsa.
`$context.resourcePath`	Percorso della risorsa. Ad esempio, per la richiesta non proxy URI di`https://{rest-api-id}.execute-api.{region}.amazonaws.com/{stage}/root/child`, Il `$context.resourcePath` valore è. `/root/child` Per ulteriori informazioni, consulta Tutorial: creare un file REST API con un'HTTPintegrazione non proxy.
`$context.stage`	La fase di distribuzione della API richiesta (ad esempio, `Beta` o`Prod`).
`$context.wafResponseCode`	La risposta ricevuta da AWS WAF: `WAF_ALLOW` o `WAF_BLOCK`. Non verrà impostato se lo stage non è associato a un WebACL. Per ulteriori informazioni, consulta Utilizzalo AWS WAF per proteggere le tue API REST in API Gateway.
`$context.webaclArn`	Il sito Web ACL completo ARN utilizzato per decidere se consentire o bloccare la richiesta. Non verrà impostato se lo stage non è associato a un webACL. Per ulteriori informazioni, consulta Utilizzalo AWS WAF per proteggere le tue API REST in API Gateway.

Esempio di modello di variabile `$context`

Potresti voler utilizzare $context le variabili in un modello di mappatura se il tuo API metodo passa dati strutturati a un backend che richiede che i dati siano in un formato particolare.

L'esempio seguente mostra un modello di mappatura che mappa variabili $context in ingresso a variabili back-end con nomi leggermente diversi nel payload di una richiesta di integrazione:

Nota

Una delle variabili è una API chiave. L'esempio presuppone che il metodo richieda una API chiave.


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

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

Variabili `$context` solo per la registrazione degli accessi

Le seguenti variabili $context sono disponibili solo per la registrazione degli accessi. Per ulteriori informazioni, consulta Configurare la CloudWatch registrazione per REST APIs Gateway API. (Per WebSocket APIs, vediMonitora WebSocket API l'esecuzione con CloudWatch metriche.)

Parametro	Descrizione
`$context.authorize.error`	Il messaggio di errore di autorizzazione.
`$context.authorize.latency`	La latenza di autorizzazione in ms.
`$context.authorize.status`	Il codice di stato restituito da un tentativo di autorizzazione.
`$context.authorizer.error`	Il messaggio di errore restituito da un'autorizzazione.
`$context.authorizer.integrationLatency`	La latenza di integrazione dell'autorizzatore in ms.
`$context.authorizer.integrationStatus`	Il codice di stato restituito da un'autorizzazione Lambda.
`$context.authorizer.latency`	La latenza di autorizzazione in ms.
`$context.authorizer.requestId`	L'ID della AWS richiesta dell'endpoint.
`$context.authorizer.status`	Il codice di stato restituito da un'autorizzazione.
`$context.authenticate.error`	Il messaggio di errore restituito da un tentativo di autenticazione.
`$context.authenticate.latency`	La latenza di autenticazione in ms.
`$context.authenticate.status`	Il codice di stato restituito da un tentativo di autenticazione.
`$context.customDomain.basePathMatched`	Il percorso di una API mappatura a cui corrisponde una richiesta in arrivo. Applicabile quando un client utilizza un nome di dominio personalizzato per accedere a un. API Ad esempio, se un client invia una richiesta a`https://api.example.com/v1/orders/1234`, e la richiesta corrisponde alla API mappatura con il percorso`v1/orders`, il valore è`v1/orders`. Per ulteriori informazioni, consulta Mappa API le fasi su un nome di dominio personalizzato per REST APIs.
`$context.endpointType`	Il tipo di endpoint di. API
`$context.integration.error`	Il messaggio di errore restituito da un'integrazione.
`$context.integration.integrationStatus`	Per l'integrazione del proxy Lambda, il codice di stato restituito dal codice della funzione Lambda di backend AWS Lambda, non dal codice della funzione Lambda.
`$context.integration.latency`	Latenza di integrazione in ms. Equivalente a `$context.integrationLatency`.
`$context.integration.requestId`	L'ID della AWS richiesta dell'endpoint. Equivalente a `$context.awsEndpointRequestId`.
`$context.integration.status`	Il codice di stato restituito da un'integrazione. Per le integrazioni proxy Lambda, questo è il codice di stato restituito dal codice della funzione Lambda.
`$context.integrationLatency`	Latenza di integrazione in ms.
`$context.integrationStatus`	Per l'integrazione del proxy Lambda, questo parametro rappresenta il codice di stato restituito dal codice della funzione Lambda di AWS Lambda backend e non dal codice della funzione Lambda.
`$context.responseLatency`	Latenza della risposta in ms.
`$context.responseLength`	Lunghezza del payload della risposta in byte.
`$context.status`	Stato della risposta del metodo.
`$context.waf.error`	Il messaggio di errore restituito da. AWS WAF
`$context.waf.latency`	La AWS WAF latenza in ms.
`$context.waf.status`	Il codice di stato restituito da AWS WAF.
`$context.xrayTraceId`	L'ID della traccia di X-Ray. Per ulteriori informazioni, consulta Configurazione AWS X-Ray con le API REST di API Gateway.

`$input` Variabili

La variabile $input rappresenta il payload della richiesta del metodo e i parametri che devono essere elaborati dal modello di mappatura. Fornisce le seguenti funzioni:

Variabile e funzione	Descrizione
`$input.body`	Restituisce il payload della richiesta non elaborata come stringa. È possibile utilizzare `$input.body` per conservare interi numeri in virgola mobile, ad esempio`10.00`.
`$input.json(x)`	Questa funzione valuta un'JSONPathespressione e restituisce i risultati sotto forma di stringaJSON. Ad esempio, `$input.json('$.pets')` restituisce una JSON stringa che rappresenta la `pets` struttura. Per ulteriori informazioni suJSONPath, vedere JSONPathor JSONPathfor Java.
`$input.params()`	Restituisce una mappa di tutti i parametri della richiesta. Si consiglia di utilizzare `$util.escapeJavaScript` per sanificare il risultato ed evitare un potenziale attacco di iniezione. Per il pieno controllo della sanificazione delle richieste, utilizzare un'integrazione proxy senza un modello e gestire la sanificazione delle richieste nell'integrazione.
`$input.params(x)`	Restituisce il valore di un parametro della richiesta del metodo dal percorso, dalla stringa di query o dal valore dell'intestazione (cercati in questo ordine) a partire da una stringa del nome del parametro `x`. Si consiglia di utilizzare `$util.escapeJavaScript` per sanificare il parametro ed evitare un potenziale attacco di iniezione. Per il controllo completo della sanificazione dei parametri, utilizzare un'integrazione proxy senza un modello e gestire la sanificazione delle richieste nell'integrazione.
`$input.path(x)`	Accetta una stringa di JSONPath espressione (`x`) e restituisce una rappresentazione JSON oggettuale del risultato. Ciò consente di accedere e manipolare gli elementi del payload in modo nativo in Apache Velocity Template Language (). VTL Ad esempio, se l'espressione `$input.path('$.pets')` restituisce un oggetto in questo modo: `[ { "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()` restituisce `"3"`. Per ulteriori informazioni suJSONPath, vedere or for Java. JSONPathJSONPath

Esempi di modello di variabile `$input`

Gli esempi seguenti mostrano come utilizzare $input le variabili nei modelli di mappatura. Puoi utilizzare un'integrazione fittizia o un'integrazione non proxy Lambda che restituisca l'evento di input API a Gateway per provare questi esempi.

Esempio di modello di mappatura di parametri

L'esempio seguente passa tutti i parametri della richiesta, inclusipath, e querystringheader, all'endpoint di integrazione tramite un payload: 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
  }
}

Per una richiesta che include i seguenti parametri di input:

Un parametro di percorso denominato myparam
Parametri della stringa di query querystring1=value1,value2&querystring2=value3
Intestazioni "header1" : "value1""header2" : "value2","header3" : "value3".

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

JSONesempio di modello di mappatura

È possibile usare la variabile $input per ottenere stringhe di query e il corpo della richiesta con o senza l'uso di modelli. Potresti anche voler ottenere il parametro e il payload o una sottosezione del payload. I tre esempi seguenti mostrano come eseguire questa operazione.

L'esempio seguente utilizza un modello di mappatura per ottenere una sottosezione del payload. Questo esempio ottiene il parametro di input name e quindi l'intero corpo: POST


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

Per una richiesta che include i parametri della stringa di query name=Bella&type=dog e il seguente corpo:


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

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

Se l'JSONinput contiene caratteri senza escape che non possono essere analizzati JavaScript, API Gateway potrebbe restituire una risposta 400. Applica $util.escapeJavaScript($input.json('$')) per garantire che l'JSONinput possa essere analizzato correttamente.

L'esempio precedente con $util.escapeJavaScript($input.json('$')) applied è il seguente:


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

In questo caso, l'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

JSONPathesempio di espressione

L'esempio seguente mostra come passare un'JSONPathespressione al json() metodo. Puoi anche leggere una sottosezione dell'oggetto del corpo della richiesta utilizzando un punto,., per specificare una proprietà:


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

Per una richiesta che include i parametri della stringa di query name=Bella&type=dog e il seguente corpo:


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

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

Se il payload di una richiesta di metodo contiene caratteri senza escape che non possono essere analizzati JavaScript, API Gateway potrebbe restituire una risposta. 400 Applica $util.escapeJavaScript() per garantire che l'JSONinput possa essere analizzato correttamente.

L'esempio precedente con $util.escapeJavaScript($input.json('$.Age')) applied è il seguente:


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

In questo caso, l'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

Esempio di richiesta e risposta

L'esempio seguente utilizza $input.params()$input.path(), e $input.json() per una risorsa con il percorso/things/{id}:


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

Per una richiesta che include il parametro path 123 e il seguente corpo:


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

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

L'esempio precedente con $util.escapeJavaScript($input.json('$.things')) applied è il seguente:


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

L'output di questo modello di mappatura dovrebbe essere simile al seguente:


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

Per ulteriori esempi di mappatura, consulta Modelli di mappatura per REST APIs.

`$stageVariables`

Le variabili di fase possono essere utilizzate nei modelli di mappatura e mappatura dei parametri e come segnaposto nelle ARNs integrazioni di metodi. URLs Per ulteriori informazioni, consulta Usa le variabili di fase per un REST API in API Gateway.

Sintassi	Descrizione
`$stageVariables.<variable_name>`, `$stageVariables['<variable_name>']` o `${stageVariables['<variable_name>']}`	`<variable_name>` rappresenta il nome di una variabile di fase.

`$util` Variabili

La variabile $util contiene funzioni di utilità da usare in modelli di mappatura.

Nota

Se non diversamente specificato, il set di caratteri predefinito è UTF -8.

Funzione	Descrizione
`$util.escapeJavaScript()`	Sfugge ai caratteri di una stringa utilizzando le regole delle JavaScript stringhe. Nota Questa funzione trasforma qualsiasi virgoletta singola (`'`) in virgoletta preceduta da un carattere escape (`\'`). Tuttavia, le virgolette singole con escape non sono valide in. JSON Pertanto, quando l'output di questa funzione viene utilizzato in una JSON proprietà, è necessario riconvertire le virgolette singole con escape (`\'`) in virgolette singole regolari (`'`). Questo viene mostrato nell'esempio seguente: `"input" : "$util.escapeJavaScript(data).replaceAll("\\'","'")"`
`$util.parseJson()`	Prende «stringified» JSON e restituisce una rappresentazione oggettuale del risultato. È possibile utilizzare il risultato di questa funzione per accedere e manipolare gli elementi del payload in modo nativo in Apache Velocity Template Language (). VTL Ad esempio, in presenza del payload seguente: `{"errorMessage":"{\"key1\":\"var1\",\"key2\":{\"arr\":[1,2,3]}}"}` E se usi il modello di mappatura seguente: `#set ($errorMessageObj = $util.parseJson($input.path('$.errorMessage'))) { "errorMessageObjKey2ArrVal" : $errorMessageObj.key2.arr[0] }` Otterrai l'output seguente: `{ "errorMessageObjKey2ArrVal" : 1 }`
`$util.urlEncode()`	Converte una stringa nel formato «application/». x-www-form-urlencoded
`$util.urlDecode()`	Decodifica una stringa «application/». x-www-form-urlencoded
`$util.base64Encode()`	Codifica i dati in una stringa con codifica base64.
`$util.base64Decode()`	Decodifica i dati da una stringa con codifica base64.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Comportamenti passthrough di integrazione

Risposte del gateway