इस पेज का अनुवाद Cloud Translation API से किया गया है.

कस्टम प्लग इन डेवलप करना

Apigee Edge के दस्तावेज़ देखे जा रहे हैं.
Apigee X के दस्तावेज़. जानकारी पर जाएं

Edge Microgateway v. 3.3.x

दर्शक

यह विषय उन डेवलपर के लिए है जो कस्टम प्लगिन लिखकर, Edge Microgateway की सुविधाओं को बढ़ाना चाहते हैं. अगर आपको एक नया प्लगिन लिखने के लिए, JavaScript और Node.js का अनुभव ज़रूरी है.

कस्टम Edge माइक्रोगेटवे प्लगिन क्या है?

प्लगिन एक Node.js मॉड्यूल होता है, जो Edge Microgateway में फ़ंक्शन जोड़ता है. प्लग इन मॉड्यूल एक जैसे पैटर्न को फ़ॉलो करते हैं और ऐसी जगह पर स्टोर किए जाते हैं जहां Edge Microgateway है. इससे उन्हें अपने-आप खोजा और इस्तेमाल किया जा सकता है. Edge Microgateway इंस्टॉल करते समय, आपको पहले से तय कई प्लगिन मिलेंगे. इनमें पुष्टि करने, तेज़ी से बढ़ने की वजह, कोटा, और आंकड़ों के लिए प्लगिन शामिल हैं. इन मौजूदा प्लग इन के बारे में प्लगिन का इस्तेमाल करें में बताया गया है.

कस्टम प्लगिन लिखकर, माइक्रोगेटवे में नई सुविधाएं और क्षमताएं जोड़ी जा सकती हैं. डिफ़ॉल्ट रूप से, Edge Microgateway एक सुरक्षित पास-थ्रू प्रॉक्सी है, जो टारगेट सेवाओं के लिए और उनसे मिलने वाले अनुरोधों और जवाबों में कोई बदलाव नहीं करता. कस्टम प्लग इन की मदद से, माइक्रोगेटवे से आने वाले अनुरोधों और रिस्पॉन्स को प्रोग्राम के हिसाब से, अपने-आप होने वाली प्रोसेस से इंटरैक्ट किया जा सकता है.

कस्टम प्लगिन कोड कहां डालें

कस्टम प्लग इन का फ़ोल्डर, Edge Microgateway इंस्टॉलेशन के हिस्से के तौर पर यहां शामिल किया गया है:

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

जहां [prefix], npm प्रीफ़िक्स डायरेक्ट्री है, जैसा कि इंस्टॉलिंग एज माइक्रोगेटवे में "एज माइक्रोगेटवे कहां इंस्टॉल है" में बताया गया है.

इस डिफ़ॉल्ट प्लग इन डायरेक्ट्री को बदला जा सकता है. प् लगिन कहां मिलेंगे देखें.

पहले से तय प्लग इन की समीक्षा करना

अपना खुद का प्लग इन डेवलप करने से पहले, यह जांच लेना बेहतर होगा कि पहले से तय किए गए कोई भी प्लग इन आपकी ज़रूरतों को पूरा नहीं करता हो. ये प्लग इन इन देशों में मौजूद हैं:

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

जहां [prefix], npm प्रीफ़िक्स डायरेक्ट्री है. इंस्टॉलिंग एज माइक्रोगेटवे में "एज माइक्रोगेटवे कहां इंस्टॉल है" भी देखें.

ज़्यादा जानकारी के लिए, Edge माइक्रोगेटवे के साथ दिए गए, पहले से तय किए गए प्लग इन भी देखें.

कोई आसान प्लगिन लिखें

इस सेक्शन में, हम एक आसान प्लगिन बनाने के लिए ज़रूरी चरणों के बारे में बताएंगे. यह प्लगिन रिस्पॉन्स डेटा (जो भी हो) को "नमस्ते, दुनिया!" स्ट्रिंग से बदल देता है और इसे टर्मिनल पर प्रिंट कर देता है.

ध्यान दें: यहां दिया गया तरीका अपनाने के लिए, आपके पास Edge माइक्रोगेटवे का एक कॉन्फ़िगर किया गया और चालू इंस्टेंस होना चाहिए. इसे आसानी से समझने के लिए, हम मान लेते हैं कि एपीआई पासकोड की सुरक्षा वाले ट्यूटोरियल में बताया गया कॉन्फ़िगरेशन ही इस्तेमाल किया जा रहा है. Edge माइक्रोगेटवे को सेट अप और कॉन्फ़िगर करना लेख देखें.

अगर Edge Microgateway चल रहा है, तो इसे अभी बंद करें:
```
edgemicro stop
```
cd को कस्टम प्लग इन डायरेक्ट्री के लिए इस्तेमाल करें:
cd [prefix]/lib/node_modules/edgemicro/plugins

जहां [prefix], npm प्रीफ़िक्स डायरेक्ट्री है, जैसा कि इंस्टॉलिंग एज माइक्रोगेटवे में "एज माइक्रोगेटवे कहां इंस्टॉल है" में बताया गया है.
इसके लिए, response-override और cd नाम के साथ एक नया प्लगिन प्रोजेक्ट बनाएं:
```
mkdir response-override && cd response-override
```
नया Node.js प्रोजेक्ट बनाएं:
```
npm init
```
'डिफ़ॉल्ट' को स्वीकार करने के लिए, Return को कई बार दबाएं.
index.js नाम की नई फ़ाइल बनाने के लिए, टेक्स्ट एडिटर का इस्तेमाल करें.
index.js में इस कोड को कॉपी करके फ़ाइल सेव करें.
```
'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");
    }
  };
}
```
ध्यान दें: प्लगिन के फ़ंक्शन (*_response), इवेंट हैंडलर होते हैं. जब भी एज माइक्रोगेटवे को डेटा का कोई हिस्सा मिलता है, तब ondata_response फ़ंक्शन को कॉल किया जाता है. onend_response फ़ंक्शन को तब कॉल किया जाता है, जब रिस्पॉन्स डेटा का आखिरी बाइट मिलता है.

