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

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

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

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

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

एलिमेंट का क्रम

इस उदाहरण में, <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 फ़्लो, PostFlow, और PostClientFlow को चलाने के लिए किया जाता है.

<Condition>

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

स्ट्रीम किस तरह की है String
पैरंट एलिमेंट <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[डॉट]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>

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

स्ट्रीम किस तरह की है String
पैरंट एलिमेंट <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>

तीसरा उदाहरण

नीचे दिए गए उदाहरण में किसी कंडिशनल फ़्लो में कई फ़्लो दिखाए गए हैं:

<!-- 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> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

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

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

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

चाइल्ड एलिमेंट Type ब्यौरा
<Condition> String यह एक कंडिशनल स्टेटमेंट के बारे में बताता है, जिसे रनटाइम के दौरान प्रोसेस किया जाता है. अगर स्टेटमेंट सही के तौर पर नतीजा दिखाता है, तो फ़्लो (और इसके सभी चरण) चलाए जाते हैं. अगर स्टेटमेंट गलत के तौर पर नतीजा दिखाता है, तो फ़्लो (और इसके सभी चरणों) को अनदेखा कर दिया जाता है.
<Description> String इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है. यह जानकारी बाहरी लोगों को नहीं दिखती.
<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 सेगमेंट में बाकी फ़्लो को छोड़ देता है.

तीसरा उदाहरण

यहां दिए गए उदाहरण में, "डिफ़ॉल्ट" <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>

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

डिफ़ॉल्ट फ़्लो की मदद से, नुकसान पहुंचाने वाले हमलों से अपने खाते को सुरक्षित रखा जा सकता है.

एट्रिब्यूट

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

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

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

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

<Name>

<Flow> में लागू की जाने वाली नीति के आईडी के बारे में बताता है.

स्ट्रीम किस तरह की है String
पैरंट एलिमेंट <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> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

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

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

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

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

<PostClientFlow>

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

स्ट्रीम किस तरह की है कॉम्प्लेक्स ऑब्जेक्ट
पैरंट एलिमेंट <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> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

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

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

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

चाइल्ड एलिमेंट Type ब्यौरा
<Description> String इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है.
<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> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

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

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

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

चाइल्ड एलिमेंट Type ब्यौरा
<Description> String इससे फ़्लो के बारे में कम शब्दों में जानकारी मिलती है.
<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> के चाइल्ड एलिमेंट के बारे में बताया गया है:

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

<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> के चाइल्ड एलिमेंट के बारे में बताया गया है:

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

<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> के चाइल्ड एलिमेंट के बारे में बताया गया है:

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