Benutzerdefinierte Plug-ins entwickeln

<ph type="x-smartling-placeholder"></ph> Sie sehen die Dokumentation zu Apigee Edge.
Gehen Sie zur Apigee X-Dokumentation. Weitere Informationen

Edge Microgateway Version 3.1.5 und höher

Zielgruppe

Dieses Thema richtet sich an Entwickler, die Edge Microgateway-Features durch benutzerdefinierten Plug-ins. Wenn Sie ein neues Plug-in schreiben möchten, sollten Sie mit JavaScript und Node.js vertraut sein erforderlich.

Was ist ein benutzerdefiniertes Edge Microgateway-Plug-in?

Ein Plug-in ist ein Node.js-Modul, das Edge Microgateway um Funktionen ergänzt. Plug-in-Module einem einheitlichen Muster folgen und an einem Edge Microgateway bekannten Speicherort gespeichert werden, dass sie erkannt und automatisch ausgeführt werden. Wenn Sie eine der folgenden Optionen nutzen, stehen Ihnen mehrere vordefinierte Plug-ins zur Verfügung: Edge Microgateway installieren. Dazu gehören Plug-ins für Authentifizierung, Spike Arrest, Kontingent- und Analytics. Diese vorhandenen Plug-ins werden unter Plug-ins verwenden beschrieben.

Sie können dem Microgateway neue Funktionen hinzufügen, indem Sie custom . Standardmäßig ist Edge Microgateway im Wesentlichen ein sicherer Passthrough-Proxy, übergibt Anfragen und Antworten unverändert an und von Zieldiensten. Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen und Antworten interagieren, die über das Microgateway fließen.

Benutzerdefinierten Plug-in-Code einfügen

Die Edge Microgateway-Installation enthält einen Ordner für benutzerdefinierte Plug-ins hier:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

Dabei ist [prefix] das npm-Präfixverzeichnis als beschrieben in „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

Sie können dieses Standard-Plug-in-Verzeichnis ändern. Weitere Informationen finden Sie unter .

Vordefinierte Plug-ins überprüfen

Bevor Sie versuchen, Ihr eigenes Plug-in zu entwickeln, überprüfen Sie am besten, ob keine der vordefinierten die Ihren Anforderungen entsprechen. Diese Plug-ins befinden sich hier:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

Dabei ist [prefix] das Präfixverzeichnis npm. Weitere Informationen finden Sie unter auch „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

Weitere Informationen finden Sie unter Vordefinierte mit Edge Microgateway bereitgestellte Plug-ins.

Einfaches Plug-in schreiben

In diesem Abschnitt werden die Schritte zum Erstellen eines einfachen Plug-ins erläutert. Dieses Plug-in überschreibt die Antwortdaten (was auch immer sie sind) mit der Zeichenfolge "Hello, World!" und druckt sie im .

  1. Wenn Edge Microgateway ausgeführt wird, beenden Sie es jetzt:
    edgemicro stop
  2. cd in das benutzerdefinierte Plug-in-Verzeichnis:

    cd [prefix]/lib/node_modules/edgemicro/plugins

    wobei [prefix] das Präfixverzeichnis npm ist wie unter "Wo ist Edge Microgateway installiert ist" beschrieben in Edge installieren Microgateway

  3. Erstellen Sie ein neues Plug-in-Projekt mit dem Namen response-override und cd. hinzufügen:
    mkdir response-override && cd response-override
  4. Erstellen Sie ein neues Node.js-Projekt:
    npm init
    Drücken Sie mehrmals auf die Eingabetaste, um die Standardeinstellungen zu übernehmen.
  5. Erstellen Sie mit einem Texteditor eine neue Datei namens index.js.
  6. 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");
    }
  };
}
  7. 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, wobei org und env sind die Namen Ihrer Edge-Organisation und Ihrer Umgebung.
  8. Fügen Sie dem Element plugins:sequence das Plug-in response-override hinzu wie unten dargestellt.
          ...
      
      plugins:
        dir: ../plugins
        sequence:
          - oauth
          - response-override
          
      ...
  9. Starten Sie Edge Microgateway neu.
  10. API über Edge Microgateway aufrufen. Bei diesem API-Aufruf wird davon ausgegangen, dass Sie Konfiguration als Anleitung mit der Sicherheit des API-Schlüssels, wie unter Einrichten der und Edge Microgateway konfigurieren:
    curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
