फ़्लो के साथ प्रॉक्सी के काम करने के तरीके को नियंत्रित करना

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

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

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

नीचे दिए गए फ़्लो कॉन्फ़िगरेशन के उदाहरण में, ऐसे फ़्लो के बारे में बताया गया है जिसमें पुष्टि करने वाली कुंजी की नीति लागू होती है. यह तब काम करती है, if इनकमिंग अनुरोध का पाथ / पर खत्म होता है और अनुरोध की एचटीटीपी कार्रवाई GET होती है.

<Flow name="Get Food Carts">
    <Description>Get Food Carts</Description>
    <Request>
        <Step>
            <Name>Verify-API-Key</Name>
        </Step>
    </Request>
    <Condition>(proxy.pathsuffix MatchesPath "/") and (request.verb = "GET")</Condition>
</Flow>

फ़्लो के <Name> एलिमेंट में मौजूद Verify-API-Key वैल्यू, उस नीति को शामिल करने का काम करती है जिसे प्रॉक्सी में कहीं और एक्सएमएल के साथ कॉन्फ़िगर किया गया हो, जैसे कि:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<VerifyAPIKey async="false" continueOnError="false" enabled="true" name="Verify-API-Key">
    <DisplayName>Verify API Key</DisplayName>
    <Properties/>
    <APIKey ref="request.header.x-api-key"/>
</VerifyAPIKey>

फ़्लो एक्ज़ीक्यूट करने का क्रम डिज़ाइन करना

आपका स्ट्रक्चर फ़्लो, ताकि आपके लॉजिक को प्रोसेसिंग पाथ में सही क्रम में लागू किया जा सके.

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

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

एंडपॉइंट टाइप ब्यौरा फ़्लो के लिए इस्तेमाल किया जा सकता है
ProxyEndpoint इसमें क्लाइंट के सबसे करीब का एपीआई प्रॉक्सी फ़्लो शामिल होता है. क्लाइंट के अनुरोध पर सबसे पहले, और फिर क्लाइंट के रिस्पॉन्स पर आखिरी बार काम करने के लिए, लॉजिक को जगहें देता है. PreFlow, कंडिशनल फ़्लो, PostFlow, PostClientFlow
TargetEndpoint इसमें बैकएंड संसाधन के सबसे करीब वाला एपीआई प्रॉक्सी फ़्लो शामिल है. लॉजिक के लिए जगह देता है, ताकि उसके लिए अनुरोध तैयार किया जा सके और फिर बैकएंड रिसॉर्स से मिलने वाले रिस्पॉन्स को मैनेज किया जा सके. PreFlow, कंडिशनल फ़्लो, PostFlow

एक्सएमएल के साथ फ़्लो कॉन्फ़िगर करें, जो यह तय करता है कि क्या होना चाहिए और किस क्रम में होना चाहिए. इस उदाहरण में दिखाया गया है कि प्रॉक्सी एंडपॉइंट और टारगेट एंडपॉइंट में, फ़्लो को क्रम से कैसे क्रम में लगाया जाता है:

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

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

रैंक फ़्लो टाइप ब्यौरा
1 PreFlow

यह तब काम आता है, जब आपको यह पक्का करने की ज़रूरत हो कि कोई और कोड इस्तेमाल होने से पहले कुछ कोड काम करता है.

अगर PreFlow, टारगेट एंडपॉइंट में है, तो यह प्रॉक्सी एंडपॉइंट के PostFlow के बाद काम करता है.

2 शर्तों के साथ फ़्लो

कंडीशनल (शर्त के साथ) लॉजिक के लिए जगह. PreFlow के बाद और PostFlow से पहले लागू किया जाता है.

हर सेगमेंट के लिए सिर्फ़ एक कंडिशनल फ़्लो लागू किया जाता है. यह पहला फ़्लो है जिसकी स्थिति 'सही' मिलती है. इसका मतलब है कि इनमें से हर एक के हिस्से के तौर पर, एक कंडिशनल फ़्लो लागू किया जा सकता है:
  • प्रॉक्सीEndpoint के अनुरोध की पाइपलाइन
  • टारगेटएंडपॉइंट के अनुरोध की पाइपलाइन
  • प्रॉक्सीEndpoint की प्रतिक्रिया पाइपलाइन
  • TargetEndpoint की रिस्पॉन्स पाइपलाइन
3 PostFlow

यह डेटा लॉग करने, अनुरोध को प्रोसेस करने के दौरान हुई किसी गतिविधि की सूचना देने वगैरह के लिए एक अच्छी जगह है. कंडिशनल फ़्लो और PreFlow के बाद लागू होता है.

