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

आपको 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, कंडिशनल फ़्लो, 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[बिंदु]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 स्ट्रिंग (ज़रूरी है) फ़्लो के लिए एक यूनीक आईडी. उदाहरण के लिए, &quot;My-Conditional-Flow-1&quot;. नाम में स्पेस या अन्य खास वर्ण नहीं हो सकते.

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

नीचे दी गई टेबल में, <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>
चाइल्ड एलिमेंट <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 और, दोनों में अनुरोध के लिए तय किए गए फ़्लो को दिखाया गया है पोस्टफ़्लो:

<!-- 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 और पोस्टफ़्लो:

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