ध्यान दें: अहम जानकारी: प्लगिन के सभी फ़ंक्शन के लिए, next() फ़ंक्शन ज़रूरी है. यह फ़ंक्शन, कॉल किए जाने वाले अगले प्लगिन फ़ंक्शन को गड़बड़ी (पहला तर्क) और डेटा (दूसरा तर्क) पास करता है. ध्यान दें कि इस उदाहरण में, ondata_response में मौजूद data आर्ग्युमेंट शून्य है. इस तर्क को शून्य पर सेट करने से, हम onend_response में दिए गए रिस्पॉन्स डेटा को बदल देते हैं. अगर हम आर्ग्युमेंट को null पर सेट नहीं करते हैं, तो डिफ़ॉल्ट रूप से डेटा को रिस्पॉन्स में पास कर दिया जाता है. भले ही, हम onend_response में इसे बदलें.
अब आपने एक प्लगिन बना लिया है और आपको उसे Edge Microgateway कॉन्फ़िगरेशन में जोड़ना होगा. $HOME/.edgemicro/[org]-[env]-config.yaml फ़ाइल खोलें. यहां org और env आपके Edge संगठन और एनवायरमेंट के नाम हैं.
नीचे दिखाए गए तरीके के मुताबिक, plugins:sequence एलिमेंट में response-override प्लगिन जोड़ें.
```
      ...
      
      plugins:
        dir: ../plugins
        sequence:
          - oauth
          - response-override
          
      ...
```
ध्यान दें: ध्यान दें: प्लगिन उसी क्रम में चलाए जाते हैं जिस क्रम में वे plugins:sequence की सूची में दिखते हैं.
Edge माइक्रोगेटवे को रीस्टार्ट करें.
Edge Microgateway से किसी एपीआई को कॉल करें. (यह एपीआई कॉल मानता है कि आपने वही कॉन्फ़िगरेशन सेट अप किया है जो एपीआई पासकोड की सुरक्षा वाले ट्यूटोरियल में किया गया है. इसके बारे में, Edge माइक्रोगेटवे को सेट अप और कॉन्फ़िगर करना सेक्शन में बताया गया है:
```
curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
Hello, World!
```

प्लगिन की बनावट

नीचे दिया गया Edge Microgateway सैंपल प्लगिन है, जिसमें वह पैटर्न दिखाया गया है जिसके हिसाब से आपको अपने प्लगिन डेवलप करने हैं. इस सेक्शन में बताए गए सैंपल प्लग इन का सोर्स कोड, plugins/header-uppercase/index.js. में है

प्लग इन, स्टैंडर्ड NPM मॉड्यूल होते हैं. इनमें रूट फ़ोल्डर में package.json और index.js मौजूद होते हैं.
प्लगिन को init() फ़ंक्शन एक्सपोर्ट करना चाहिए.
init() फ़ंक्शन में तीन आर्ग्युमेंट होते हैं: config, logger, और stats. इन आर्ग्युमेंट के बारे में प्लगिन init() फ़ंक्शन आर्ग्युमेंट में बताया गया है.
init(), नाम वाले फ़ंक्शन हैंडलर वाला एक ऑब्जेक्ट दिखाता है. इसे तब कॉल किया जाता है, जब किसी अनुरोध के पूरे समय के दौरान कुछ इवेंट होते हैं.

इवेंट हैंडलर के फ़ंक्शन

प्लगिन को इनमें से कुछ या सभी इवेंट हैंडलर फ़ंक्शन लागू करने होंगे. इन फ़ंक्शन को लागू करना आप पर निर्भर करता है. दिया गया कोई भी फ़ंक्शन ज़रूरी नहीं है. साथ ही, एक सामान्य प्लगिन, इन फ़ंक्शन के कम से कम एक सबसेट को लागू करेगा.

अनुरोध के फ़्लो इवेंट हैंडलर

इन फ़ंक्शन को Edge Microgateway में अनुरोध इवेंट पर कॉल किया जाता है.

onrequest
ondata_request
onend_request
onclose_request
onerror_request

onrequest फ़ंक्शन

क्लाइंट के अनुरोध की शुरुआत में कॉल किया गया. यह फ़ंक्शन तब ट्रिगर होता है, जब Edge Microgateway को अनुरोध का पहला बाइट मिलता है. इस फ़ंक्शन से आपको अनुरोध के हेडर, यूआरएल, क्वेरी पैरामीटर, और एचटीटीपी तरीके को ऐक्सेस करने की सुविधा मिलती है. अगर अगले सेशन में पहले सही तर्क (जैसे कि गड़बड़ी का कोई इंस्टेंस) को कॉल किया जाता है, तो अनुरोध की प्रोसेसिंग रुक जाती है. इसके बाद, टारगेट करने के अनुरोध की प्रोसेस शुरू नहीं की जाती.

उदाहरण:

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

ondata_request फ़ंक्शन

यह तब कॉल किया जाता है, जब क्लाइंट से कुछ डेटा मिलता है. अनुरोध के डेटा को प्लगिन के क्रम में अगले प्लगिन में पास करता है. क्रम में मौजूद आखिरी प्लगिन से मिलने वाली वैल्यू, टारगेट में भेजी जाती है. इस्तेमाल के एक उदाहरण के तौर पर नीचे दिया गया है कि टारगेट करने के लिए भेजे जाने से पहले, अनुरोध किए गए डेटा को पूरी तरह से बदला जाता है.

उदाहरण:

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

onend_request फ़ंक्शन

यह तब कॉल किया जाता है, जब क्लाइंट से अनुरोध किया गया पूरा डेटा मिल जाता है.

उदाहरण:

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

onclose_request फ़ंक्शन

इससे पता चलता है कि क्लाइंट कनेक्शन बंद हो गया है. इस फ़ंक्शन का इस्तेमाल उन मामलों में किया जा सकता है जहां क्लाइंट कनेक्शन भरोसेमंद नहीं है. इसे तब कॉल किया जाता है, जब क्लाइंट के साथ सॉकेट कनेक्शन बंद हो जाता है.

उदाहरण:

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

onerror_request फ़ंक्शन

क्लाइंट अनुरोध पाने में कोई गड़बड़ी होने पर कॉल किया जाता है.

उदाहरण:

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

रिस्पॉन्स फ़्लो इवेंट हैंडलर

इन फ़ंक्शन को Edge Microgateway में रिस्पॉन्स इवेंट पर कॉल किया जाता है.

onresponse
ondata_response
onend_response
onclose_response
onerror_response

onresponse फ़ंक्शन

टारगेट रिस्पॉन्स की शुरुआत में कॉल किया जाता है. यह फ़ंक्शन तब ट्रिगर होता है, जब Edge Microgateway को रिस्पॉन्स का पहला बाइट मिलता है. इस फ़ंक्शन से आपको रिस्पॉन्स हेडर और स्टेटस कोड का ऐक्सेस मिलता है.

उदाहरण:

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 फ़ंक्शन

यह तब कॉल किया जाता है, जब टारगेट से डेटा का एक हिस्सा मिलता है.

उदाहरण:

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

onend_response फ़ंक्शन

यह तब कॉल किया जाता है, जब टारगेट से रिस्पॉन्स का पूरा डेटा मिल जाता है.

उदाहरण:

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

onclose_response फ़ंक्शन

इससे पता चलता है कि टारगेट कनेक्शन बंद हो गया है. इस फ़ंक्शन का इस्तेमाल उन मामलों में किया जा सकता है जहां टारगेट कनेक्शन भरोसेमंद नहीं है. इसे तब कहा जाता है, जब टारगेट के लिए सॉकेट कनेक्शन बंद हो जाता है.

उदाहरण:

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

onerror_response फ़ंक्शन

टारगेट जवाब पाने में कोई गड़बड़ी होने पर कॉल किया जाता है.

उदाहरण:

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

प्लगिन इवेंट हैंडलर फ़ंक्शन के बारे में आपको क्या जानने की ज़रूरत है

जब Edge Microgateway दिए गए एपीआई अनुरोध को प्रोसेस करता है, तब होने वाले खास इवेंट के जवाब में, प्लग इन इवेंट हैंडलर फ़ंक्शन को कॉल किया जाता है.

प्रोसेस पूरी होने के बाद, हर init() फ़ंक्शन हैंडलर (ondata_request, ondata_response वगैरह) को next() कॉलबैक को कॉल करना होगा. अगर next() को कॉल नहीं किया जाता है, तो प्रोसेसिंग बंद हो जाएगी और अनुरोध रुक जाएगा.
next() में पहला आर्ग्युमेंट कोई गड़बड़ी हो सकती है. इस वजह से, अनुरोध की प्रोसेसिंग बंद हो जाएगी.
ondata_ और onend_ हैंडलर को दूसरे तर्क के साथ next() को कॉल करना होगा, जिसमें टारगेट या क्लाइंट को भेजा जाने वाला डेटा मौजूद होगा. अगर प्लग इन बफ़र हो रहा है और इस समय बदलने के लिए ज़रूरत के मुताबिक डेटा उपलब्ध नहीं है, तो यह तर्क शून्य हो सकता है.
ध्यान दें कि प्लगिन के एक इंस्टेंस का इस्तेमाल, सभी अनुरोधों और रिस्पॉन्स के लिए किया जाता है. अगर कोई प्लग इन कॉल के बीच हर अनुरोध की स्थिति को बनाए रखना चाहता है, तो वह उस स्थिति को दिए गए request ऑब्जेक्ट (req) में जोड़ी गई प्रॉपर्टी में सेव कर सकता है, जिसका लाइफ़टाइम, एपीआई कॉल की अवधि है.
सभी गड़बड़ियों को ठीक करते समय सावधानी बरतें और गड़बड़ी के साथ next() को कॉल करें. next() को कॉल न कर पाने की वजह से, एपीआई कॉल को हैंग कर दिया जाएगा.
ध्यान रखें कि मेमोरी लीक न होने दें, क्योंकि इससे Edge Microgateway की पूरी परफ़ॉर्मेंस पर असर पड़ सकता है. साथ ही, मेमोरी खत्म हो जाने पर, यह क्रैश हो सकता है.
ध्यान रखें कि मुख्य थ्रेड में कंप्यूट-इंटेसिव टास्क न करें और Node.js मॉडल को फ़ॉलो करें. इससे Edge माइक्रोगेटवे की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.

प्लगिन init() फ़ंक्शन के बारे में जानकारी

इस सेक्शन में init() फ़ंक्शन को पास किए गए आर्ग्युमेंट के बारे में बताया गया है: config, logger, और stats.

कॉन्फ़िगरेशन

Edge Microgateway कॉन्फ़िगरेशन फ़ाइल को Apigee Edge से डाउनलोड किए गए डेटा के साथ मर्ज करके, मिला कॉन्फ़िगरेशन डेटा, config नाम के ऑब्जेक्ट में रखा जाता है.

response-override नाम के प्लगिन में, foo की वैल्यू के साथ param नाम का कॉन्फ़िगरेशन पैरामीटर जोड़ने के लिए, इसे default.yaml फ़ाइल में डालें:

response-override:
    param: foo

इसके बाद, अपने प्लगिन कोड में पैरामीटर को इस तरह से ऐक्सेस किया जा सकता है:

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

इस मामले में, आपको प्लगिन डीबग आउटपुट में foo प्रिंट किया हुआ दिखेगा:

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

मर्ज किए गए माइक्रोगेटवे कॉन्फ़िगरेशन और डाउनलोड किए गए Apigee Edge के डेटा को, चाइल्ड ऑब्जेक्ट config.emgConfigs में ऐक्सेस किया जा सकता है. उदाहरण के लिए, इस कॉन्फ़िगरेशन डेटा को init फ़ंक्शन में इस तरह से ऐक्सेस किया जा सकता है:

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

ध्यान दें: emgConfigs ऑब्जेक्ट को v3.1.6 में जोड़ा गया था. कुंजी का नाम emgConfigs रिज़र्व है. YAML कॉन्फ़िगरेशन फ़ाइल में, किसी प्लगिन के कॉन्फ़िगरेशन के तहत किसी अन्य कॉन्फ़िगरेशन को तय करने के लिए, इसका इस्तेमाल नहीं किया जा सकता. अगर वैल्यू तय की जाती है, तो रनटाइम के दौरान इसे बदल दिया जाएगा.

नीचे डेटा का एक उदाहरण दिया गया है, जिसमें emgConfigs में शामिल है:

{
    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

सिस्टम लॉगर. हाल ही में काम करने वाला लॉगर, इन फ़ंक्शन को एक्सपोर्ट करता है. यहां ऑब्जेक्ट कोई स्ट्रिंग, एचटीटीपी अनुरोध, एचटीटीपी रिस्पॉन्स या गड़बड़ी का इंस्टेंस हो सकता है.

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

आंकड़े

ऐसा ऑब्जेक्ट जिसमें माइक्रोगेटवे इंस्टेंस से होने वाले अनुरोधों और रिस्पॉन्स से जुड़े अनुरोधों, जवाबों, गड़बड़ियों, और एग्रीगेट किए गए अन्य आंकड़ों की संख्या होती है.

treqErrors - गड़बड़ियों वाले टारगेट अनुरोधों की संख्या.
treqErrors - गड़बड़ियों वाले टारगेट जवाबों की संख्या.
statusCodes - रिस्पॉन्स कोड वाले ऑब्जेक्ट की गिनती की जाती है:

{
  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 - अनुरोधों की कुल संख्या.
responses - रिस्पॉन्स की कुल संख्या.
कनेक्शन - ऐक्टिव टारगेट कनेक्शन की संख्या.

Next() फ़ंक्शन के बारे में जानकारी

सीरीज़ के अगले तरीके को प्रोसेस करने के लिए, प्लगिन के सभी तरीकों को next() को कॉल करना होगा. ऐसा न करने पर, प्लगिन की प्रोसेस रुक जाएगी. अनुरोध की लाइफ़ साइकल में, पहला तरीका onrequest() है. कॉल किया जाने वाला अगला तरीका ondata_request() है. हालांकि, ondata_request को सिर्फ़ तब कॉल किया जाता है, जब अनुरोध में डेटा शामिल हो. जैसे, पोस्ट अनुरोध के लिए. इसके बाद, onend_request() वाला तरीका कॉल किया जाएगा. अनुरोध की प्रोसेसिंग पूरी होने के बाद, इस तरीके को कॉल किया जाएगा. onerror_* फ़ंक्शन को सिर्फ़ तब कॉल किया जाता है, जब कोई गड़बड़ी हो. साथ ही, इनकी मदद से, कस्टम कोड की मदद से गड़बड़ियों को ठीक किया जा सकता है.

मान लें कि अनुरोध में डेटा भेजा गया है और ondata_request() को कॉल किया जाता है. ध्यान दें कि फ़ंक्शन दो पैरामीटर के साथ next() को कॉल करता है:

next(null, data);

पारंपरिक तरीके से, पहले पैरामीटर का इस्तेमाल गड़बड़ी की जानकारी देने के लिए किया जाता है. इसके बाद, उस जानकारी को चेन में बाद में होने वाले फ़ंक्शन में मैनेज किया जा सकता है. इसे null पर सेट करने का मतलब है कि यह एक फ़र्ज़ी तर्क है. इसका मतलब है कि इसमें कोई गड़बड़ी नहीं है. साथ ही, अनुरोध की प्रोसेसिंग सामान्य तौर पर होनी चाहिए. अगर यह तर्क सही है (जैसे कि कोई गड़बड़ी वाला ऑब्जेक्ट), तो अनुरोध की प्रोसेस रुक जाती है और अनुरोध टारगेट को भेज दिया जाता है.

दूसरा पैरामीटर, अनुरोध के डेटा को चेन के अगले फ़ंक्शन को भेजता है. अगर कोई और प्रोसेस नहीं की जाती है, तो अनुरोध के डेटा में कोई बदलाव नहीं किया जाता. ऐसा, एपीआई के टारगेट में किया जाता है. हालांकि, आपके पास इस तरीके में अनुरोध के डेटा में बदलाव करने और बदले गए अनुरोध को टारगेट पर पास करने का मौका है. उदाहरण के लिए, अगर अनुरोध वाला डेटा एक्सएमएल होना चाहिए और टारगेट को JSON होना चाहिए, तो ondata_request() वाले तरीके में कोड जोड़ा जा सकता है. (a) अनुरोध के हेडर के कॉन्टेंट-टाइप को application/json में बदला जाता है. साथ ही, आपकी पसंद के मुताबिक डेटा का इस्तेमाल करके, अनुरोध के डेटा को JSON में बदला जाता है. उदाहरण के लिए, NPM से मिले Node.js xml2json कन्वर्टर का इस्तेमाल किया जा सकता है.

आइए, देखते हैं कि यह कैसा दिख सकता है:

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

इस मामले में, अनुरोध के डेटा (जिसे एक्सएमएल माना जाता है) को JSON में बदल दिया जाता है. साथ ही, बदले गए डेटा को बैकएंड टारगेट में भेजने से पहले, next() के ज़रिए अनुरोध की चेन में अगले फ़ंक्शन को भेजा जाता है.

ध्यान दें कि बदले गए डेटा को प्रिंट करने के लिए, आपके पास एक और डीबग स्टेटमेंट जोड़ने का विकल्प होता है. इसे डीबग करने के लिए इस्तेमाल किया जा सकता है. उदाहरण के लिए:

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

प्लगिन हैंडलर को एक्ज़ीक्यूट करने के क्रम के बारे में जानकारी

Edge माइक्रोगेटवे के लिए प्लग इन लिखने पर, आपको यह समझना होगा कि प्लग इन इवेंट हैंडलर किस क्रम में चलाए जाते हैं.

इस बात का खास ध्यान रखें कि Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में प्लगिन का क्रम तय करने पर, अनुरोध हैंडलर बढ़ते क्रम में लागू होते हैं. वहीं, रिस्पॉन्स हैंडलर घटते के क्रम में काम करते हैं.

नीचे दिए गए उदाहरण की मदद से, एक्ज़ीक्यूशन के इस क्रम को समझा जा सकता है.

1. तीन आसान प्लग इन बनाएं

नीचे दिए गए प्लगिन का इस्तेमाल करें. जब इसके इवेंट हैंडलर को कॉल किया जाता है, तब यह सिर्फ़ प्रिंट कंसोल आउटपुट के तौर पर काम करता है:

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

अब, एक ही कोड का इस्तेमाल करके plugin-2 और plugin-3, दो और प्लगिन बनाएं. इन्हें छोड़कर, console.log() स्टेटमेंट को plugin-2 और plugin-3 में बदलें.

2. प्लग इन कोड की समीक्षा करें

<microgateway-root-dir>/plugins/plugin-1/index.js में एक्सपोर्ट किए गए प्लगिन के फ़ंक्शन, इवेंट हैंडलर हैं. ये फ़ंक्शन, अनुरोध और रिस्पॉन्स को प्रोसेस करने के दौरान तय समय पर काम करते हैं. उदाहरण के लिए, onrequest, अनुरोध के हेडर का पहला बाइट एक्ज़ीक्यूट करता है. हालांकि, onend_response, रिस्पॉन्स का आखिरी बाइट मिलने के बाद काम करता है.

हैंडलर ondata_response पर एक नज़र डालें -- इसे तब कहा जाता है, जब रिस्पॉन्स से जुड़ा कुछ डेटा मिलता है. ज़रूरी बात यह है कि यह ज़रूरी नहीं है कि रिस्पॉन्स डेटा एक ही बार में मिले. इसके बजाय, हो सकता है कि डेटा ज़रूरत के हिसाब से अलग-अलग हिस्सों में मिले.

3. प्लगिन के क्रम में प्लग इन जोड़ें

इस उदाहरण में, हम Edge Microgateway कॉन्फ़िगरेशन फ़ाइल (~./edgemicro/config.yaml) में दिए गए प्लगिन के क्रम में, इस तरह प्लग इन जोड़ेंगे. क्रम ज़रूरी है. यह प्लगिन हैंडलर के चलने का क्रम तय करता है.

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

4. डीबग आउटपुट की जांच करना

अब इन प्लग इन को कॉल करने पर बनने वाले आउटपुट को देखते हैं. यहां कुछ ज़रूरी बातों का ध्यान रखा गया है:

Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल (~./edgemicro/config.yaml) का क्रम तय करता है. यह उस क्रम के बारे में बताता है जिसमें इवेंट हैंडलर कॉल किए जाते हैं.
अनुरोध हैंडलर को बढ़ते क्रम में कॉल किया जाता है (वह क्रम जिसमें वे प्लगिन के क्रम -- 1, 2, 3 में दिखते हैं).
रिस्पॉन्स हैंडलर को घटते क्रम में कॉल किया जाता है -- 3, 2, 1.
मिलने वाले डेटा के हर हिस्से के लिए, ondata_response हैंडलर को एक बार कॉल किया जाता है. इस उदाहरण (नीचे दिखाया गया आउटपुट) में दो अलग-अलग हिस्से मिले हैं.

यहां डीबग आउटपुट का नमूना दिया गया है जो इन तीन प्लग इन के इस्तेमाल में होने पर और Edge Microgateway के ज़रिए एक अनुरोध भेजने पर बनता है. बस उस क्रम पर ध्यान दें जिसमें हैंडलर कॉल किए जाते हैं:

  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

खास जानकारी

कस्टम प्लगिन के काम करने के तरीके (जैसे, अनुरोध या रिस्पॉन्स डेटा को इकट्ठा और बदलना) करते समय, उस क्रम को समझना ज़रूरी है जिसमें प्लगिन हैंडलर को कॉल किया जाता है.

बस यह याद रखें कि अनुरोध हैंडलर उसी क्रम में चलाए जाते हैं जिस क्रम में Edge Microgateway कॉन्फ़िगरेशन फ़ाइल में प्लगिन बताए गए हैं. साथ ही, रिस्पॉन्स हैंडलर को उलटे क्रम में चलाया जाता है.

प्लग इन में ग्लोबल वैरिएबल का इस्तेमाल करने के बारे में जानकारी

Edge Microgateway को किया गया हर अनुरोध, प्लगिन के एक ही इंस्टेंस पर भेजा जाता है. इसलिए, किसी दूसरे क्लाइंट की ओर से किए गए दूसरे अनुरोध की स्थिति, पहले की स्थिति की जगह ले लेगी. प्लगिन की स्थिति को सेव करने के लिए ही, अनुरोध या रिस्पॉन्स ऑब्जेक्ट पर प्रॉपर्टी में स्टेट को सेव करना सुरक्षित होता है (जिसका लाइफ़टाइम, अनुरोध किए गए समय तक ही किया जा सकता है).

प्लग इन में टारगेट यूआरएल को फिर से लिखना

वर्शन 2.3.3 में जोड़ा गया

अपने प्लग इन कोड में इन वैरिएबल में बदलाव करके, डिफ़ॉल्ट टारगेट यूआरएल को प्लगिन में बदला जा सकता है: req.targetHostname और req.targetPath.

इसमें जोड़ा गया: v2.4.x

टारगेट एंडपॉइंट पोर्ट को बदला भी जा सकता है. साथ ही, एचटीटीपी और एचटीटीपीएस में से किसी एक को चुना जा सकता है. अपने प्लग इन कोड में इन वैरिएबल में बदलाव करें: req.targetPort और req.targetSecure. एचटीटीपीएस चुनने के लिए, req.targetSecure को true पर सेट करें; एचटीटीपी के लिए, इसे false पर सेट करें. अगर आपने req.targetSecure को सही पर सेट किया हुआ है, तो ज़्यादा जानकारी के लिए यह चर्चा थ्रेड देखें.

वर्शन 3.3.3 में हटाया गया

eurekaclient नाम के प्लग इन को v.3.3.3 में Edge Microgateway से हटा दिया गया है. प्रॉडक्ट की जानकारी देखें.

इस सुविधा को हटाने से, Edge माइक्रोगेटवे के मुख्य फ़ंक्शन या टारगेट यूआरएल को फिर से लिखने पर कोई असर नहीं पड़ता. आप डाइनैमिक एंडपॉइंट लुकअप को कॉन्फ़िगर कर सकते हैं और प्लगिन लेवल पर req.targetHostname, req.targetPath, req.targetPort, और req.targetSecure जैसे टारगेट वैरिएबल को बदल सकते हैं. प्लगिन में टारगेट यूआरएल को फिर से लिखना देखें.

प्लगिन के सैंपल

ये प्लग इन आपको Edge Microgateway इंस्टॉलेशन के साथ दिए गए हैं. इन्हें यहां Edge Microgateway इंस्टॉलेशन में देखा जा सकता है:

[prefix]/lib/node_modules/edgemicro/plugins

इकट्ठा करने का अनुरोध

यह प्लगिन, क्लाइंट के डेटा के हिस्सों को अनुरोध ऑब्जेक्ट से जुड़ी कलेक्शन प्रॉपर्टी में इकट्ठा करता है. अनुरोध किया गया सारा डेटा मिलने पर, अरे को बफ़र में इकट्ठा किया जाता है और फिर उसे क्रम में अगले प्लगिन में भेज दिया जाता है. यह प्लग इन क्रम में पहला प्लग इन होना चाहिए, ताकि बाद के प्लग इन को इकट्ठा किया गया अनुरोध डेटा मिल सके.

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

    }

  };

}

