Stai visualizzando la documentazione di Apigee Edge.
Consulta la
documentazione di Apigee X. info
Cosa
Questa policy ti consente di aggiungere codice JavaScript personalizzato che viene eseguito nel contesto di un flusso di proxy API. Nel codice JavaScript personalizzato, puoi utilizzare gli oggetti, i metodi e le proprietà del modello oggetto JavaScript di Apigee Edge. Il modello a oggetti consente di ottenere, impostare e rimuovere le variabili nel contesto del flusso del proxy. Puoi anche utilizzare le funzioni di crittografia di base fornite con il modello a oggetti.
Informazioni
Esistono molti casi d'uso per il criterio JavaScript. Ad esempio, puoi ottenere e impostare variabili di flusso, eseguire logica personalizzata ed eseguire la gestione degli errori, estrarre dati da richieste o risposte, modificare dinamicamente l'URL di destinazione backend e molto altro ancora. Queste norme ti consentono di implementare un comportamento personalizzato non coperto da altre norme standard di Edge. Infatti, puoi utilizzare un criterio JavaScript per ottenere molti degli stessi comportamenti implementati da altri criteri, come AssignMessage ed ExtractVariable.
Un caso d'uso che sconsigliamo per la norma JavaScript è la registrazione. Il criterio di registrazione dei messaggi è molto più adatto alla registrazione su piattaforme di logging di terze parti come Splunk, Sumo e Loggly e migliori le prestazioni del proxy API eseguendo il criterio di registrazione dei messaggi in PostClientFlow, che viene eseguito dopo che la risposta è stata inviata al client.
Il criterio JavaScript consente di specificare un file sorgente JavaScript da eseguire oppure
puoi includere il codice JavaScript direttamente nella configurazione del criterio con l'elemento <Source>.
In entrambi i casi, il codice JavaScript viene eseguito quando viene eseguito il passaggio a cui è collegato il criterio.
Per l'opzione del file sorgente, il codice sorgente viene sempre archiviato in una
posizione standard all'interno del bundle proxy: apiproxy/resources/jsc. In alternativa, puoi anche
memorizzare il codice sorgente in un file di risorse a livello di ambiente o organizzazione. Per
istruzioni, vedi File di risorse. Puoi anche caricare il codice JavaScript tramite l'editor proxy dell'interfaccia utente Apigee.
I file di origine JavaScript devono sempre avere un'estensione .js.
Consulta Software e versioni supportati per la versione attualmente supportata di JavaScript.
Video
Guarda un breve video per scoprire come creare un'estensione delle norme personalizzata utilizzando le norme JavaScript.
Esempi
Riscrivere l'URL di destinazione
Ecco un caso d'uso comune: estrarre dati dal corpo di una richiesta, memorizzarli in una variabile di flusso e utilizzare questa variabile di flusso altrove nel flusso del proxy. Supponiamo che tu abbia un'app in cui l'utente inserisce il proprio nome in un modulo HTML e lo invia. Vuoi che il proxy API estragga i dati del modulo e li aggiunga dinamicamente all'URL utilizzato per chiamare il servizio di backend. Come faresti in una policy JavaScript?
Nota:se vuoi provare questo esempio, presupponiamo che tu abbia creato un nuovo proxy nell'editor dei proxy. Quando lo crei, fornisci un URL del servizio di backend: http://www.example.com. Per questo esempio, riscriveremo l'URL di backend in modo dinamico. Se non sai come creare un nuovo proxy, consulta il tutorial introduttivo. .
- Nell'interfaccia utente Edge, apri il proxy che hai creato nell'editor proxy.
- Seleziona la scheda Sviluppa.
- Nel menu Nuovo, seleziona Nuovo script.
- Nella finestra di dialogo, seleziona JavaScript e assegna un nome allo script, ad esempio
js-example. - Incolla il seguente codice nell'editor di codice e salva il proxy. L'aspetto importante da
notare è l'oggetto
context. Questo oggetto è disponibile per il codice JavaScript in qualsiasi punto del flusso del proxy. Viene utilizzato per ottenere costanti specifiche del flusso, per chiamare metodi get/set utili e per altre operazioni. Questa parte dell'oggetto fa parte del modello a oggetti JavaScript di Edge. Tieni presente che la variabile di flussotarget.urlè una variabile integrata di lettura/scrittura accessibile nel flusso della richiesta target. Quando impostiamo questa variabile con l'URL dell'API, Edge effettua la chiamata di backend a questo URL. Abbiamo riscritto l'URL di destinazione originale, che era quello che hai specificato quando hai creato il proxy (ad es. http://www.example.com).
if (context.flow=="PROXY_REQ_FLOW") { var username = context.getVariable("request.formparam.user"); context.setVariable("info.username", username); } if (context.flow=="TARGET_REQ_FLOW") { context.setVariable("request.verb", "GET"); var name = context.getVariable("info.username"); var url = "http://mocktarget.apigee.net/" context.setVariable("target.url", url + "?user=" + name); }
- Nel menu Nuova norma, seleziona JavaScript.
- Assegna un nome alla norma, ad esempio
target-rewrite. Accetta i valori predefiniti e salva le norme. - Se selezioni Proxy Endpoint Preflow nel navigatore, vedrai che il criterio è stato aggiunto a questo flusso.
- Nel navigatore, seleziona l'icona Target Endpoint PreFlow.
- Dal navigatore, trascina la policy JavaScript sul lato Richiesta dell'endpoint di destinazione nell'editor del flusso.
- risparmia,
- Chiama l'API in questo modo, sostituendo il nome dell'organizzazione e il nome del proxy corretti in base alle tue esigenze:
curl -i -H 'Content-Type: application/x-www-form-urlencoded' -X POST -d 'user=Will' http://myorg-test.apigee.net/js-example
Infine, diamo un'occhiata alla definizione XML per i criteri JavaScript utilizzati in
questo esempio. La cosa importante da notare è che l'elemento <ResourceURL>
viene utilizzato per specificare il file di origine JavaScript da eseguire. Questo stesso pattern viene utilizzato
per qualsiasi file di origine JavaScript: jsc://filename.js. Se il codice JavaScript
richiede inclusioni, puoi utilizzare uno o più elementi <IncludeURL> per
eseguire questa operazione, come descritto più avanti in questo riferimento.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <Javascript async="false" continueOnError="false" enabled="true" timeLimit="200" name="target-rewrite"> <DisplayName>target-rewrite</DisplayName> <Properties/> <ResourceURL>jsc://js-example.js</ResourceURL> </Javascript>
Recuperare il valore della proprietà da JavaScript
Puoi aggiungere un elemento <Property> nella configurazione, quindi recuperare il valore dell'elemento con JavaScript in fase di runtime.
Utilizza l'attributo name dell'elemento per specificare il nome con cui accedere alla
proprietà dal codice JavaScript. Il valore dell'elemento <Property> (il valore
tra i tag di apertura e chiusura) è il valore letterale che verrà ricevuto da
JavaScript.
In JavaScript, recuperi il valore della proprietà della norma accedendovi come proprietà dell'oggetto
Properties, come nel seguente esempio:
- Configura la proprietà. In questo caso, il valore della proprietà è il nome della variabile
response.status.code.<Javascript async="false" continueOnError="false" enabled="true" timeLimit="200" name="JavascriptURLRewrite"> <DisplayName>JavascriptURLRewrite</DisplayName> <Properties> <Property name="source">response.status.code</Property> </Properties> <ResourceURL>jsc://JavascriptURLRewrite.js</ResourceURL> </Javascript>
- Recupera la proprietà con JavaScript. Qui, il valore recuperato, ovvero il nome di una variabile,
viene quindi utilizzato dalla funzione
getVariableper recuperare il valore della variabile.var responseCode = properties.source; // Returns "response.status.code" var value = context.getVariable(responseCode); // Get the value of response.status.code context.setVariable("response.header.x-target-response-code", value);
Gestione degli errori
Per esempi e una discussione sulle tecniche di gestione degli errori che puoi utilizzare in un callout JavaScript, consulta questo post nella community Apigee. I suggerimenti offerti nella community Apigee hanno solo scopo informativo e non rappresentano necessariamente le best practice consigliate da Apigee.
Riferimento elemento
Il riferimento all'elemento descrive gli elementi e gli attributi del criterio JavaScript.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <Javascript async="false" continueOnError="false" enabled="true" timeLimit="200" name="JavaScript-1"> <DisplayName>JavaScript 1</DisplayName> <Properties> <Property name="propName">propertyValue</Property> </Properties> <SSLInfo> <Enabled>trueFalse</Enabled> <ClientAuthEnabled>trueFalse</ClientAuthEnabled> <KeyStore>ref://keystoreRef</KeyStore> <KeyAlias>keyAlias</KeyAlias> <TrustStore>ref://truststoreRef</TrustStore> </SSLInfo> <IncludeURL>jsc://a-javascript-library-file</IncludeURL> <ResourceURL>jsc://my-javascript-source-file</ResourceURL> <Source>insert_js_code_here</Source> </Javascript>
Attributi <Javascript>
<Javascript name="Javascript-1" enabled="true" continueOnError="false" async="false" timeLimit="200">
I seguenti attributi sono specifici di queste norme.
| Attributo | Descrizione | Predefinito | Presenza |
|---|---|---|---|
| timeLimit |
Specifica il tempo massimo (in millisecondi) consentito per l'esecuzione dello script. Ad esempio, se viene superato un limite di 200 ms, il criterio genera questo errore:
Nota:per gli account di prova senza costi aggiuntivi, il tempo di esecuzione è limitato a 200 ms. |
N/D | Obbligatorio |
La tabella seguente descrive gli attributi comuni a tutti gli elementi principali del criterio:
| Attributo | Descrizione | Predefinito | Presenza |
|---|---|---|---|
name |
Il nome interno del criterio. Il valore dell'attributo Se vuoi, puoi utilizzare l'elemento |
N/D | Obbligatorio |
continueOnError |
Imposta il valore su Imposta su |
falso | Facoltativo |
enabled |
Imposta il valore su Imposta |
true | Facoltativo |
async |
Questo attributo è obsoleto. |
falso | Deprecato |
<DisplayName> elemento
Da utilizzare in aggiunta all'attributo name per etichettare il criterio in
editor proxy della UI di gestione con un nome diverso e in linguaggio naturale.
<DisplayName>Policy Display Name</DisplayName>
| Predefinito |
N/D Se ometti questo elemento, il valore dell'attributo |
|---|---|
| Presenza | Facoltativo |
| Tipo | Stringa |
Elemento <IncludeURL>
Specifica un file di libreria JavaScript da caricare come dipendenza del file JavaScript principale
specificato con l'elemento <ResourceURL> o <Source>. Gli script verranno valutati nell'ordine in cui sono elencati nel criterio. Il codice può utilizzare gli oggetti, i metodi e le proprietà del modello oggetto JavaScript.
Includi più di una risorsa di dipendenza JavaScript con elementi <IncludeURL> aggiuntivi.
<IncludeURL>jsc://my-javascript-dependency.js</IncludeURL>
| Predefinito: | Nessuno |
| Presenza: | Facoltativo |
| Tipo: | Stringa |
Esempio
Consulta l'esempio di base nella sezione Esempi.
Elemento <Property>
Specifica una proprietà a cui puoi accedere dal codice JavaScript in fase di runtime.
<Properties> <Property name="propName">propertyValue</Property> </Properties>
| Predefinito: | Nessuno |
| Presenza: | Facoltativo |
| Tipo: | Stringa |
Attributi
| Attributo | Descrizione | Predefinito | Presenza |
|---|---|---|---|
| nome |
Specifica il nome della proprietà. |
N/D | Obbligatorio. |
Esempio
Vedi l'esempio nella sezione Esempi.
Elemento <ResourceURL>
Specifica il file JavaScript principale che verrà eseguito nel flusso dell'API. Puoi archiviare questo file
nell'ambito del proxy API (in /apiproxy/resources/jsc nel bundle del proxy API o nella
sezione Script del riquadro di navigazione dell'editor del proxy API) oppure negli ambiti dell'organizzazione o
dell'ambiente per il riutilizzo in più proxy API, come descritto in File di risorse. Il codice può utilizzare gli oggetti,
i metodi e le proprietà del modello oggetto JavaScript.
<ResourceURL>jsc://my-javascript.js</ResourceURL>
| Predefinito: | Nessuno |
| Presenza: | È obbligatorio specificare <ResourceURL> o <Source>. Se sono presenti sia <ResourceURL> che <Source>, <ResourceURL> viene ignorato. |
| Tipo: | Stringa |
Esempio
Consulta l'esempio di base nella sezione Esempi.
Elemento <Source>
Consente di inserire JavaScript direttamente nella configurazione XML del criterio. Il codice JavaScript inserito viene eseguito quando il criterio viene eseguito nel flusso API.
| Predefinito: | Nessuno |
| Presenza: | È obbligatorio specificare <ResourceURL> o <Source>. Se sono presenti sia <ResourceURL> che <Source>, <ResourceURL> viene ignorato. |
| Tipo: | Stringa |
Esempio
<Javascript name='JS-ParseJsonHeaderFullString' timeLimit='200' > <Properties> <Property name='inboundHeaderName'>specialheader</Property> <Property name='outboundVariableName'>json_stringified</Property> </Properties> <Source> var varname = 'request.header.' + properties.inboundHeaderName + '.values.string'; var h = context.getVariable(varname); if (h) { h = JSON.parse(h); h.augmented = (new Date()).valueOf(); var v = JSON.stringify(h, null, 2) + '\n'; // further indent var r = new RegExp('^(\S*)','mg'); v= v.replace(r,' $1'); context.setVariable(properties.outboundVariableName, v); } </Source> </Javascript>
Elemento <SSLInfo>
Specifica le proprietà utilizzate per configurare TLS per tutte le istanze client HTTP create dal criterio JavaScript.
<SSLInfo> <Enabled>trueFalse</Enabled> <ClientAuthEnabled>trueFalse</ClientAuthEnabled> <KeyStore>ref://keystoreRef</KeyStore> <KeyAlias>keyAlias</KeyAlias> <TrustStore>ref://truststoreRef</TrustStore> </SSLInfo>
| Predefinito: | Nessuno |
| Presenza: | Facoltativo |
| Tipo: | Stringa |
La procedura di configurazione di TLS per un client HTTP è la stessa che utilizzi per configurare TLS per un TargetEndpoint/TargetServer. Per ulteriori informazioni, consulta Configurazione di TLS da Edge al backend.
Note sull'utilizzo
Una policy JavaScript non contiene codice effettivo. Un criterio JavaScript fa invece riferimento a una
"risorsa" JavaScript e definisce il passaggio nel flusso API in cui viene eseguito JavaScript. Puoi
caricare lo script tramite l'editor proxy dell'interfaccia utente di gestione oppure puoi includerlo nella
directory /resources/jsc nei proxy API che sviluppi localmente.
Debug del codice del criterio JavaScript
Utilizza la funzione print() per visualizzare le informazioni di debug nel riquadro di output della transazione nello strumento Trace. Per dettagli ed esempi, vedi le istruzioni di debug con JavaScript print().
Per visualizzare le istruzioni di stampa in Trace:
- Apri lo strumento di tracciamento e avvia una sessione di tracciamento per un proxy che contiene la tua policy JavaScript.
- Chiama il proxy.
- Nello strumento di tracciamento, fai clic su Output di tutte le transazioni per aprire il riquadro
dell'output.

- I tuoi estratti conto stampati verranno visualizzati in questo riquadro.
Puoi utilizzare la funzione print() per inviare informazioni di debug allo strumento Trace. Questa funzione è disponibile direttamente tramite il modello a oggetti JavaScript. Per maggiori dettagli, vedi Eseguire il debug di JavaScript con le istruzioni print().
Variabili di flusso
Questo criterio non compila alcuna variabile per impostazione predefinita. Tuttavia, puoi impostare (e ottenere) le variabili di flusso nel codice JavaScript chiamando i metodi sull'oggetto contesto. Un pattern tipico è simile a questo:
context.setVariable("response.header.X-Apigee-Target", context.getVariable("target.name"))
L'oggetto contesto fa parte del modello oggetto JavaScript di Apigee Edge.
Messaggi di errore
This section describes the fault codes and error messages that are returned and fault variables that are set by Edge when this policy triggers an error. This information is important to know if you are developing fault rules to handle faults. To learn more, see What you need to know about policy errors and Handling faults.
Runtime errors
These errors can occur when the policy executes.
| Fault code | HTTP status | Cause | Fix |
|---|---|---|---|
steps.javascript.ScriptExecutionFailed |
500 | The JavaScript policy can throw many different types of ScriptExecutionFailed errors. Commonly seen types of errors include RangeError, ReferenceError, SyntaxError, TypeError, and URIError. | build |
steps.javascript.ScriptExecutionFailedLineNumber |
500 | An error occurred in the JavaScript code. See the fault string for details. | N/A |
steps.javascript.ScriptSecurityError |
500 | A security error occurred when the JavaScript executed. See the fault string for details. | N/A |
Deployment errors
These errors can occur when you deploy a proxy containing this policy.
| Error name | Cause | Fix |
|---|---|---|
InvalidResourceUrlFormat |
If the format of the resource URL specified within the <ResourceURL> or the <IncludeURL> element of the JavaScript policy is invalid, then the deployment of the API proxy fails. |
build |
InvalidResourceUrlReference |
If the <ResourceURL> or the <IncludeURL> elements
refer to a JavaScript file that does not exist, then the deployment of the API proxy fails.
The referenced source file must exist either the API proxy, environment, or organization level. |
build |
WrongResourceType |
This error occurs during deployment if the <ResourceURL> or the <IncludeURL>
elements of the JavaScript policy refer to any resource type other than jsc (JavaScript file). |
build |
NoResourceURLOrSource |
The deployment of the JavaScript policy can fail with this error if the <ResourceURL>
element is not declared or if the resource URL is not defined within this element.
<ResourceURL> element is a mandatory element. Or, The <IncludeURL> element is declared
but the resource URL is not defined within this element. The <IncludeURL> element is optional
but if declared, the resource URL must be specified within the <IncludeURL> element. |
build |
Fault variables
These variables are set when this policy triggers an error at runtime. For more information, see What you need to know about policy errors.
| Variables | Where | Example |
|---|---|---|
fault.name="fault_name" |
fault_name is the name of the fault, as listed in the Runtime errors table above. The fault name is the last part of the fault code. | fault.name Matches "ScriptExecutionFailed" |
javascript.policy_name.failed |
policy_name is the user-specified name of the policy that threw the fault. | javascript.JavaScript-1.failed = true |
Example error response
{ "fault": { "faultstring": "Execution of SetResponse failed with error: Javascript runtime error: "ReferenceError: "status" is not defined. (setresponse.js:6)\"", "detail": { "errorcode": "steps.javascript.ScriptExecutionFailed" } } }
Example fault rule
<FaultRule name="JavaScript Policy Faults"> <Step> <Name>AM-CustomErrorResponse</Name> <Condition>(fault.name Matches "ScriptExecutionFailed") </Condition> </Step> <Condition>(javascript.JavaScript-1.failed = true) </Condition> </FaultRule>
Schema
Ogni tipo di policy è definito da uno schema XML (.xsd). Per riferimento, gli schemi delle policy
sono disponibili su GitHub.
Argomenti correlati
- Modello oggetto JavaScript
- Per istruzioni, esempi di criteri ed esempi JavaScript, consulta Programmazione di proxy API con JavaScript.
Articoli della community Apigee
Puoi trovare questi articoli correlati nella community Apigee: