फ़्लो कॉन्फ़िगरेशन का रेफ़रंस

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

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

हैरारकी और सिंटैक्स

यहां दिए गए उदाहरणों में, फ़्लो कॉन्फ़िगरेशन एलिमेंट की एलिमेंट हैरारकी और सिंटैक्स दिखाया गया है:

एलिमेंट हैरारकी

इस उदाहरण में, <ProxyEndpoint> और <TargetEndpoint> एलिमेंट में मौजूद फ़्लो कॉन्फ़िगरेशन एलिमेंट की हैरारकी दिखाई गई है:

<ProxyEndpoint | TargetEndpoint>
    <PreFlow>
          <Request>
                <Step>
                    <Condition>
                    <Name>
          <Response>
                <Step>
                    <Condition>
                    <Name>
          <Description>
    <Flows>
          <Flow>
                <Description>
                <Condition>
                <Request>
                      <Step>
                          
                <Response>
                      <Step>
                          
          <Description>
    <PostFlow>
          <Request>
                <Step>
                    
          <Response>
                <Step>
                    
          <Description>
    <PostClientFlow> (<ProxyEndpoint> only)
          <Response>
                
          <Description>

      // Additional configuration elements

</ProxyEndpoint | TargetEndpoint>

सिंटैक्स

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

<!-- ProxyEndpoint flow configuration file -->
<ProxyEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  <PostClientFlow name="flow_name">
    <Description>flow_description</Description>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

<!-- TargetEndpoint flow configuration file -->
<TargetEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
    ...
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  ...
</TargetEndpoint>

इन एलिमेंट का इस्तेमाल, PreFlow, Conditional Flow, PostFlow, और PostClientFlow के एक्ज़ीक्यूशन को तय करने के लिए किया जाता है.

<Condition>

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

समस्या स्ट्रिंग
पैरंट एलिमेंट <Flow>
<Step>
चाइल्ड एलिमेंट कोई नहीं

किसी शर्त को किसी खास चरण या पूरे फ़्लो पर लागू किया जा सकता है. यह इस बात पर निर्भर करता है कि आपने एलिमेंट को <Flow> या <Step> एलिमेंट में रखा है या नहीं:

// Condition can apply to just one step:        // Or to the flow:
<Flows>                                         <Flows>
  <Flow>                                          <Flow>
    <Step>                                          <Condition>
      <Condition>                                   <Step>
      <Name>                                          <Name>
      ...                                             ...
    ...                                             ...
  ...                                             ...
</Flows>                                        </Flows>

अगर <Step> में मौजूद कोई शर्त सही होती है, तो Edge उस चरण को पूरा करता है. अगर शर्त पूरी नहीं होती है, तो Edge इस चरण को छोड़ देता है.

अगर <Flow> में मौजूद कोई शर्त सही होती है, तो Edge, फ़्लो में मौजूद सभी चरणों को प्रोसेस करता है. अगर शर्त पूरी नहीं होती है, तो Edge पूरे फ़्लो को स्किप कर देता है.

सिंटैक्स

<Condition> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Condition>property operator "value"</Condition>

कहां:

property
वह फ़्लो वैरिएबल प्रॉपर्टी जिसका इस्तेमाल आपको अपनी शर्त में करना है. उदाहरण के लिए, request फ़्लो वैरिएबल में path और content नाम की प्रॉपर्टी होती हैं. इनका इस्तेमाल किसी शर्त में करने के लिए, flow_variable[dot]property_name तय करें: 
request.path
request.content

फ़्लो वैरिएबल और उनकी प्रॉपर्टी की पूरी सूची देखने के लिए, फ़्लो वैरिएबल का रेफ़रंस देखें.

operator
यह एक ऐसा कंस्ट्रक्ट है जिससे यह तय होता है कि आपकी शर्त का आकलन कैसे किया जाएगा. सामान्य ऑपरेटर में ये शामिल हैं: 
>     greater than           <=    less than or equal to
<     less than              >=    greater than or equal to
=     equals                 &&    and
!=    not equals             ||    or

~~    JavaRegex
~     Matches
/~    MatchesPath

पूरी सूची देखने के लिए, शर्तों के रेफ़रंस में ऑपरेटर देखें.

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

उदाहरण 1

यहां दिए गए उदाहरण में, यह जांच की गई है कि request फ़्लो वैरिएबल की verb प्रॉपर्टी "GET" है या नहीं:

<!-- api-platform/reference/examples/flow-segments/condition-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  ...
</ProxyEndpoint>

अगर अनुरोध "GET" है, तो यह उदाहरण "Log-Request-OK" नीति को लागू करता है.

उदाहरण 2

यहां दिए गए उदाहरण में, रिस्पॉन्स कोड की जांच की गई है:

<!-- api-platform/reference/examples/flow-segments/condition-2.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

कोड की वैल्यू के आधार पर, अलग-अलग नीतियां लागू की जाती हैं.

विशेषताएं

<Condition> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

<Condition> एलिमेंट में कोई चाइल्ड एलिमेंट नहीं है.

<Description>

इसमें फ़्लो के बारे में ऐसी जानकारी होती है जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. इस एलिमेंट का इस्तेमाल करके, खुद को या अन्य डेवलपर को फ़्लो के बारे में जानकारी दें. यह जानकारी बाहरी तौर पर नहीं दिखती.

समस्या स्ट्रिंग
पैरंट एलिमेंट <Flow>
<PreFlow>
<PostFlow>
चाइल्ड एलिमेंट कोई नहीं

सिंटैक्स

<Description> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Description>flow_description</Description>

उदाहरण

यहां दिए गए उदाहरण में, <Description> एलिमेंट दिखाया गया है. यह एलिमेंट, किसी फ़्लो के मकसद के बारे में बताता है:

<!-- api-platform/reference/examples/flow-segments/description-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

विशेषताएं

<Description> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

<Description> एलिमेंट में कोई चाइल्ड एलिमेंट नहीं है.

<Flow>

यह एलिमेंट, Edge के लिए कस्टम स्टेप का एक सेट तय करता है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <Flows>
चाइल्ड एलिमेंट <Condition>
<Description>
<Request>
<Response>

आपके पास <Flow> पर <Condition> तय करने का विकल्प होता है. ऐसे में, Edge सिर्फ़ तब फ़्लो में दिए गए चरणों को पूरा करता है, जब शर्त सही हो. ऐसा न होने पर, Edge इस पूरे फ़्लो को छोड़ देता है.

<Flows> एलिमेंट में कई <Flow> एलिमेंट हो सकते हैं. हर एलिमेंट की अपनी शर्त और चरण होते हैं. जब एक से ज़्यादा <Flow> एलिमेंट होते हैं, तो Edge सिर्फ़ उस पहले एलिमेंट को लागू करता है जिसमें कोई शर्त नहीं होती या शर्त सही होती है.

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

सिंटैक्स

<Flow> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Flow name="conditional_flow_name">
  <Description>flow_description</Description>
  <Condition>property operator "value"</Condition>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</Flow>

<Flow> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण 1

यहां दिए गए उदाहरण में, एक सामान्य <Flow> दिखाया गया है. यह हमेशा "Log-Message-OK" नीति को लागू करता है:

<!-- api-platform/reference/examples/flow-segments/flow-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-flow">
    <Flow>
      <Request>
        <Step>
          <Name>Log-Message-OK</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

उदाहरण 2

यहां दिए गए उदाहरण में, कई चरणों वाला <Flow> दिखाया गया है. हर चरण की अपनी शर्त है:

<!-- api-platform/reference/examples/flow-segments/flow-2.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

उदाहरण 3

यहां दिए गए उदाहरण में, शर्त के साथ फ़्लो में कई फ़्लो दिखाए गए हैं:

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Edge, किसी सेगमेंट में सिर्फ़ एक फ़्लो को एक्ज़ीक्यूट करता है. यह उस पहले फ़्लो को एक्ज़ीक्यूट करता है जिसमें कोई शर्त नहीं होती या जिसकी शर्त सही होती है.