एक-दूसरे का जवाब देना

यह प्लगिन, टारगेट के डेटा के हिस्सों को रिस्पॉन्स ऑब्जेक्ट से अटैच की गई अरे प्रॉपर्टी में इकट्ठा करता है. जवाब से जुड़ा पूरा डेटा मिलने के बाद, अरे को बफ़र में इकट्ठा किया जाता है और फिर उसे क्रम में मौजूद अगले प्लगिन में भेज दिया जाता है. यह प्लगिन, रिस्पॉन्स पर काम करता है, जो उलटे क्रम में प्रोसेस किए जाते हैं. इसलिए, आपको इसे क्रम में आखिरी प्लगिन के तौर पर रखना चाहिए.

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

  };

}

हेडर-अपरकेस प्लगिन

एज माइक्रोगेटवे डिस्ट्रिब्यूशन में, <microgateway-root-dir>/plugins/header-uppercase नाम का एक सैंपल प्लगिन शामिल होता है. इस नमूने में हर फ़ंक्शन हैंडलर के बारे में बताने वाली टिप्पणियां शामिल हैं. यह सैंपल, टारगेट रिस्पॉन्स के डेटा को आसानी से ट्रांसफ़ॉर्मेशन करता है. साथ ही, क्लाइंट के अनुरोध और टारगेट रिस्पॉन्स में कस्टम हेडर जोड़ता है.