Hello, World!

Aufbau eines Plug-ins

Das folgende Edge Microgateway-Beispiel-Plug-in veranschaulicht das Muster, das beim die Entwicklung eigener Plug-ins. Der Quellcode für das in diesem Abschnitt beschriebene Beispiel-Plug-in ist im plugins/header-uppercase/index.js.

  • Plug-ins sind Standard-NPM-Module mit einem package.json und index.js im Stammordner.
  • Ein Plug-in muss eine init()-Funktion exportieren.
  • Die Funktion init() verwendet drei Argumente: config, logger und stats. Diese Argumente werden im Plug-in init()-Funktionsargumente.
  • 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 Event-Handler-Funktionen implementieren. Implementierung welche Funktionen Sie nutzen. Jede gegebene Funktion ist optional und ein typisches Plug-in wird unter zumindest eine Teilmenge dieser Funktionen.

Flow-Event-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 des Anfrage wird von Edge Microgateway empfangen. Mit dieser Funktion erhalten Sie Zugriff auf die Anfrageheader, URL, Suchparameter und HTTP-Methode. Wenn Sie "Next" mit dem ersten Argument der Wahrheit (z. B. Fehlerinstanz), wird die Verarbeitung der Anfrage gestoppt und es wird 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 die nächste in der Plug-in-Sequenz ein. Der vom letzten Plug-in in der Sequenz zurückgegebene Wert wird an das Ziel zu erreichen. Ein typischer Anwendungsfall (siehe unten) ist die Transformation der Anfragedaten vor dem Senden zum Ziel hin.

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-Function

Gibt an, dass die Clientverbindung beendet wurde. Sie können diese Funktion verwenden, wenn der Clientverbindung ist unzuverlässig. Sie wird aufgerufen, wenn die Socket-Verbindung zum Client geschlossen.

Beispiel:

onclose_request: function(req, res, next) {
      debug('plugin onclose_request');
      next();
    }

onerror_request-Function

Wird aufgerufen, wenn beim Empfang der Clientanfrage ein Fehler auftritt.

Beispiel:

onerror_request: function(req, res, err, next) {
      debug('plugin onerror_request ' + err);
      next();
    }

Ereignis-Handler für Antwortfluss

Diese Funktionen werden bei Antwortereignissen in Edge Microgateway aufgerufen.

  • onresponse
  • ondata_response
  • onend_response
  • onclose_response
  • onerror_response

onresponse-Function

Wird zu Beginn der Zielantwort aufgerufen. Diese Funktion wird ausgelöst, wenn das erste Byte des Antwort wird von Edge Microgateway empfangen. 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);
    }
<ph type="x-smartling-placeholder">


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);
    }
<ph type="x-smartling-placeholder">

onclose_response-Function

Gibt an, dass die Zielverbindung beendet wurde. Sie können diese Funktion verwenden, wenn der Zielverbindung ist unzuverlässig. Sie wird aufgerufen, wenn die Socket-Verbindung zum Ziel geschlossen.

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();
    }

Was Sie über die Plug-in-Event-Handler-Funktionen

