Développer des plug-ins personnalisés

<ph type="x-smartling-placeholder"></ph> Vous consultez la documentation Apigee Edge.
Accédez à la page Documentation sur Apigee X. En savoir plus

Edge Microgateway version 2.3.x

Audience

Cet article est destiné aux développeurs qui souhaitent étendre les fonctionnalités d'Edge Microgateway en écrivant des plug-ins personnalisés. Si vous souhaitez écrire un nouveau plug-in, vous devez connaître JavaScript et Node.js obligatoire.

Qu'est-ce qu'un plug-in Edge Microgateway personnalisé ?

Un plug-in est un module Node.js qui ajoute des fonctionnalités à Edge Microgateway. Modules de plug-ins suivent un schéma cohérent et sont stockés dans un emplacement connu d'Edge Microgateway, de les détecter et de les exécuter automatiquement. Plusieurs plug-ins prédéfinis sont fournis installer Edge Microgateway. Il s'agit notamment de plug-ins pour l'authentification, l'arrêt des pics, les quotas et analyse. Ces plug-ins existants sont décrits dans la section Utiliser des plug-ins.

Vous pouvez ajouter de nouvelles fonctionnalités à la micropasserelle en écrivant des valeurs personnalisées plug-ins. Par défaut, Edge Microgateway est essentiellement un proxy passthrough sécurisé qui transmet les requêtes et les réponses inchangées à et depuis les services cibles. Grâce aux plug-ins personnalisés, vous pouvez : de manière programmatique avec les requêtes et les réponses qui transitent par la micropasserelle.

Où placer le code de plug-in personnalisé ?

Un dossier pour les plug-ins personnalisés est inclus dans l'installation d'Edge Microgateway ici:

[prefix]/lib/node_modules/edgemicro/plugins

où [prefix] est le répertoire avec le préfixe npm décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

Vous pouvez modifier ce répertoire par défaut du plug-in. Consultez Où trouver les plug-ins.

Examiner les plug-ins prédéfinis

Avant d'essayer de développer votre propre plug-in, il est bon de vérifier qu'aucun des plug-ins prédéfinis qui répondent à vos besoins. Ces plug-ins se trouvent dans:

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

où [prefix] est le répertoire avec préfixe npm. Voir "Où Edge Microgateway est-il installé ?" de la section Installation d'Edge Microgateway :

Pour en savoir plus, consultez également la section Prédéfinis plug-ins fournis avec Edge Microgateway.

Écrire un plug-in simple