अगर PostFlow प्रॉक्सी एंडपॉइंट में है और टारगेट एंडपॉइंट है, तो प्रॉक्सी एंडपॉइंट PostFlow, टारगेट एंडपॉइंट PreFlow से पहले काम करता है.

4 PostClientFlow (सिर्फ़ प्रॉक्सी फ़्लो) क्लाइंट को जवाब मिलने के बाद, मैसेज को लॉग करने का फ़्लो.

PreFlow के साथ पहले कोड को एक्ज़ीक्यूट करना

PreFlow तब काम आता है, जब आपको यह पक्का करना होता है कि कुछ और होने से पहले कुछ कोड काम करते हैं.

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

उदाहरण के लिए, आप आम तौर पर किसी ऐसे क्लाइंट को सेवा नहीं देना चाहते, जिसका कोटा पूरा हो चुका है. ये ज़रूरी शर्तें पूरी करने के लिए, आपको PreFlow सेगमेंट में सुरक्षा और कोटा की नीतियां शामिल करनी होंगी. इस तरह, आपको इस बात की चिंता करने की ज़रूरत नहीं है कि बाद में कंडिशनल फ़्लो में, किसी ऐसी स्थिति का आकलन नहीं हो पाएगा. इस फ़्लो में शामिल नीतियां, किसी भी तरह की प्रोसेस को पूरा करने से पहले लागू होंगी.

नीचे दिए गए उदाहरण में, SpikeArrest और कोटा नीतियां, कंडिशनल फ़्लो में प्रोसेस होने से पहले लागू होती हैं.

<PreFlow name="MyPreFlow">
    <Request>
        <Step>
            <Name>Spike-Arrest</Name>
        </Step>
        <Step>
            <Name>Quota</Name>
        </Step>
    </Request>
    <Response/>
</PreFlow>

कोड को कुछ शर्तों के साथ, कंडीशनल फ़्लो के साथ लागू करना

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

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