यह रहा <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();
    }

  };

}

ट्रांसफ़ॉर्म-अपरकेस

यह एक सामान्य ट्रांसफ़ॉर्मेशन प्लगिन है. इसे अपने हिसाब से किसी भी तरह का ट्रांसफ़ॉर्मेशन ऐक्शन में बदला जा सकता है. इस उदाहरण में सिर्फ़ रिस्पॉन्स को बदला गया है और डेटा के लिए अंग्रेज़ी के बड़े अक्षरों का इस्तेमाल किया गया है.

सलाह: बेहतर होगा कि आप किसी भी ट्रांसफ़ॉर्मेशन प्लगिन से पहले उस ट्रांसफ़ॉर्मेशन प्लगिन का इस्तेमाल करें जो अनुरोध पर काम करता हो. इसी तरह, अगर किसी रिस्पॉन्स को बदला जा रहा है, तो ट्रांसफ़ॉर्मेशन प्लगिन के पहले रिस्पॉन्स-एक्क्यूमुलेट प्लगिन इस्तेमाल करें. ऐसा करने से, यह पक्का होता है कि ऑनएंड हैंडलर को भेजने से पहले, अनुरोध या रिस्पॉन्स का पूरा डेटा एक हिस्से में बांटा जाएगा.

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

  };

}