Plug-in-Event-Handler-Funktionen werden als Reaktion auf bestimmte Ereignisse aufgerufen, die während Edge Microgateway verarbeitet eine bestimmte API-Anfrage.

  • Jeder der init()-Funktions-Handler (ondata_request, ondata_response usw.) muss nach Abschluss den next()-Callback aufrufen. Datenverarbeitung. Wenn Sie next() nicht aufrufen, wird die Verarbeitung beendet und die Anfrage hängt.
  • Das erste Argument für next() kann ein Fehler sein, der zu einer Anfrage führt. zu beenden.
  • Die Handler ondata_ und onend_ müssen next() mit einem zweiten Argument mit den Daten, die an das Ziel übergeben werden sollen. oder der Kundschaft. Dieses Argument kann null sein, wenn das Plug-in eine Zwischenspeicherung durchführt und nicht genügend Daten zur Verfügung stehen, um sich im Moment zu verändern.
  • Beachten Sie, dass eine einzelne Instanz des Plug-ins verwendet wird, um alle Anfragen und Antworten zu bearbeiten. Möchte ein Plug-in den anfragespezifischen Status zwischen den Aufrufen beibehalten, kann es diesen Status in einem dem bereitgestellten request-Objekt (req) hinzugefügt, dessen Lebensdauer ist die Dauer des API-Aufrufs.
  • Achten Sie darauf, dass alle Fehler abgefangen werden, und rufen Sie next() mit dem Fehler auf. Fehler bei next() aufruft, dazu führt, dass der API-Aufruf ausgesetzt wird.
  • Achten Sie darauf, keine Speicherlecks zu verursachen, da dies die Gesamtleistung von Edge beeinträchtigen kann. Microgateway verwenden und es zum Absturz bringen, wenn der Arbeitsspeicher ausgeht.
  • Achten Sie darauf, dem Node.js-Modell zu folgen und keine rechenintensiven Aufgaben in der Haupt- Thread, da dies die Leistung von Edge Microgateway beeinträchtigen kann.

Über die Funktion „init()“ des Plug-ins

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 Die von Apigee Edge heruntergeladenen Daten werden in einem Objekt namens config abgelegt.

So fügen Sie einen Konfigurationsparameter param mit dem Wert foo hinzu. in das Plug-in response-override, fügen Sie diesen im default.yaml ein. Datei:

response-override:
    param: foo

Anschließend können Sie wie folgt auf den Parameter im Plug-in-Code 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

Ich auf die zusammengeführte Microgateway-Konfiguration zugreifen und Apigee Edge-Daten im untergeordnetes Objekt config.emgConfigs. Beispiel: können Sie in der Funktion init auf diese Konfigurationsdaten zugreifen. wie folgt:

module.exports.init = function(config, logger, stats) {
   let emgconfigs = config.emgConfigs;

Im Folgenden finden Sie ein Beispiel für Daten, die in emgConfigs enthalten sind: 

{
    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 Systemprotokoll. Der aktuell verwendete Logger exportiert diese Funktionen, wobei das Objekt ein String, eine HTTP-Anfrage, eine HTTP-Antwort oder eine Fehlerinstanz.

  • info(object, message)
  • warn(object, message)
  • error(object, message)
  • trace(object, message)
  • debug(object, message)

Statistiken

Ein Objekt, das die Anzahl der Anfragen, Antworten, Fehler und andere aggregierte Statistiken enthält zu den Anfragen und Antworten, die über eine Microgateway-Instanz gesendet werden.

  • treqErrors: Anzahl der Zielanfragen mit Fehlern.
  • treqErrors – Anzahl der Zielantworten mit Fehlern.
  • statusCodes – Ein Objekt mit Antwortcode wird gezählt:
{
  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 Verarbeitung der nächsten Methode im (sonst hängt der Plug-in-Prozess auf). Die erste aufgerufene Methode im Anfragelebenszyklus onrequest() Die nächste Methode, die aufgerufen werden soll, ist die Methode ondata_request(). Allerdings ondata_request wird nur aufgerufen, wenn die Anfrage Daten enthält, wie in z. B. einer POST-Anfrage. Die nächste aufgerufene Methode ist onend_request(), der nach Abschluss der Anfrageverarbeitung aufgerufen wird. Die onerror_*-Funktionen werden nur im Fehlerfall aufgerufen und ermöglichen Folgendes: können Sie die Fehler bei Bedarf mit benutzerdefiniertem Code verarbeiten.

Angenommen, Daten werden in der Anfrage gesendet und ondata_request() wird aufgerufen. Hinweis dass die Funktion next() mit zwei Parametern aufruft:

next(null, data);

Konventionsgemäß wird der erste Parameter verwendet, um Fehlerinformationen zu übermitteln, die Sie dann Handle in einer nachfolgenden Funktion in der Kette ab. Wenn Sie es auf null setzen, angeben, dass keine Fehler vorliegen und die Anfrageverarbeitung normal fortgesetzt werden sollte. Wenn ist dieses Argument wahrheitsgemäß (z. B. ein Fehlerobjekt), dann wird die Verarbeitung der Anforderung beendet und die Anforderung wird an das Ziel gesendet werden.

Der zweite Parameter übergibt die Anfragedaten an die nächste Funktion in der Kette. Wenn Sie keine 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änderten an das Ziel zu senden. Wenn die Anforderungsdaten beispielsweise XML sind und das Ziel JSON erwartet, können Sie der Methode ondata_request() Code hinzufügen, mit dem (a) Content-Type des Anfrageheaders in application/json und konvertiert die Anfragedaten in JSON mit jeder beliebigen Methode (z. B. Node.js) xml2json-Konverter aus NPM).

Das könnte so 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 Anforderungsdaten (von denen angenommen wird, dass sie im XML-Format vorliegen) in JSON konvertiert und der transformierte 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 für das Debugging auszugeben. zu verstehen. 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);
},