यहां, कोटा की सीमाएं सिर्फ़ तब लागू होती हैं, जब अनुरोध, /issue/** के यूआरआई पैटर्न (/समस्या/ यूआरआई में आखिरी फ़ॉरवर्ड स्लैश) के साथ हो, वाला GET अनुरोध हो.

<Flow name="MyFlow">
    <Description/>
    <Request>
        <Step>
            <Name>Quota</Name>
        </Step>
    </Request>
    <Response/>
    <Condition>(proxy.pathsuffix MatchesPath "/issue/**") and (request.verb = "GET")</Condition>
</Flow>

शर्तें तय करने के लिए, फ़्लो वैरिएबल का इस्तेमाल किया जाता है. कंडिशन में वैरिएबल का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, फ़्लो वैरिएबल वाली शर्तें देखें.

स्थितियों में पैटर्न मैचिंग का इस्तेमाल करने के उदाहरण के लिए, पैटर्न मैचिंग लेख देखें.

PostFlow का इस्तेमाल करके, कोड को कोर लॉजिक के बाद एक्ज़ीक्यूट किया जाना है

PostFlow, एंडपॉइंट की प्रोसेस पूरी होने से पहले और एंडपॉइंट की प्रोसेस पूरी होने से पहले, कार्रवाइयों को करने के लिए एक बेहतरीन जगह है. PostFlow, कंडिशनल फ़्लो और PreFlow के बाद काम करता है.

PostFlow, कुछ डेटा लॉग करने, कुछ होने की सूचना भेजने, जवाब के मैसेज के फ़ॉर्मैट को बदलने वगैरह के लिए एक अच्छी जगह है.

यहां दिए गए उदाहरण में, Apigee Edge के क्लाइंट को जवाब भेजने से पहले, SetResponseHeaders नाम की एक AssignmentsMessage नीति, रिस्पॉन्स मैसेज के हेडर सेट करती है.

<PostFlow>
    <Response>
        <Step>
            <Name>SetResponseHeaders</Name>
        </Step>
    </Response>
 </PostFlow>

क्लाइंट को PostClientFlow से आपकी प्रॉक्सी का जवाब मिलने के बाद कोड को एक्ज़ीक्यूट करना

PostClientFlow में ये नीतियां शामिल की जा सकती हैं:

* फ़्लो कॉलआउट नीति सिर्फ़ ऐसे शेयर किए गए फ़्लो को कॉल कर सकती है जो PostClientFlow में शामिल होने की शर्तों को पूरा करते हैं (जैसे, सिर्फ़ काम करने वाली नीतियां शामिल होती हैं).

अगर आपने कोई कोड शामिल किया है, तो उसे एक्ज़ीक्यूट करने के लिए, PostClientFlow आखिरी बार लागू करेगा. इसे क्लाइंट को रिस्पॉन्स भेजे जाने के बाद एक्ज़ीक्यूट किया जाएगा.

फ़ाइनल लॉगिंग के लिए PostClientFlow अच्छा है. साथ ही, आपके पास जवाब वाले मैसेज के लिए, शुरू और खत्म होने के टाइमस्टैंप लॉग करने का विकल्प भी है.

यहां PostClientFlow का उदाहरण दिया गया है, जिसमें MessageLogging नीति अटैच की गई है.

    ...
    <PostFlow name="PostFlow">
        <Request/>
        <Response/>
    </PostFlow>
    <PostClientFlow>
        <Request/>
        <Response>
            <Step>
                <Name>Message-Logging-1</Name>
            </Step>
        </Response>
    </PostClientFlow>
    ...

वीडियो: यह छोटा सा वीडियो देखें. इसमें, 'डेवलपर के लिए चार मिनट का वीडियो' (4MV4D) सीरीज़ की MessageLogging नीति का इस्तेमाल करके, PostClientFlow बनाने का तरीका बताया गया है.

ज़्यादा जानकारी के लिए, ये देखें:

फ़्लो में लॉजिक जोड़ना

अपने प्रॉक्सी में लॉजिक जोड़ने के बाद, उसके फ़्लो में नीतियां जोड़ी जा सकती हैं. जिस तरह फ़्लो एक क्रम में काम करते हैं उसी तरह, फ़्लो का कॉन्टेंट एक क्रम में लागू होता है. उदाहरण के लिए, PreFlow, फिर flow, फिर PostFlow, जैसा कि इस विषय में बताया गया है.

नीचे दिए गए उदाहरण में, फ़्लो कॉन्फ़िगरेशन में तीन नीतियों के बारे में बताया गया है. ये नीतियां, एक्सएमएल फ़ाइलों में किसी दूसरी जगह पर कॉन्फ़िगर की जाती हैं. Verify-API-Key में दी गई नीति, Remove-API-Key में बताई गई नीति से पहले लागू होती है. दोनों के बाद Quota में दिखाई गई नीति लागू होती है.

<Flow name="Get Food Cart Menus">
    <Description>Get Food Cart Menus</Description>
    <Request>
        <Step>
            <Name>Verify-API-Key</Name>
        </Step>
        <Step>
            <Name>Remove-API-Key</Name>
        </Step>
        <Step>
            <Name>Quota</Name>
        </Step>
    </Request>
    <Condition>(proxy.pathsuffix MatchesPath "/") and (request.verb = "GET")</Condition>
</Flow>

Apigee Edge कंसोल, नीतियों के इस क्रम को आइकॉन की एक पंक्ति के तौर पर दिखाता है. हर आइकॉन, नीति को दिखाता है.

Apigee Edge कंसोल, नीतियों के इस क्रम को आइकॉन की एक पंक्ति के तौर पर दिखाता है. हर आइकॉन, नीति को दिखाता है. अनुरोध के पाथ पर दिखाए गए आइकॉन: &#39;एपीआई पासकोड की पुष्टि करें&#39;, &#39;एपीआई पासकोड हटाएं&#39;, और कोटा

फ़्लो डीबग करना

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

प्रॉक्सी का पता लगाने के बारे में ज़्यादा जानने के लिए, ट्रेस टूल का इस्तेमाल करना लेख देखें.

फ़्लो में गड़बड़ियों को ठीक करना

एपीआई प्रॉक्सी में कई जगहों से गड़बड़ियां बढ़ाई जा सकती हैं, जिनमें फ़्लो से भी गड़बड़ियां शामिल हैं.

यहां दिए गए उदाहरण में, टारगेट एंडपॉइंट में PreFlow का रिस्पॉन्स स्टंजा दिया गया है. दूसरे शब्दों में, यह कोड ऐसा कोड होता है जो बैकएंड टारगेट से रिस्पॉन्स मिलते ही तुरंत लागू हो जाता है. उदाहरण में, अगर टारगेट से मिला जवाब 200 नहीं है, तो गलती बताई जाती है (सफलता).

<PreFlow name="PreFlow">
    <Response>
        <Step>
            <Name>RaiseFault</Name>
            <Condition>(response.status.code GreaterThan "200")</Condition>
        </Step>
    </Response>
</PreFlow>

गड़बड़ी ठीक करने के बारे में ज़्यादा जानने के लिए, गड़बड़ियां ठीक करना देखें.