Sie sehen die Apigee Edge-Dokumentation.
Rufen Sie die Apigee X-Dokumentation auf. weitere Informationen
Edge Microgateway Version 3.3.x
Zielgruppe
Dieses Thema richtet sich an Entwickler, die Edge Microgateway-Features durch das Schreiben benutzerdefinierter Plug-ins erweitern möchten. Wenn Sie ein neues Plug-in schreiben möchten, müssen Sie mit JavaScript und Node.js vertraut sein.
Was ist ein benutzerdefiniertes Edge Microgateway-Plug-in?
Ein Plug-in ist ein Node.js-Modul, das Edge Microgateway-Funktionen erweitert. Plug-in-Module folgen einem einheitlichen Muster und werden an einem Ort gespeichert, der Edge Microgateway bekannt ist, damit sie automatisch erkannt und ausgeführt werden können. Wenn Sie Edge Microgateway installieren, werden mehrere vordefinierte Plug-ins bereitgestellt. Dazu gehören Plug-ins für Authentifizierung, Spike Arrest, Kontingente und Analysen. Eine Beschreibung dieser vorhandenen Plug-ins finden Sie unter Plug-ins verwenden.
Sie können dem Mikrogateway neue Features und Funktionen hinzufügen, indem Sie benutzerdefinierte Plug-ins schreiben. Standardmäßig ist Edge Microgateway im Wesentlichen ein sicherer Passthrough-Proxy, der Anfragen und Antworten unverändert an und von Zieldiensten weiterleitet. Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen und Antworten interagieren, die durch das Mikrogateway gesendet werden.
Benutzerdefinierten Plug-in-Code einfügen
Ein Ordner für benutzerdefinierte Plug-ins ist hier Teil der Edge Microgateway-Installation:
[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins
Dabei ist [prefix]
das Präfixverzeichnis npm
, wie unter Edge Microgateway installieren unter „Wo ist Edge Microgateway installiert“ beschrieben.
Sie können dieses Standard-Plug-in-Verzeichnis ändern. Weitere Informationen finden Sie unter Plug-ins finden.
Vordefinierte Plug-ins überprüfen
Bevor Sie versuchen, ein eigenes Plug-in zu entwickeln, sollten Sie prüfen, ob keines der vordefinierten Plug-ins Ihren Anforderungen entspricht. Sie finden diese Plug-ins hier:
[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins
Dabei ist [prefix]
das Präfixverzeichnis npm
. Weitere Informationen finden Sie unter Edge Microgateway installieren im Abschnitt „Wo ist Edge Microgateway installiert?“.
Weitere Informationen finden Sie unter Vordefinierte Plug-ins für Edge Microgateway.
Einfaches Plug-in schreiben
In diesem Abschnitt werden die Schritte zum Erstellen eines einfachen Plug-ins beschrieben. Dieses Plug-in überschreibt die Antwortdaten (je nachdem, welche Art von Daten sie sind) mit dem String „Hello, World!“ und gibt sie im Terminal aus.
- Wenn Edge Microgateway ausgeführt wird, beenden Sie es jetzt:
edgemicro stop
-
cd
zum benutzerdefinierten Plug-in-Verzeichnis:cd [prefix]/lib/node_modules/edgemicro/plugins
Dabei ist
[prefix]
das Präfixverzeichnisnpm
, wie unter Edge Microgateway installieren unter „Wo ist Edge Microgateway installiert“ beschrieben. - Erstellen Sie ein neues Plug-in-Projekt mit dem Namen response-override und
cd
:
mkdir response-override && cd response-override
- Erstellen Sie ein neues Node.js-Projekt:
npm init
Drücken Sie mehrmals die Eingabetaste, um die Standardwerte zu übernehmen. - Erstellen Sie mit einem Texteditor eine neue Datei mit dem Namen
index.js
. - Kopieren Sie den folgenden Code in
index.js
und speichern Sie die Datei.
'use strict'; var debug = require('debug') module.exports.init = function(config, logger, stats) { return { ondata_response: function(req, res, data, next) { debug('***** plugin ondata_response'); next(null, null); }, onend_response: function(req, res, data, next) { debug('***** plugin onend_response'); next(null, "Hello, World!\n\n"); } }; }
- Jetzt haben Sie ein Plug-in erstellt und müssen es der Edge Microgateway-Konfiguration hinzufügen.
Öffnen Sie die Datei
$HOME/.edgemicro/[org]-[env]-config.yaml
, wobeiorg
undenv
Ihre Edge-Organisations- und Umgebungsnamen sind. - Fügen Sie dem
plugins:sequence
-Element das Plug-inresponse-override
hinzu, wie unten gezeigt.
... plugins: dir: ../plugins sequence: - oauth - response-override ...
- Starten Sie Edge Microgateway neu.
- Rufen Sie eine API über Edge Microgateway auf. Bei diesem API-Aufruf wird davon ausgegangen, dass Sie die gleiche Konfiguration wie in der Anleitung mit API-Schlüsselsicherheit eingerichtet haben, wie unter Edge Microgateway einrichten und konfigurieren beschrieben:
curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo Hello, World!
Aufbau eines Plug-ins
Das folgende Beispiel-Plug-in für Edge Microgateway veranschaulicht das Muster, das bei der Entwicklung eigener Plug-ins zu befolgen ist. Der Quellcode für das in diesem Abschnitt beschriebene Beispiel-Plug-in befindet sich im plugins/header-uppercase/index.js.
- Plug-ins sind Standard-NPM-Module mit einem
package.json
undindex.js
im Stammordner. - Ein Plug-in muss eine init()-Funktion exportieren.
- Die Funktion init() verwendet drei Argumente: config, logger und stats. Diese Argumente werden in den Argumenten der Plug-in-Funktion init() beschrieben.
- init() gibt ein Objekt mit benannten Funktions-Handlern zurück, die aufgerufen werden, wenn bestimmte Ereignisse während der Lebensdauer einer Anfrage auftreten.
Event-Handler-Funktionen
Ein Plug-in muss einige oder alle dieser Ereignis-Handler-Funktionen implementieren. Die Implementierung dieser Funktionen liegt bei Ihnen. Jede Funktion ist optional und ein typisches Plug-in implementiert mindestens einen Teil dieser Funktionen.
Ablaufereignis-Handler anfordern
Diese Funktionen werden bei Anfrageereignissen in Edge Microgateway aufgerufen.
onrequest
ondata_request
onend_request
onclose_request
onerror_request
onrequest
-Funktion
Wird zu Beginn der Clientanfrage aufgerufen. Diese Funktion wird ausgelöst, wenn das erste Byte der Anfrage von Edge Microgateway empfangen wird. Mit dieser Funktion erhalten Sie Zugriff auf die Anfrageheader, die URL, die Abfrageparameter und die HTTP-Methode. Wenn Sie als Nächstes mit einem wahrheitsgemäßen ersten Argument aufrufen (z. B. einer Fehlerinstanz), wird die Anfrageverarbeitung beendet und keine Zielanfrage initiiert.
Beispiel:
onrequest: function(req, res, next) { debug('plugin onrequest'); req.headers['x-foo-request-start'] = Date.now(); next(); }
ondata_request
-Funktion
Wird aufgerufen, wenn ein Datenblock vom Client empfangen wird. Übergibt Anfragedaten an das nächste Plug-in in der Plug-in-Sequenz. Der vom letzten Plug-in in der Sequenz zurückgegebene Wert wird an das Ziel gesendet. Ein typischer Anwendungsfall (siehe unten) besteht darin, die Anfragedaten vor dem Senden an das Ziel zu transformieren.
Beispiel:
ondata_request: function(req, res, data, next) { debug('plugin ondata_request ' + data.length); var transformed = data.toString().toUpperCase(); next(null, transformed); }
onend_request
-Funktion
Wird aufgerufen, wenn alle Anfragedaten vom Client empfangen wurden.
Beispiel:
onend_request: function(req, res, data, next) { debug('plugin onend_request'); next(null, data); }
onclose_request
-Funktion
Gibt an, dass die Clientverbindung beendet wurde. Sie können diese Funktion in Fällen verwenden, in denen die Clientverbindung unzuverlässig ist. Sie wird aufgerufen, wenn die Socket-Verbindung zum Client beendet wird.
Beispiel:
onclose_request: function(req, res, next) { debug('plugin onclose_request'); next(); }
onerror_request
-Funktion
Wird aufgerufen, wenn beim Empfang der Clientanfrage ein Fehler auftritt.
Beispiel:
onerror_request: function(req, res, err, next) { debug('plugin onerror_request ' + err); next(); }
Event-Handler für Antwortfluss
Diese Funktionen werden bei Antwortereignissen in Edge Microgateway aufgerufen.
onresponse
ondata_response
onend_response
onclose_response
onerror_response
onresponse
-Funktion
Wird zu Beginn der Zielantwort aufgerufen. Diese Funktion wird ausgelöst, wenn das erste Byte der Antwort von Edge Microgateway empfangen wird. Mit dieser Funktion erhalten Sie Zugriff auf die Antwortheader und den Statuscode.
Beispiel:
onresponse: function(req, res, next) { debug('plugin onresponse'); res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start']) next(); }
ondata_response
-Funktion
Wird aufgerufen, wenn ein Datenblock vom Ziel empfangen wird.
Beispiel:
ondata_response: function(req, res, data, next) { debug('plugin ondata_response ' + data.length); var transformed = data.toString().toUpperCase(); next(null, transformed); }
onend_response
-Funktion
Wird aufgerufen, wenn alle Antwortdaten vom Ziel empfangen wurden.
Beispiel:
onend_response: function(req, res, data, next) { debug('plugin onend_response'); next(null, data); }
onclose_response
-Funktion
Gibt an, dass die Zielverbindung geschlossen wurde. Sie können diese Funktion in Fällen verwenden, in denen die Zielverbindung unzuverlässig ist. Sie wird aufgerufen, wenn die Socket-Verbindung zum Ziel beendet wurde.
Beispiel:
onclose_response: function(req, res, next) { debug('plugin onclose_response'); next(); }
onerror_response
-Funktion
Wird aufgerufen, wenn beim Empfang der Zielantwort ein Fehler auftritt.
Beispiel:
onerror_response: function(req, res, err, next) { debug('plugin onerror_response ' + err); next(); }
Wissenswertes zu den Plug-in-Event-Handler-Funktionen
Plug-in-Event-Handler-Funktionen werden als Reaktion auf bestimmte Ereignisse aufgerufen, die auftreten, während Edge Microgateway eine bestimmte API-Anfrage verarbeitet.
- Jeder der init()-Funktions-Handler (ondata_request, ondata_response usw.) muss nach der Verarbeitung den next()-Callback aufrufen. Wenn Sie next() nicht aufrufen, wird die Verarbeitung beendet und die Anfrage bleibt hängen.
- Das erste Argument für next() ist möglicherweise ein Fehler, der dazu führt, dass die Anfrageverarbeitung beendet wird.
- Die Handler ondata_ und onend_ müssen next() mit einem zweiten Argument aufrufen, das die Daten enthält, die an das Ziel oder den Client übergeben werden sollen. Dieses Argument kann null sein, wenn das Plug-in zwischengespeichert wird und derzeit nicht genügend Daten zur Transformation vorhanden sind.
- Für alle Anfragen und Antworten wird eine einzelne Instanz des Plug-ins verwendet. Wenn ein Plug-in den Anfragestatus zwischen Aufrufen beibehalten möchte, kann es diesen Status in einem Attribut speichern, das dem bereitgestellten request-Objekt (req) hinzugefügt wird. Seine Lebensdauer ist die Dauer des API-Aufrufs.
- Achten Sie darauf, alle Fehler abzufangen und next() mit dem Fehler aufzurufen. Wenn next() nicht aufgerufen wird, bleibt der API-Aufruf hängen.
- Achten Sie darauf, dass keine Speicherlecks entstehen, da diese die Gesamtleistung von Edge Microgateway beeinträchtigen und zum Absturz führen können, wenn nicht genügend Arbeitsspeicher vorhanden ist.
- Folgen Sie dem Node.js-Modell und führen Sie keine rechenintensiven Aufgaben im Hauptthread aus, da dies die Leistung von Edge Microgateway beeinträchtigen kann.
Über die Plug-in-Funktion init()
In diesem Abschnitt werden die Argumente beschrieben, die an die Funktion init() übergeben werden: config, logger und stats.
config
Konfigurationsdaten, die durch Zusammenführen der Edge Microgateway-Konfigurationsdatei mit den von Apigee Edge heruntergeladenen Daten abgerufen werden, werden in einem Objekt mit dem Namen config
abgelegt.
Um einem Plug-in namens response-override einen Konfigurationsparameter namens param mit dem Wert foo hinzuzufügen, fügen Sie Folgendes in die Datei default.yaml
ein:
response-override: param: foo
Anschließend können Sie wie folgt im Plug-in-Code auf den Parameter zugreifen:
// Called when response data is received ondata_response: function(req, res, data, next) { debug('***** plugin ondata_response'); debug('***** plugin ondata_response: config.param: ' + config.param); next(null, data); },
In diesem Fall wird in der Debug-Ausgabe des Plug-ins „foo“ ausgegeben:
Sun, 13 Dec 2015 21:25:08 GMT plugin:response-override ***** plugin ondata_response: config.param: foo
Sie können im untergeordneten Objekt config.emgConfigs
auf die zusammengeführte Mikrogateway-Konfiguration zugreifen und Apigee Edge-Daten herunterladen. So können Sie beispielsweise in der Funktion init
auf diese Konfigurationsdaten zugreifen:
module.exports.init = function(config, logger, stats) { let emgconfigs = config.emgConfigs;
Unten siehst du ein Beispiel für Daten, die emgConfigs
enthalten:
{ edgemicro: { port: 8000, max_connections: 1000, config_change_poll_interval: 600, logging: { level: 'error', dir: '/var/tmp', stats_log_interval: 60, rotate_interval: 24, stack_trace: false }, plugins: { sequence: [Array] }, global: { org: 'Your Org', env: 'test' } }, headers: { 'x-forwarded-for': true, 'x-forwarded-host': true, 'x-request-id': true, 'x-response-time': true, via: true }, proxies: [ { max_connections: 1000, name: 'edgemicro_delayed', revision: '1', proxy_name: 'default', base_path: '/edgemicro_delayed', target_name: 'default', url: 'https://httpbin.org/delay/10', timeout: 0 } ], product_to_proxy: { EdgeMicroTestProduct: [ 'edgemicro-auth','edgemicro_delayed',] }, product_to_scopes: {prod4: [ 'Admin', 'Guest', 'Student' ] }, product_to_api_resource: { EdgeMicroTestProduct: [ '/*' ] }, _hash: 0, keys: { key: 'Your key', secret: 'Your key ' }, uid: 'Internally generated uuid', targets: [] }
logger
Der Systemprotokollierungs-Tool. Der aktuell verwendete Logger exportiert diese Funktionen, wobei das Objekt ein String, eine HTTP-Anfrage, eine HTTP-Antwort oder eine Fehlerinstanz sein kann.
info(object, message)
warn(object, message)
error(object, message)
trace(object, message)
debug(object, message)
stats
Ein Objekt, das die Anzahl der Anfragen, Antworten, Fehler und andere aggregierte Statistiken in Bezug auf die Anfragen und Antworten enthält, die durch eine Mikrogateway-Instanz gesendet werden.
- treqErrors – Die Anzahl der Zielanfragen mit Fehlern.
- treqErrors – Anzahl der Zielantworten mit Fehlern.
- statusCodes – Ein Objekt, das die Anzahl der Antwortcodes enthält:
{ 1: number of target responses with 1xx response codes 2: number of target responses with 2xx response codes 3: number of target responses with 3xx response codes 4: number of target responses with 4xx response codes 5: number of target responses with 5xx response codes }
- requests – Die Gesamtzahl der Anfragen.
- responses – Die Gesamtzahl der Antworten.
- connections – Die Anzahl der aktiven Zielverbindungen.
Über die Funktion next()
Alle Plug-in-Methoden müssen next()
aufrufen, um die nächste Methode in der Serie weiter zu verarbeiten. Andernfalls bleibt der Plug-in-Prozess hängen. Im Lebenszyklus der Anfrage wird onrequest() zuerst aufgerufen. Als Nächstes wird die Methode ondata_request()
aufgerufen. ondata_request
wird jedoch nur dann aufgerufen, wenn die Anfrage Daten enthält, wie z. B. bei einer POST-Anfrage. Die nächste aufgerufene Methode ist onend_request()
, die aufgerufen wird, wenn die Anfrageverarbeitung abgeschlossen ist. Die onerror_*
-Funktionen werden nur im Fehlerfall aufgerufen. Sie können die Fehler bei Bedarf mit benutzerdefiniertem Code verarbeiten.
Angenommen, in der Anfrage werden Daten gesendet und ondata_request()
wird aufgerufen. Die Funktion ruft next()
mit zwei Parametern auf:
next(null, data);
Konventionsgemäß wird der erste Parameter zur Übermittlung von Fehlerinformationen verwendet, die Sie dann in einer nachfolgenden Funktion in der Kette verarbeiten können. Wenn Sie es auf null
, ein falsches Argument, setzen, sagen wir, dass keine Fehler vorliegen und die Anfrageverarbeitung normal fortgesetzt werden sollte. Wenn dieses Argument wahrheitsgemäß ist (z. B. bei einem Fehlerobjekt), wird die Verarbeitung der Anfrage beendet und die Anfrage an das Ziel gesendet.
Der zweite Parameter übergibt die Anforderungsdaten an die nächste Funktion in der Kette. Wenn Sie keine weitere Verarbeitung ausführen, werden die Anfragedaten unverändert an das Ziel der API übergeben.
Sie haben jedoch die Möglichkeit, die Anfragedaten innerhalb dieser Methode zu ändern und die geänderte Anfrage an das Ziel zu übergeben. Wenn die Anfragedaten beispielsweise XML sind und das Ziel JSON erwartet, können Sie der Methode ondata_request()
Code hinzufügen, der (a) den Inhaltstyp des Anfrageheaders in application/json
ändert und die Anfragedaten mit einem beliebigen Zweck in JSON konvertiert. Sie können beispielsweise einen Node.js-Konverter xml2json verwenden, der von NPM abgerufen wird.
So könnte das aussehen:
ondata_request: function(req, res, data, next) { debug('****** plugin ondata_request'); var translated_data = parser.toJson(data); next(null, translated_data); },
In diesem Fall werden die Anfragedaten (wobei angenommen wird, dass es sich um XML handelt) in JSON konvertiert und die transformierten Daten über next()
an die nächste Funktion in der Anfragekette übergeben, bevor sie an das Back-End-Ziel übergeben werden.
Sie können eine weitere Debug-Anweisung hinzufügen, um die transformierten Daten zu Fehlerbehebungszwecken auszugeben. Beispiel:
ondata_request: function(req, res, data, next) { debug('****** plugin ondata_request'); var translated_data = parser.toJson(data); debug('****** plugin ondata_response: translated_json: ' + translated_json); next(null, translated_data); },
Ausführungsreihenfolge von Plug-in-Handlern
Wenn Sie Plug-ins für Edge Microgateway schreiben, müssen Sie wissen, in welcher Reihenfolge Plug-in-Event-Handler ausgeführt werden.
Sie sollten unbedingt daran denken, dass beim Angeben einer Plug-in-Sequenz in der Edge Microgateway-Konfigurationsdatei die Anfrage-Handler in aufsteigender Reihenfolge ausgeführt werden, während die Antwort-Handler in absteigender Reihenfolge ausgeführt werden.
Das folgende Beispiel soll Ihnen das Verständnis dieser Ausführungssequenz verdeutlichen.
1. Drei einfache Plug-ins erstellen
Sehen Sie sich das folgende Plug-in an. Sie gibt lediglich die Konsolenausgabe aus, wenn ihre Event-Handler aufgerufen werden:
plugins/plugin-1/index.js
module.exports.init = function(config, logger, stats) { return { onrequest: function(req, res, next) { console.log('plugin-1: onrequest'); next(); }, onend_request: function(req, res, data, next) { console.log('plugin-1: onend_request'); next(null, data); }, ondata_response: function(req, res, data, next) { console.log('plugin-1: ondata_response ' + data.length); next(null, data); }, onend_response: function(req, res, data, next) { console.log('plugin-1: onend_response'); next(null, data); } }; }
Erwägen Sie nun, zwei weitere Plug-ins, plugin-2
und plugin-3
, mit demselben Code zu erstellen (außer Ändern Sie die console.log()
-Anweisungen entsprechend zu plugin-2
und plugin-3
).
2. Plug-in-Code überprüfen
Die exportierten Plug-in-Funktionen in <microgateway-root-dir>/plugins/plugin-1/index.js
sind Event-Handler, die zu bestimmten Zeiten während der Verarbeitung von Anfragen und Antworten ausgeführt werden. Beispielsweise führt onrequest
das erste Byte der empfangenen Anfrageheader aus. Allerdings wird onend_response
ausgeführt, nachdem das letzte Byte an Antwortdaten empfangen wurde.
Sehen Sie sich den Handler „ondata_response“ an. Er wird immer dann aufgerufen, wenn ein Teil von Antwortdaten empfangen wird. Wichtig ist, dass die Antwortdaten nicht unbedingt auf einmal empfangen werden. Vielmehr können die Daten in Blöcken beliebiger Länge empfangen werden.
3. Plug-ins der Plug-in-Sequenz hinzufügen
In diesem Beispiel fügen wir die Plug-ins der Plug-in-Sequenz in der Edge Microgateway-Konfigurationsdatei (~./edgemicro/config.yaml
) wie folgt hinzu. Die Reihenfolge ist wichtig. Sie definiert die Reihenfolge, in der die Plug-in-Handler ausgeführt werden.
plugins: dir: ../plugins sequence: - plugin-1 - plugin-2 - plugin-3
4. Debug-Ausgabe untersuchen
Sehen wir uns nun die Ausgabe an, die beim Aufruf dieser Plug-ins erzeugt wird. Hier sind einige wichtige Punkte zu beachten:
- Die Plug-in-Sequenz der Edge Microgateway-Konfigurationsdatei (
~./edgemicro/config.yaml
) gibt die Reihenfolge an, in der Event-Handler aufgerufen werden. - Anfrage-Handler werden in aufsteigender Reihenfolge (in der Reihenfolge, in der sie in der Plug-in-Sequenz angezeigt werden) aufgerufen: 1, 2, 3.
- Antwort-Handler werden in absteigender Reihenfolge aufgerufen: 3, 2, 1.
- Der Handler
ondata_response
wird für jeden ankommenden Datenblock einmal aufgerufen. In diesem Beispiel (Ausgabe unten) werden zwei Blöcke empfangen.
Hier ist ein Beispiel für eine Debug-Ausgabe, die erstellt wird, wenn diese drei Plug-ins verwendet und eine Anfrage über Edge Microgateway gesendet wird. Beachten Sie die Reihenfolge, in der die Handler aufgerufen werden:
plugin-1: onrequest plugin-2: onrequest plugin-3: onrequest plugin-1: onend_request plugin-2: onend_request plugin-3: onend_request plugin-3: ondata_response 931 plugin-2: ondata_response 931 plugin-1: ondata_response 931 plugin-3: ondata_response 1808 plugin-3: onend_response plugin-2: ondata_response 1808 plugin-2: onend_response plugin-1: ondata_response 1808 plugin-1: onend_response
Zusammenfassung
Wenn Sie benutzerdefinierte Plug-in-Funktionen wie das Sammeln und Transformieren von Anfrage- oder Antwortdaten implementieren möchten, ist es sehr wichtig zu wissen, in welcher Reihenfolge Plug-in-Handler aufgerufen werden.
Denken Sie daran, dass Anfrage-Handler in der Reihenfolge ausgeführt werden, in der die Plug-ins in der Edge Microgateway-Konfigurationsdatei angegeben sind. Antwort-Handler werden in umgekehrter Reihenfolge ausgeführt.
Globale Variablen in Plug-ins verwenden
Jede Anfrage an Edge Microgateway wird an dieselbe Instanz eines Plug-ins gesendet. Daher überschreibt der Status einer zweiten Anfrage von einem anderen Client die erste. Der einzige sichere Ort zum Speichern des Plug-in-Status ist das Speichern des Status in einem Attribut des Anfrage- oder Antwortobjekts, dessen Lebensdauer auf diejenige der Anfrage beschränkt ist.
Ziel-URLs in Plug-ins neu schreiben
Hinzugefügt in: v2.3.3
Sie können die Standard-Ziel-URL in einem Plug-in dynamisch überschreiben, indem Sie die folgenden Variablen im Plug-in-Code ändern: req.targetHostname und req.targetPath.
Hinzugefügt in: v2.4.x
Sie können auch den Port des Zielendpunkts überschreiben und zwischen HTTP und HTTPS auswählen. Ändern Sie diese Variablen im Plug-in-Code: req.targetPort und req.targetSecure. Wenn Sie HTTPS auswählen möchten, setzen Sie req.targetSecure auf true und für HTTP auf false. Wenn Sie „req.targetSecure“ auf „true“ setzen, finden Sie in diesem Diskussionsthread weitere Informationen.
Beispiel-Plug-ins
Diese Plug-ins werden mit Ihrer Edge Microgateway-Installation bereitgestellt. Sie finden sie hier in der Edge Microgateway-Installation:
[prefix]/lib/node_modules/edgemicro/plugins
Dabei ist [prefix]
das Präfixverzeichnis npm
, wie unter Edge Microgateway installieren unter „Wo ist Edge Microgateway installiert“ beschrieben.
Anfrage akkumulieren
Dieses Plug-in sammelt Datenblöcke vom Client in einem Array-Attribut, das an das Anfrageobjekt angehängt ist. Wenn alle Anfragedaten empfangen wurden, wird das Array zu einem Puffer verkettet, der dann an das nächste Plug-in in der Sequenz übergeben wird. Dieses Plug-in sollte das erste Plug-in in der Sequenz sein, damit nachfolgende Plug-ins die akkumulierten Anfragedaten erhalten.
module.exports.init = function(config, logger, stats) { function accumulate(req, data) { if (!req._chunks) req._chunks = []; req._chunks.push(data); } return { ondata_request: function(req, res, data, next) { if (data && data.length > 0) accumulate(req, data); next(null, null); }, onend_request: function(req, res, data, next) { if (data && data.length > 0) accumulate(req, data); var content = null; if (req._chunks && req._chunks.length) { content = Buffer.concat(req._chunks); } delete req._chunks; next(null, content); } }; }
Akkumulatoren-Antwort
Dieses Plug-in sammelt Datenblöcke aus dem Ziel in einem Array-Attribut, das an das Antwortobjekt angehängt ist. Wenn alle Antwortdaten empfangen wurden, wird das Array zu einem Puffer verkettet, der dann an das nächste Plug-in in der Sequenz übergeben wird. Da dieses Plug-in mit Antworten arbeitet, die in umgekehrter Reihenfolge verarbeitet werden, sollten Sie es als letztes Plug-in in der Reihenfolge platzieren.
module.exports.init = function(config, logger, stats) { function accumulate(res, data) { if (!res._chunks) res._chunks = []; res._chunks.push(data); } return { ondata_response: function(req, res, data, next) { if (data && data.length > 0) accumulate(res, data); next(null, null); }, onend_response: function(req, res, data, next) { if (data && data.length > 0) accumulate(res, data); var content = Buffer.concat(res._chunks); delete res._chunks; next(null, content); } }; }
Plug-in „header-uppercase“
Edge Microgateway-Distributionen enthalten ein Beispiel-Plug-in namens <microgateway-root-dir>/plugins/header-uppercase
. Das Beispiel enthält Kommentare, in denen die einzelnen Funktions-Handler beschrieben werden. In diesem Beispiel wird eine einfache Datentransformation der Zielantwort durchgeführt und der Clientanfrage und der Zielantwort werden benutzerdefinierte Header hinzugefügt.
Hier ist der Quellcode für <microgateway-root-dir>/plugins/header-uppercase/index.js
:
'use strict'; var debug = require('debug')('plugin:header-uppercase'); // required module.exports.init = function(config, logger, stats) { var counter = 0; return { // indicates start of client request // request headers, url, query params, method should be available at this time // request processing stops (and a target request is not initiated) if // next is called with a truthy first argument (an instance of Error, for example) onrequest: function(req, res, next) { debug('plugin onrequest'); req.headers['x-foo-request-id'] = counter++; req.headers['x-foo-request-start'] = Date.now(); next(); }, // indicates start of target response // response headers and status code should be available at this time onresponse: function(req, res, next) { debug('plugin onresponse'); res.setHeader('x-foo-response-id', req.headers['x-foo-request-id']); res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start']); next(); }, // chunk of request body data received from client // should return (potentially) transformed data for next plugin in chain // the returned value from the last plugin in the chain is written to the target ondata_request: function(req, res, data, next) { debug('plugin ondata_request ' + data.length); var transformed = data.toString().toUpperCase(); next(null, transformed); }, // chunk of response body data received from target // should return (potentially) transformed data for next plugin in chain // the returned value from the last plugin in the chain is written to the client ondata_response: function(req, res, data, next) { debug('plugin ondata_response ' + data.length); var transformed = data.toString().toUpperCase(); next(null, transformed); }, // indicates end of client request onend_request: function(req, res, data, next) { debug('plugin onend_request'); next(null, data); }, // indicates end of target response onend_response: function(req, res, data, next) { debug('plugin onend_response'); next(null, data); }, // error receiving client request onerror_request: function(req, res, err, next) { debug('plugin onerror_request ' + err); next(); }, // error receiving target response onerror_response: function(req, res, err, next) { debug('plugin onerror_response ' + err); next(); }, // indicates client connection closed onclose_request: function(req, res, next) { debug('plugin onclose_request'); next(); }, // indicates target connection closed onclose_response: function(req, res, next) { debug('plugin onclose_response'); next(); } }; }
Großschreibung umwandeln
Dies ist ein allgemeines Transformations-Plug-in, das Sie für eine beliebige Art von Transformation ändern können. In diesem Beispiel werden die Antwort- und Anfragedaten einfach in Großbuchstaben umgewandelt.
*/ module.exports.init = function(config, logger, stats) { // perform content transformation here // the result of the transformation must be another Buffer function transform(data) { return new Buffer(data.toString().toUpperCase()); } return { ondata_response: function(req, res, data, next) { // transform each chunk as it is received next(null, data ? transform(data) : null); }, onend_response: function(req, res, data, next) { // transform accumulated data, if any next(null, data ? transform(data) : null); }, ondata_request: function(req, res, data, next) { // transform each chunk as it is received next(null, data ? transform(data) : null); }, onend_request: function(req, res, data, next) { // transform accumulated data, if any next(null, data ? transform(data) : null); } }; }