Dans cette section, nous allons découvrir la procédure à suivre pour créer un plug-in simple. Ce plug-in remplace les données de réponse (quelles qu'elles soient) par la chaîne "Hello, World!". et l'imprime du terminal.

  1. Si Edge Microgateway est en cours d'exécution, arrêtez-le maintenant:
    edgemicro stop
  2. cd vers le répertoire personnalisé du plug-in:

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

    où [prefix] est le répertoire avec préfixe npm. comme décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

  3. Créer un projet de plug-in response-override et y appliquer cd:
    mkdir response-override && cd response-override
  4. Créez un projet Node.js:
    npm init
     Appuyez plusieurs fois sur "Retour" pour accepter les valeurs par défaut.
  5. Utilisez un éditeur de texte pour créer un fichier appelé index.js.
  6. Copiez le code suivant dans index.js et enregistrez le fichier.
    '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. Vous avez maintenant créé un plug-in et vous devez l'ajouter à la configuration Edge Microgateway. Ouvrez le fichier $HOME/.edgemicro/[org]-[env]-config.yaml. où org et env sont votre organisation Edge et nom d'environnement.
  8. Ajoutez le plug-in response-override à l'élément plugins:sequence, comme indiqué ci-dessous.
          ...
      
      plugins:
        dir: ../plugins
        sequence:
          - oauth
          - response-override
          
      ...
  9. Redémarrez Edge Microgateway.
  10. Appeler une API via Edge Microgateway (Cet appel d'API suppose que vous avez configuré la même configuration que dans le tutoriel sur la sécurité des clés API, comme décrit dans la section Configurer et configurer Edge Microgateway:
    curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
Hello, World!

Anatomie d'un plug-in

L'exemple de plug-in Edge Microgateway suivant illustre le modèle à suivre lorsque développer vos propres plug-ins. Le code source de l'exemple de plug-in présenté dans cette section est le suivant : dans le plugins/header-uppercase/index.js.

  • Les plug-ins sont des modules NPM standards un élément package.json et un élément index.js à la racine .
  • Un plug-in doit exporter une fonction init().
  • La fonction init() prend trois arguments: config, logger, et stats. Ces arguments sont décrits Arguments de la fonction init() du plug-in.
  • init() renvoie un objet avec des gestionnaires de fonctions nommés qui sont appelés Lorsque certains événements se produisent au cours de la durée de vie d'une demande.

Fonctions du gestionnaire d'événements

Un plug-in doit implémenter tout ou partie de ces fonctions de gestionnaire d'événements. La mise en œuvre de ces c'est à vous de décider. N'importe quelle fonction est facultative, et un plug-in classique au moins un sous-ensemble de ces fonctions.

Gestionnaires d'événements de flux de requêtes

Ces fonctions sont appelées sur les événements de demande dans Edge Microgateway.

  • onrequest
  • ondata_request
  • onend_request
  • onclose_request
  • onerror_request

Fonction onrequest

Appelé au début de la requête client. Cette fonction se déclenche lorsque le premier octet de la est reçue par Edge Microgateway. Cette fonction vous donne accès aux en-têtes de requête, l'URL, les paramètres de requête et la méthode HTTP. Si vous appelez "next" avec un premier argument véridique (par exemple, (Erreur), le traitement de la requête s'arrête et aucune requête cible n'est lancée.

Exemple :

onrequest: function(req, res, next) {
      debug('plugin onrequest');
      req.headers['x-foo-request-start'] = Date.now();
      next();
    }

Fonction ondata_request

Appelé lorsqu'un fragment de données est reçu du client. Transmettre les données des requêtes au prochain dans la séquence de plug-ins. La valeur renvoyée par le dernier plug-in de la séquence est envoyée à la cible. Un cas d'utilisation typique, illustré ci-dessous, consiste à transformer les données d'une requête avant de les envoyer. à la cible.

Exemple :

ondata_request: function(req, res, data, next) {
      debug('plugin ondata_request ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }

Fonction onend_request

Appelé lorsque toutes les données de la requête ont été reçues du client.

Exemple :

onend_request: function(req, res, data, next) {
      debug('plugin onend_request');
      next(null, data);
    }

Fonction onclose_request

Indique que la connexion client a été fermée. Vous pouvez utiliser cette fonction dans les cas où la connexion au client n'est pas fiable. Il est appelé lorsque la connexion de socket au client est fermé.

Exemple :

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

Fonction onerror_request

Appelé en cas d'erreur lors de la réception de la requête du client.

Exemple :

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

Gestionnaires d'événements de flux de réponse

Ces fonctions sont appelées sur les événements de réponse dans Edge Microgateway.

  • onresponse
  • ondata_response
  • onend_response
  • onclose_response
  • onerror_response

Fonction onresponse

Appelé au début de la réponse cible. Cette fonction se déclenche lorsque le premier octet de la est reçue par Edge Microgateway. Cette fonction vous donne accès aux en-têtes de réponse et le code d'état.

Exemple :

onresponse: function(req, res, next) {      
    debug('plugin onresponse');     
    res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start'])    
    next();    
}


Fonction ondata_response

Appelé lorsqu'un fragment de données est reçu de la cible.

Exemple :

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


Fonction onend_response

Appelé lorsque toutes les données de réponse ont été reçues de la cible.

Exemple :

onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    }
 <ph type="x-smartling-placeholder">

Fonction onclose_response

Indique que la connexion cible est fermée. Vous pouvez utiliser cette fonction dans les cas où la connexion cible n'est pas fiable. Il est appelé lorsque la connexion du socket à la cible est fermé.

Exemple :

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


Fonction onerror_response

Appelé en cas d'erreur lors de la réception de la réponse cible.

Exemple :

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

Ce que vous devez savoir sur le Fonctions du gestionnaire d'événements de plug-in

Les fonctions de gestionnaire d'événements de plug-in sont appelées en réponse à des événements spécifiques qui se produisent Edge Microgateway traite une requête API donnée.

  • Chacun des gestionnaires de fonction init() (ondata_request, ondata_response, etc.) doit appeler au rappel next() une fois le traitement terminé. Si vous ne appelez next(), le traitement s'arrête et la requête est bloquée.
  • Le premier argument de next() peut être une erreur, ce qui provoquera pour mettre fin au traitement de la demande.
  • Les gestionnaires ondata_ et onend_ doivent : appeler next() avec un deuxième argument contenant les données à transmettre ; à la cible ou au client. Cet argument peut être nul si le plug-in est en mémoire tampon et qu'il n'a pas suffisamment de données à transformer.
  • Notez qu'une seule instance du plug-in est utilisée pour traiter toutes les requêtes et les réponses. Si un plug-in souhaite conserver l'état de chaque requête entre les appels, il peut l'enregistrer dans un ajoutée à l'objet request fourni. (req), dont la durée de vie correspond à la durée de l'appel d'API.
  • Veillez à intercepter toutes les erreurs et à appeler next() avec l'erreur. Si vous n'appelez pas next(), l'appel d'API sera suspendu.
  • Veillez à ne pas introduire de fuites de mémoire, car cela peut affecter les performances globales d'Edge et la faire planter en cas de manque de mémoire.
  • Veillez à suivre le modèle Node.js en n'effectuant pas de tâches exigeantes en ressources de calcul dans car cela peut nuire aux performances d'Edge Microgateway.

À propos de la fonction init() du plug-in

Cette section décrit les arguments transmis à La fonction init(): config, logger, et stats.

config

Objet de configuration obtenu après la fusion du fichier de configuration Edge Microgateway avec les informations téléchargées à partir d'Apigee Edge, telles que les produits et les quotas. Vous trouverez configuration spécifique au plug-in dans cet objet: config.<plugin-name>.

Pour ajouter un paramètre de configuration appelé param avec une valeur de foo à un plug-in appelé response-override, placez dans le fichier default.yaml:

response-override:
    param: foo

Vous pouvez ensuite accéder au paramètre dans le code de votre plug-in, comme ceci:

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

Dans ce cas, "foo" s'affiche dans la sortie de débogage du plug-in:

Sun, 13 Dec 2015 21:25:08 GMT plugin:response-override ***** plugin ondata_response: config.param: foo

logger

L'enregistreur système. L'enregistreur actuellement utilisé exporte ces fonctions, où les objets peuvent être une chaîne, une requête HTTP, une réponse HTTP ou une instance Error.

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

stats

Objet qui contient le nombre de requêtes, de réponses, d'erreurs et d'autres statistiques agrégées liées aux requêtes et aux réponses circulant via une instance de micropasserelle.

  • treqErrors : nombre de requêtes cibles comportant des erreurs.
  • treqErrors : nombre de réponses cibles comportant des erreurs.
  • statusCodes : un objet contenant le code de réponse.
{
  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 : nombre total de requêtes.
  • réponses : nombre total de réponses.
  • connections : nombre de connexions cibles actives.

À propos de la fonction next()

Toutes les méthodes de plug-in doivent appeler next() pour continuer à traiter la suivante de la série (ou le processus du plug-in se bloquera). Dans le cycle de vie des requêtes, appelée est onrequest(). La méthode suivante à appeler est la méthode ondata_request() ; Toutefois, ondata_request n'est appelé que si le inclut des données, comme dans le cas d'une requête POST. La méthode suivante, appelée est onend_request(), qui est appelé lorsque le traitement de la requête est terminé. Les fonctions onerror_* ne sont appelées qu'en cas d'appel et ils vous permettent de gérer les erreurs avec du code personnalisé si vous le souhaitez.

Supposons que des données soient envoyées dans la requête et que ondata_request() soit appelé. Notez que la fonction appelle next() avec deux paramètres:

next(null, data);

Par convention, le premier paramètre est utilisé pour transmettre des informations sur l'erreur, que vous pouvez ensuite dans une fonction ultérieure de la chaîne. En le définissant sur null, , nous disons qu'il n'y a pas d'erreur et que le traitement des requêtes devrait se dérouler normalement. Si cet argument est vrai (par exemple, un objet Error), alors le traitement de la requête s'arrête et la requête est envoyés à la cible.

Le deuxième paramètre transmet les données de la requête à la fonction suivante dans la chaîne. Si vous ne un traitement supplémentaire, les données de la requête sont transmises telles quelles à la cible de l'API. Vous avez toutefois la possibilité de modifier les données de requête dans cette méthode et de transmettre les valeurs à la cible. Par exemple, si les données de la requête sont au format XML et que la cible attend JSON, vous pouvez alors ajouter du code à la méthode ondata_request() qui (a) modifie la Content-Type de l'en-tête de requête en application/json et convertit le paramètre des données vers JSON en utilisant la méthode de votre choix (par exemple, vous pouvez utiliser convertisseur xml2json Node.js obtenu à partir de NPM).

Voyons à quoi cela pourrait ressembler:

ondata_request: function(req, res, data, next) {
  debug('****** plugin ondata_request);
  var translated_data = parser.toJson(data);
  next(null, translated_data);
},

Dans ce cas, les données de la requête (appelées "XML") sont converties au format JSON. les données transformées sont transmises via next() à la fonction suivante dans la requête avant d'être transmises à la cible du backend.

Notez que vous pouvez ajouter une autre instruction de débogage pour imprimer les données transformées à des fins de débogage. objectifs. Exemple :

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

À propos Ordre d'exécution du gestionnaire de plug-ins

Si vous écrivez des plug-ins pour Edge Microgateway, vous devez comprendre l'ordre dans lequel et les gestionnaires d'événements sont exécutés.

Le point important à retenir est que lorsque vous spécifiez une séquence de plug-in dans la périphérie Fichier de configuration Microgateway, les gestionnaires de requêtes exécutent dans l'ordre croissant, tandis que les gestionnaires de réponses exécutent par ordre décroissant.

L'exemple suivant est conçu pour vous aider à comprendre cette séquence d'exécution.

1. Créez trois plug-ins

Prenons l'exemple du plug-in suivant. Il suffit d'imprimer la sortie de la console lorsque ses gestionnaires d'événements sont appelé:

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

Maintenant, envisagez de créer deux autres plug-ins, plugin-2 et plugin-3, avec le même code (sauf si vous modifiez les instructions console.log() à plugin-2 et plugin-3 respectivement).

2. Examiner le code du plug-in

Fonctions du plug-in exporté dans <microgateway-root-dir>/plugins/plugin-1/index.js sont des événements qui s'exécutent à des moments précis pendant le traitement des requêtes et des réponses. Pour exemple, onrequest exécute le premier octet des en-têtes de requête est reçues. Alors que onend_response s'exécute après le dernier octet de réponse de données reçues.

Examinez le gestionnaire ondata_response. Il est appelé à chaque fois qu'un fragment de données de réponse est reçue. Il est important de savoir que les données de réponse ne sont pas nécessairement reçues une seule fois. Les données peuvent plutôt être reçues par blocs de longueur arbitraire.

3. Ajoutez les plug-ins à la séquence du plug-in

En continuant avec cet exemple, nous allons ajouter les plug-ins à la séquence de plug-ins dans Fichier de configuration Microgateway (~./edgemicro/config.yaml) comme indiqué ci-dessous. La séquence est importantes. Il définit l'ordre d'exécution des gestionnaires de plug-in.

  plugins:
    dir: ../plugins
    sequence:
      - plugin-1
      - plugin-2
      - plugin-3

4. Examiner le résultat du débogage

Voyons maintenant le résultat qui serait produit lorsque ces plug-ins sont appelés. Il y a quelques points importants à noter:

  • La séquence du plug-in dans le fichier de configuration Edge Microgateway (~./edgemicro/config.yaml) spécifie l'ordre dans lequel les gestionnaires d'événements sont appelé.
  • Les gestionnaires de requêtes sont appelés dans l'ordre croissant (ordre dans lequel dans l'ordre du plug-in (1, 2, 3).
  • Les gestionnaires de réponses sont appelés dans l'ordre décroissant (3, 2, 1.
  • Le gestionnaire ondata_response est appelé une fois pour chaque fragment de données. qui arrive. Dans cet exemple (la sortie illustrée ci-dessous), deux fragments sont reçus.

Voici un exemple de résultat de débogage généré lorsque ces trois plug-ins sont utilisés et qu'une requête est envoyée via Edge Microgateway. Notez simplement l'ordre dans lequel les gestionnaires sont appelés:

  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

Résumé

Il est très important de comprendre l'ordre dans lequel les gestionnaires de plug-ins sont appelés implémenter des fonctionnalités de plug-in personnalisées, telles que l'accumulation et la transformation de requêtes ou de réponses ; données.

N'oubliez pas que les gestionnaires de requêtes sont exécutés dans l'ordre dans lequel les plug-ins sont spécifiés dans le fichier de configuration Edge Microgateway, et les gestionnaires de réponses sont exécutés dans la l'ordre inverse.

À propos de l'utilisation de variables globales dans les plug-ins

Chaque requête envoyée à Edge Microgateway est envoyée à la même instance d'un plug-in. Par conséquent, un l'état de la deuxième requête d'un autre client écrasera la première. Le seul endroit sûr d'enregistrer l'état du plug-in consiste à le stocker dans une propriété de l'objet de requête ou de réponse (dont sa durée de vie est limitée à celle de la requête).

Réécriture des URL cibles dans les plug-ins

Ajoutée à: v.2.3.3

Vous pouvez remplacer dynamiquement l'URL cible par défaut dans un plug-in en modifiant ces variables dans votre plug-in code: req.targetHostname et req.targetPath.

Exemples de plug-ins

Ces plug-ins sont fournis avec votre installation Edge Microgateway. Vous les trouverez dans la Installation d'Edge Microgateway ici:

[prefix]/lib/node_modules/edgemicro/plugins

où [prefix] est le répertoire avec le préfixe npm décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

accumulate-request

Ce plug-in accumule des fragments de données du client dans une propriété de tableau associée au . Lorsque toutes les données de requête sont reçues, le tableau est concaténé dans un tampon qui est ensuite transmise au plug-in suivant dans la séquence. Ce plug-in doit être le premier plug-in de la séquence afin que les plug-ins suivants reçoivent les données de requête accumulées.

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

Ce plug-in accumule des fragments de données de la cible dans une propriété de tableau associée au . Lorsque toutes les données de réponse sont reçues, le tableau est concaténé dans un tampon qui est ensuite transmise au plug-in suivant dans la séquence. Comme ce plug-in fonctionne d'entrée, qui sont traitées dans l'ordre inverse, placez-le en tant que dernier plug-in de la séquence.

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 = null;
      if(res._chunks && res._chunks.length) {
        content = Buffer.concat(res._chunks);
      }
      delete res._chunks;
      next(null, content);
    }
 
  };
}

Plug-in header-uppercase

Les distributions Edge Microgateway incluent un exemple de plug-in appelé <microgateway-root-dir>/plugins/header-uppercase. L'exemple inclut des commentaires décrivant chacun des gestionnaires de fonctions. Cet exemple utilise quelques données simples de la réponse cible et ajoute des en-têtes personnalisés à la requête du client et à la cible de réponse.

Voici le code source pour <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();
    }

  };

}

transformation en majuscules

Il s'agit d'un plug-in de transformation général que vous pouvez modifier pour faire la transformation souhaitée. Cet exemple transforme simplement la réponse et les données de requête en majuscules.

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

  };

}

Autres tutoriels de plug-ins

Consultez également ces tutoriels sur le blog Apigee: