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

आपको Apigee Edge दस्तावेज़ दिख रहा है.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इस पेज पर जाएं Apigee X दस्तावेज़. जानकारी

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

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

फ़्लो कॉन्फ़िगरेशन के नीचे दिए गए उदाहरण में, ऐसे फ़्लो के बारे में बताया गया है जिसमें VerifyAPIKey नीति काम करती है इस नीति की मदद से, अगर आने वाले अनुरोध का पाथ, / और अनुरोध के एचटीटीपी पर खत्म होता है, तो इस नीति को लागू किया जाता है क्रिया 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>

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

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

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

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

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

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

कोड एक्ज़ीक्यूट होना पहले 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 में बदलना चाहें जब अनुरोध करने वाला ऐप्लिकेशन किसी मोबाइल डिवाइस पर चल रहा हो.

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

<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 अच्छा प्लैटफ़ॉर्म है रिस्पॉन्स मैसेज के फ़ॉर्मैट में बदलाव कर सकता है.

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

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

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

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

• एक्सटेंशन कॉल आउट नीति
• फ़्लोकॉलआउट की नीति^*
• MessageLogging की नीति
• सर्विसकॉलआउट की नीति

^* फ़्लोकॉलआउट नीति सिर्फ़ उन शेयर किए गए फ़्लो को कॉल कर सकती है जो खुद का इस्तेमाल करने के लिए शर्तें पूरी करता है. जैसे, सिर्फ़ काम करने वाली नीतियां शामिल करना.

अगर आप किसी एक को शामिल करते हैं, तो एक PostClientFlow, क्लाइंट को जवाब भेज दिया जाता है.

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

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

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

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

• एपीआई प्रॉक्सी कॉन्फ़िगरेशन के बारे में जानकारी
• ट्यूटोरियल : Apigee Edge - क्लाइंट फ़्लो पोस्ट करें समुदाय लेख

फ़्लो में लॉजिक जोड़ा जा रहा है

जब प्रॉक्सी में लॉजिक जोड़ा जाता है, तब प्रॉक्सी के फ़्लो में नीतियां जोड़कर ऐसा किया जाता है. जिस तरह फ़्लो एक क्रम में लागू होते हैं (PreFlow के बाद फ़्लो और फिर 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 ट्रेस टूल, ग्राफ़िक का इस्तेमाल करके यह बताता है कि आपके एपीआई प्रॉक्सी में लॉजिक कैसे इस्तेमाल होता है एक अनुरोध के बाद निष्पादित होता है. यह टूल अनुरोध और प्रतिक्रिया के बीच की प्रोसेसिंग को दिखाता है. यह यह खास तौर पर PreFlow, कंडिशनल फ़्लो, और पोस्टफ़्लो.

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

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

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

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

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

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