Info Ausführungsreihenfolge für Plug-in-Handler

Wenn Sie Plug-ins für Edge Microgateway schreiben, müssen Sie die Reihenfolge verstehen, ausgeführt werden.

Wichtig ist, dass Sie beim Angeben einer Plug-in-Sequenz in Edge Microgateway-Konfigurationsdatei werden die Anfrage-Handler in aufsteigender Reihenfolge ausgeführt, während die Antwort-Handler in absteigender Reihenfolge ausgeführt werden.

Das folgende Beispiel soll Ihnen helfen, diese Ausführungssequenz zu verstehen.

1. Erstellen Sie drei einfache Plug-ins

Sehen Sie sich das folgende Plug-in an. Es wird lediglich die Konsolenausgabe ausgegeben, wenn die Event-Handler mit dem Namen:

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 denselben Code (ändere die console.log()-Anweisungen jedoch in plugin-2) bzw. plugin-3).

2. Plug-in-Code überprüfen

Das exportierte Plug-in funktioniert in <microgateway-root-dir>/plugins/plugin-1/index.js sind Event-Handler, die zu bestimmten Zeiten während der Anfrage- und Antwortverarbeitung ausgeführt werden. Beispiel: onrequest führt das erste Byte der empfangenen Anfrageheader aus. Während onend_response wird ausgeführt, nachdem das letzte Byte der Antwortdaten empfangen wurde.

Sehen Sie sich den Handler ondata_response an. Er wird immer dann aufgerufen, wenn ein Teil der Antwortdaten empfangen wird. Wichtig zu wissen ist, dass die Antwortdaten nicht unbedingt einmal. Stattdessen können die Daten in Blöcken beliebiger Länge empfangen werden.

3. Plug-ins hinzufügen zu Plug-in-Sequenz

Wenn wir mit diesem Beispiel fortfahren, fügen wir die Plug-ins zur Plug-in-Sequenz in Edge hinzu. Microgateway-Konfigurationsdatei (~./edgemicro/config.yaml) folgendermaßen: Die Reihenfolge ist wichtig. Er 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

Werfen wir nun einen Blick auf die Ausgabe, die erzeugt wird, wenn diese Plug-ins aufgerufen werden. Es gibt Beachten Sie die folgenden wichtigen Punkte:

  • Die Plug-in-Sequenz der Edge Microgateway-Konfigurationsdatei (~./edgemicro/config.yaml) gibt die Reihenfolge an, in der Event-Handler ausgeführt werden. aufgerufen.
  • Request-Handler werden in aufsteigender Reihenfolge aufgerufen, d. h. in der Reihenfolge, in der sie in der Plug-in-Sequenz - 1, 2, 3).
  • Antwort-Handler werden in absteigender Reihenfolge aufgerufen: 3, 2, 1.
  • Der ondata_response-Handler wird für jeden Datenblock, der kommt. In diesem Beispiel (siehe unten) werden zwei Blöcke empfangen.