विशेषताएं

यहां दी गई टेबल में, <Flow> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

एट्रिब्यूट टाइप ब्यौरा
name स्ट्रिंग (ज़रूरी है) यह फ़्लो के लिए यूनीक आईडी होता है. उदाहरण के लिए, "My-Conditional-Flow-1". नाम में स्पेस या अन्य खास वर्ण नहीं होने चाहिए.

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <Flow> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Condition> स्ट्रिंग यह एक ऐसी शर्त वाली स्टेटमेंट तय करता है जिसे रनटाइम पर प्रोसेस किया जाता है. अगर स्टेटमेंट का आकलन सही के तौर पर किया जाता है, तो फ़्लो (और उसके सभी चरण) लागू किए जाते हैं. अगर स्टेटमेंट का आकलन गलत के तौर पर किया जाता है, तो फ़्लो (और उसके सभी चरणों) को अनदेखा कर दिया जाता है.
<Description> स्ट्रिंग इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है. यह जानकारी बाहरी तौर पर नहीं दिखती.
<Request> कॉम्प्लेक्स ऑब्जेक्ट अनुरोध सेगमेंट के लिए चरण और शर्तें तय करता है.
<Response> कॉम्प्लेक्स ऑब्जेक्ट इससे जवाब के सेगमेंट के लिए चरण और शर्तें तय की जाती हैं.

<Flows>

इसमें शून्य या उससे ज़्यादा <Flow> एलिमेंट होते हैं.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <ProxyEndpoint>
<TargetEndpoint>
चाइल्ड एलिमेंट <Flow>

अगर <Flows> में एक से ज़्यादा <Flow> एलिमेंट हैं, तो सिर्फ़ एक <Flow> एलिमेंट लागू होगा. यह पहला फ़्लो होगा, जिसमें <Condition> नहीं होगा या जिसकी शर्त सही होगी.

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

सिंटैक्स

<Flows> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Flows name="flow_name">
  <Flow name="conditional_flow_name">
    <Description>flow_description</Description>
    <Condition>property operator "value"</Condition>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </Flow>
</Flows>

<Flows> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण 1

इस उदाहरण में, एक <Flow> के साथ एक सामान्य <Flows> एलिमेंट दिखाया गया है:

<!-- api-platform/reference/examples/flow-segments/flows-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Edge, पाथ सफ़िक्स के आधार पर इनमें से किसी एक नीति को लागू करता है. यह पाथ सफ़िक्स, proxy फ़्लो वैरिएबल से इकट्ठा किया जाता है. अगर पाथ सफ़िक्स, किसी भी शर्त से मेल नहीं खाता है, तो Edge इस फ़्लो को लागू नहीं करता.

उदाहरण 2

इस उदाहरण में, <Flows> के अंदर कई <Flow> एलिमेंट दिखाए गए हैं. हर एलिमेंट का अपना <Condition> है:

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Edge, किसी सेगमेंट में सिर्फ़ उस फ़्लो को एक्ज़ीक्यूट करता है जिसकी शर्त सही होती है. इसके बाद, Edge उस सेगमेंट में मौजूद बाकी फ़्लो को छोड़ देता है.

उदाहरण 3

यहां दिए गए उदाहरण में, "डिफ़ॉल्ट" <Flow> दिखाया गया है:

<!-- api-platform/reference/examples/flow-segments/flows-3.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-conditional-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-conditional-flow-2">
      <Response>
        <Step>
          <Condition>response.header.someheader = "42"</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-default-flow">
      <Response>
        <Step>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Edge, किसी सेगमेंट में सिर्फ़ उस फ़्लो को एक्ज़ीक्यूट करता है जिसकी शर्त सही होती है. अगर शर्तों के साथ कोई फ़्लो लागू नहीं होता है, तो इस उदाहरण में तीसरा फ़्लो (बिना किसी शर्त के) लागू होता है.

डिफ़ॉल्ट फ़्लो, नुकसान पहुंचाने वाले हमलों से बचाने में मददगार हो सकता है.

विशेषताएं

<Flows> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

<Flows> एलिमेंट में ये चाइल्ड एलिमेंट होते हैं:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Flow> कॉम्प्लेक्स ऑब्जेक्ट यह एक ऐसा फ़्लो होता है जो शर्त के हिसाब से तय किए गए फ़्लो में, चरणों का एक संभावित सेट तय करता है.

<Name>

इस विकल्प से, <Flow> में लागू की जाने वाली नीति का आईडी तय किया जाता है.

समस्या स्ट्रिंग
पैरंट एलिमेंट <Step>
चाइल्ड एलिमेंट कोई नहीं

सिंटैक्स

<Name> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Name>policy_name</Name>

उदाहरण

यहां दिए गए उदाहरण में, नाम के हिसाब से फ़्लो में जोड़ी गई दो नीतियां दिखाई गई हैं:

<!-- api-platform/reference/examples/flow-segments/name-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

विशेषताएं

<Name> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

<Name> एलिमेंट में कोई चाइल्ड एलिमेंट नहीं है.

<PostFlow>

अनुरोध और जवाब के PostFlow में किए जाने वाले चरणों के बारे में बताता है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <ProxyEndpoint>
<TargetEndpoint>
चाइल्ड एलिमेंट <Description>
<Request>
<Response>

<PostFlow> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

सिंटैक्स

<PostFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostFlow>

उदाहरण

यहां दिए गए उदाहरण में, अनुरोध और जवाब, दोनों के लिए तय किए गए चरणों के साथ PostFlow दिखाया गया है:

<!-- api-platform/reference/examples/flow-segments/postflow-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Name>Set-Response-Headers</Name>
      </Step>
    </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

विशेषताएं

यहां दी गई टेबल में, <PostFlow> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

एट्रिब्यूट टाइप ब्यौरा
name स्ट्रिंग फ़्लो के लिए यूनीक आईडी (एंडपॉइंट में यूनीक होना चाहिए). उदाहरण के लिए, "My-PostFlow-1". वैल्यू में स्पेस या अन्य खास वर्ण शामिल नहीं किए जा सकते.

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <PostFlow> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Description> स्ट्रिंग इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है.
<Request> कॉम्प्लेक्स ऑब्जेक्ट यह अनुरोध के PostFlow के दौरान लागू की जाने वाली नीतियां तय करता है.
<Response> कॉम्प्लेक्स ऑब्जेक्ट यह नीति, जवाब के PostFlow के दौरान लागू होने वाली नीतियों के बारे में बताती है.

<PostClientFlow>

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

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <ProxyEndpoint>
चाइल्ड एलिमेंट <Description>
<Response>

सिंटैक्स

<PostClientFlow> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<PostClientFlow name="flow_name">
  <Description>flow_description</Description>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostClientFlow>

<PostClientFlow> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण

यहां दिए गए उदाहरण में, एक सामान्य PostClientFlow दिखाया गया है. यह एक ही नीति को लागू करता है:

<!-- api-platform/reference/examples/flow-segments/postclientflow-1.xml -->
<ProxyEndpoint name="default">
  <PostClientFlow name="my-postclientflows">
    <Description>My first PostClientFlow. Processed after the response is sent back to the client.</Description>
    <Response>
      <Step>
        <Name>Message-Logging-OK</Name>
      </Step>
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

विशेषताएं

यहां दी गई टेबल में, <PostClientFlow> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

एट्रिब्यूट टाइप ब्यौरा
name स्ट्रिंग फ़्लो का यूनीक आईडी. नाम में स्पेस या अन्य खास वर्ण शामिल नहीं किए जा सकते. उदाहरण के लिए, "My-PostClientFlow-1".

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <PostClientFlow> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Description> स्ट्रिंग इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है.
<Response> कॉम्प्लेक्स ऑब्जेक्ट यह नीति, जवाब के PostFlow के दौरान लागू होने वाली नीतियों के बारे में बताती है.

