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

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

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

Edge Microgateway v. 3.1.5 और उसके बाद के वर्शन

दर्शक

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

अगर Edge माइक्रोगेटवे चल रहा है, तो इसे अभी बंद कर दें:
```
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), इवेंट हैंडलर होते हैं. जब भी Edge माइक्रोगेटवे को डेटा का कोई हिस्सा मिलता है, तब ondata_response फ़ंक्शन को कॉल किया जाता है. onend_response फ़ंक्शन को तब कॉल किया जाता है, जब रिस्पॉन्स डेटा का लास्ट बाइट मिलता है.

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

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

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

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

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

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

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

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

onrequest
ondata_request
onend_request
onclose_request
onerror_request

onrequest फ़ंक्शन

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

उदाहरण:

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 माइक्रोगेटवे में रिस्पॉन्स इवेंट पर कॉल किया जाता है.

onresponse
ondata_response
onend_response
onclose_response
onerror_response

onresponse फ़ंक्शन

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

उदाहरण:

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

ध्यान दें: इसमें जोड़ा गया: v2.3.3

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

function(sourceRequest, sourceResponse, targetResponse, data, next)

onend_response फ़ंक्शन

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

उदाहरण:

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

ध्यान दें: इसमें जोड़ा गया: v2.3.3

function(sourceRequest, sourceResponse, targetResponse, data, next)

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 माइक्रोगेटवे की परफ़ॉर्मेंस पर असर पड़ सकता है. साथ ही, मेमोरी खत्म होने पर, यह क्रैश भी हो सकता है.
ध्यान रखें कि मुख्य थ्रेड में कंप्यूट-इंटेसिव टास्क न करके Node.js मॉडल को अपनाएं, क्योंकि इससे Edge माइक्रोगेटवे की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.

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

यह सेक्शन init() फ़ंक्शन को पास किए गए तर्कों की जानकारी देता है: config, logger, और stats.

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

Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल को 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

मर्ज किए गए माइक्रोगेटवे कॉन्फ़िगरेशन को ऐक्सेस किया जा सकता है और चाइल्ड ऑब्जेक्ट config.emgConfigs में, Apigee Edge का डेटा डाउनलोड किया जा सकता है. उदाहरण के लिए, 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. तीन आसान प्लग इन बनाएं

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

प्लगिन/प्लगिन-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 माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल (~./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 माइक्रोगेटवे की मदद से अनुरोध भेजा जाता है. बस उस क्रम पर ध्यान दें जिसमें हैंडलर को कॉल किया जाता है:

  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 माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में प्लग इन बताए गए हैं और रिस्पॉन्स हैंडलर को उलटे क्रम में चलाया जाता है.

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

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

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

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

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

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

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

Edge Microgateway में eurekaclient नाम का एक प्लग इन जोड़ा गया है. यह प्लग बताता है कि req.targetPort और req.targetSecure वैरिएबल को कैसे इस्तेमाल किया जाता है. साथ ही, यह दिखाता है कि Edge माइक्रोगेटवे, यूरेका को सर्विस एंडपॉइंट कैटलॉग के तौर पर इस्तेमाल करके, डाइनैमिक एंडपॉइंट लुकअप का इस्तेमाल कैसे कर सकता है.

प्लगिन के नमूने

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

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

  };

}