Hier sehen Sie ein Beispiel für eine Debug-Ausgabe, die generiert wird, wenn diese drei Plug-ins verwendet werden und eine Anfrage gesendet wird über Edge Microgateway. 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

Es ist sehr wichtig zu verstehen, in welcher Reihenfolge Plug-in-Handler aufgerufen werden, wenn Sie versuchen, Benutzerdefinierte Plug-in-Funktionen implementieren, z. B. zum Sammeln und Umwandeln von Anfragen oder Antworten Daten.

Denken Sie daran, dass Anfrage-Handler in der Reihenfolge ausgeführt werden, in der die Plug-ins die in der Edge Microgateway-Konfigurationsdatei angegeben sind, und Antwort-Handler werden im in entgegengesetzter Reihenfolge.

Globale Variablen in Plug-ins verwenden

Jede Anfrage an Edge Microgateway wird an dieselbe Instanz eines Plug-ins gesendet. Daher ist ein Der Status der zweiten Anfrage von einem anderen Client überschreibt den ersten. Der einzige sichere Ort, an dem Das Speichern des Plug-in-Status besteht darin, den Status in einer Eigenschaft des Anfrage- oder Antwortobjekts zu speichern, dessen Lebensdauer ist auf die der Anfrage beschränkt.

Umschreiben von Ziel-URLs in Plug-ins

Hinzugefügt in: v2.3.3

Sie können die Standard-Ziel-URL in einem Plug-in dynamisch überschreiben, indem Sie diese Variablen ändern. im Plug-in-Code: 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 wählen. Ändern Variablen im Plug-in-Code: req.targetPort und req.targetSecure. Um HTTPS auszuwählen, setzen Sie req.targetSecure auf true; für HTTP auf false setzen. Wenn Sie req.targetSecure auf wahr, siehe diese Diskussion .

Ein Beispiel-Plug-in namens eurekaclient wurde zu Edge Microgateway hinzugefügt. Dieses zeigt, wie die Variablen req.targetPort und req.targetSecure verwendet werden. Erläutert, wie Edge Microgateway eine dynamische Endpunktsuche mit Eureka als Dienst durchführen kann Endpunktkatalog.


Beispiel-Plug-ins

Diese Plug-ins werden mit Ihrer Edge Microgateway-Installation bereitgestellt. Sie finden sie in der Edge Microgateway-Installation hier:

[prefix]/lib/node_modules/edgemicro/plugins

Dabei ist [prefix] das npm-Präfixverzeichnis als beschrieben in „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

accumulate-request

Dieses Plug-in sammelt Datenblöcke vom Client in einer Array-Eigenschaft, die dem request-Objekts. Wenn alle Anfragedaten empfangen wurden, wird das Array zu einem Zwischenspeicher verkettet. das dann an das nächste Plug-in in der Sequenz übergeben wird. Dieses Plug-in sollte das erste Plug-in sein. in der Sequenz, 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);

    }

  };

}

accumulate-response

Dieses Plug-in sammelt Datenblöcke vom Ziel in einer Array-Eigenschaft, die dem -Antwortobjekt. Wenn alle Antwortdaten empfangen wurden, wird das Array zu einem Zwischenspeicher verkettet. das dann an das nächste Plug-in in der Sequenz übergeben wird. Da dieses Plug-in in Antworten, die in umgekehrter Reihenfolge verarbeitet werden, in der Sequenz an.

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 mit großem Anfangsbuchstaben

Edge Microgateway-Distributionen enthalten ein Beispiel-Plug-in namens <microgateway-root-dir>/plugins/header-uppercase Das Beispiel enthält Kommentare die die einzelnen Funktions-Handler beschreiben. In diesem Beispiel erfolgt eine einfache Datentransformation des target -Antwort und fügt der Clientanfrage und der Zielantwort benutzerdefinierte Header hinzu.

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 die Sie sich wünschen. In diesem Beispiel werden die Antwort- und Anfragedaten in Großbuchstaben.

 */
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);
    }

  };

}