<PreFlow>

यह अनुरोध और जवाब के PreFlow में लागू की जाने वाली नीतियों के बारे में बताता है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <ProxyEndpoint>
<TargetEndpoint>
चाइल्ड एलिमेंट <Description>
<Request>
<Response>

सिंटैक्स

<PreFlow> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<PreFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PreFlow>

<PreFlow> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण

यहां दिए गए उदाहरण में, अनुरोध और जवाब के फ़्लो के साथ PreFlow दिखाया गया है:

<!-- api-platform/reference/examples/flow-segments/preflow-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

विशेषताएं

यहां दी गई टेबल में, <PreFlow> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

एट्रिब्यूट टाइप ब्यौरा
name स्ट्रिंग फ़्लो का यूनीक आईडी. नाम में स्पेस या अन्य खास वर्ण शामिल नहीं किए जा सकते. उदाहरण के लिए, "My-PreFlow-1".

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <PreFlow> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Description> स्ट्रिंग इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है.
<Request> कॉम्प्लेक्स ऑब्जेक्ट इस एलिमेंट में, अनुरोध के PreFlow के दौरान लागू की जाने वाली नीतियां तय की जाती हैं.
<Response> कॉम्प्लेक्स ऑब्जेक्ट यह नीति, जवाब के PreFlow के दौरान लागू की जाने वाली नीतियों के बारे में बताती है.

<Request>

यह फ़्लो के अनुरोध सेगमेंट के दौरान लागू की जाने वाली नीतियां तय करता है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <Flow>
<PreFlow>
<PostFlow>
चाइल्ड एलिमेंट <Condition>
<Step>

सिंटैक्स

<Request> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Request>
  <Step>
    <Condition>property operator "value"</Condition>
    <Name>policy_name</Name>
  </Step>
  ...
</Request>

<Request> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण

यहां दिए गए उदाहरण में, PreFlow और PostFlow, दोनों में अनुरोध के लिए तय किए गए फ़्लो दिखाए गए हैं:

<!-- api-platform/reference/examples/flow-segments/request-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PostFlow>
  ...
</ProxyEndpoint>

विशेषताएं

<Request> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <Request> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Condition> कॉम्प्लेक्स ऑब्जेक्ट इससे यह तय होता है कि अनुरोध सेगमेंट में मौजूद चरणों को लागू किया गया है या नहीं.
<Step> स्ट्रिंग अनुरोध सेगमेंट में लागू की जाने वाली नीति के बारे में बताता है.

<Response>

यह फ़्लो के जवाब वाले सेगमेंट के दौरान लागू की जाने वाली नीतियां तय करता है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <Flow>
<PreFlow>
<PostClientFlow>
<PostFlow>
चाइल्ड एलिमेंट <Condition>
<Step>

सिंटैक्स

<Response> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Response>
  <Step>
    <Condition>property operator "value"</Condition>
    <Name>policy_name</Name>
  </Step>
  ...
</Response>

<Response> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण

यहां दिए गए उदाहरण में, PreFlow और PostFlow, दोनों में रिस्पॉन्स के लिए तय किए गए फ़्लो दिखाए गए हैं:

<!-- api-platform/reference/examples/flow-segments/response-1.xml -->
<ProxyEndpoint name="default">
    <PreFlow name="my-preFlows">
        <Description>My first PreFlow</Description>
        <Response>
            <Step>
                <Condition>response.status.code LesserThanOrEquals 300</Condition>
                <Name>Log-Response-OK</Name>
            </Step>
            <Step>
                <Condition>response.status.code GreaterThan 300</Condition>
                <Name>Log-Response-NOT-OK</Name>
            </Step>
        </Response>
    </PreFlow>
    <PostFlow name="my-postflows">
        <Description>My first PostFlow</Description>
        <Response>
            <Step>
                <Name>Set-Response-Headers</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

विशेषताएं

<Response> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <Response> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Condition> स्ट्रिंग इससे यह तय होता है कि जवाब के सेगमेंट में दिए गए चरणों को पूरा किया गया है या नहीं.
<Step> स्ट्रिंग जवाब के सेगमेंट में लागू की जाने वाली नीति के बारे में बताता है.

<Step>

यह नीति को लागू करने के लिए तय करता है. साथ ही, यह भी तय करता है कि उस नीति को लागू करना है या नहीं. हालांकि, यह ज़रूरी नहीं है.

समस्या कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <Request>
<Response>
चाइल्ड एलिमेंट <Condition>
<Name>

<Flow> में एक से ज़्यादा चरण तय किए जा सकते हैं. इन चरणों को उसी क्रम में पूरा किया जाता है जिस क्रम में इन्हें फ़्लो के एक्सएमएल में तय किया गया है.

जिन चरणों में कोई शर्त नहीं होती है वे हमेशा पूरे होते हैं. शर्त वाले चरण सिर्फ़ तब लागू होते हैं, जब शर्त सही हो. अगर शर्त पूरी नहीं होती है, तो Edge इस चरण को छोड़ देता है.

सिंटैक्स

<Step> एलिमेंट में इस सिंटैक्स का इस्तेमाल किया जाता है:

<Step>
  <Condition>property operator "value"</Condition>
  <Name>policy_name</Name>
</Step>

हर <Step> के लिए, सिर्फ़ एक <Condition> और एक <Name> हो सकता है. हालांकि, एक <Flow> में कई चरण हो सकते हैं.

<Step> के सभी चाइल्ड एलिमेंट वैकल्पिक हैं.

उदाहरण 1

यहां दिए गए उदाहरण में, एक शर्त वाला और एक बिना शर्त वाला चरण दिखाया गया है:

<!-- api-platform/reference/examples/flow-segments/step-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
      <Description>My first PostFlow</Description>
      <Request>
          <Step>
              <Condition>request.verb = "GET"</Condition>
              <Name>Log-Request-OK</Name>
          </Step>
      </Request>
      <Response>
          <Step>
              <Name>Set-Response-Headers</Name>
          </Step>
      </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

शर्त के बिना वाला चरण, अनुरोध सेगमेंट के दौरान हर बार लागू होगा. शर्त वाला चरण, सिर्फ़ तब पूरा होगा, जब रिस्पॉन्स सेगमेंट के दौरान अनुरोध "GET" हो.

उदाहरण 2

यहां दिए गए उदाहरण में, एक ही सेगमेंट में कई चरण दिखाए गए हैं:

<!-- api-platform/reference/examples/flow-segments/step-2.xml -->
<ProxyEndpoint name="default">
    <PostFlow name="PostFlow">
        <Response>
            <Step>
                <Name>Assign-Message-1</Name>
            </Step>
            <Step>
                <Name>Assign-Message-2</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

जिन चरणों में कोई शर्त नहीं होती है वे हमेशा पूरे होते हैं.

विशेषताएं

<Step> एलिमेंट में कोई एट्रिब्यूट नहीं है.

चाइल्ड एलिमेंट

यहां दी गई टेबल में, <Step> के चाइल्ड एलिमेंट के बारे में बताया गया है:

चाइल्ड एलिमेंट टाइप ब्यौरा
<Condition> स्ट्रिंग यह उस चरण के लिए शर्त वाला स्टेटमेंट तय करता है जिसे रनटाइम में प्रोसेस किया जाता है. अगर स्टेटमेंट का आकलन सही होता है, तो Edge इस चरण को पूरा करता है. अगर स्टेटमेंट का आकलन गलत के तौर पर होता है, तो Edge इस चरण को छोड़ देता है.
<Name> स्ट्रिंग यह मौजूदा फ़्लो में लागू की जाने वाली नीति का आईडी तय करता है.