कोटा नीति

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

क्या

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

• वह प्रॉडक्ट जिसमें एपीआई प्रॉक्सी शामिल है
• एपीआई का अनुरोध करने वाला ऐप्लिकेशन
• ऐप्लिकेशन डेवलपर
• कई अन्य मानदंड

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

वीडियो

इन वीडियो में, कोटा नीति के तहत कोटा मैनेज करने के बारे में बताया गया है:

सैंपल

नीति के कोड के इन सैंपल में, कोटा की अवधि शुरू और खत्म करने का तरीका बताया गया है. इसके लिए:

<Quota name="CheckQuota">
  <Interval ref="verifyapikey.verify-api-key.apiproduct.developer.quota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.quota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.quota.limit"/>
</Quota>

<Quota name="DeveloperQuota">
  <Identifier ref="verifyapikey.verify-api-key.client_id"/>
  <Interval ref="verifyapikey.verify-api-key.developer.timeInterval"/>
  <TimeUnit ref="verifyapikey.verify-api-key.developer.timeUnit"/>
  <Allow countRef="verifyapikey.verify-api-key.developer.limit"/>
</Quota>

<Quota name="QuotaPolicy" type="calendar">
  <StartTime>2017-02-18 10:30:00</StartTime>
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</Quota>

<Quota name="QuotaPolicy">
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</Quota>

<AssignMessage async="false" continueOnError="false" enabled="true" name="ReturnQuotaVars">
    <AssignTo createNew="false" type="response"/>
    <Set>
        <Headers>
            <Header name="QuotaLimit">{ratelimit.QuotaPolicy.allowed.count}</Header>
            <Header name="QuotaUsed">{ratelimit.QuotaPolicy.used.count}</Header>
            <Header name="QuotaResetUTC">{ratelimit.QuotaPolicy.expiry.time}</Header>
        </Headers>
    </Set>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

<Quota name="MyQuota">
  <Interval>1</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="10000"/>
</Quota>

<Quota name="QuotaPolicy" type="calendar">
  <Identifier ref="request.header.clientId"/>
  <StartTime>2017-02-18 10:00:00</StartTime>
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</Quota>

<Identifier ref="request.queryparam.id"/>

<Identifier ref="verifyapikey.verify-api-key.client_id"></Identifier>

<Quota name="QuotaPolicy">
  <Interval>1</Interval>
  <TimeUnit>day</TimeUnit>
  <Allow>
    <Class ref="request.header.developer_segment">
      <Allow class="platinum" count="10000"/>
      <Allow class="silver" count="1000" />
    </Class>
  </Allow>
</Quota>

कोटा नीति के बारे में जानकारी

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

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

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

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

कोटा से जुड़ी नीति के टाइप

कोटा नीति, कई तरह की नीतियों के साथ काम करती है: डिफ़ॉल्ट, calendar, flexi, और rollingwindow. हर टाइप के लिए, कोटा काउंटर के शुरू होने और रीसेट होने का समय तय होता है. इसकी जानकारी इस टेबल में दी गई है:

type="calendar" के लिए, आपको <StartTime> की वैल्यू देनी होगी.

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

उदाहरण के लिए, आपने दो घंटे की एक विंडो तय की है, जिसमें 1,000 अनुरोध किए जा सकते हैं. नया अनुरोध शाम 4:45 बजे आता है. नीति, पिछले दो घंटे की विंडो के लिए कोटे की गिनती करती है. इसका मतलब है कि दोपहर 2:45 बजे से किए गए अनुरोधों की संख्या. अगर दो घंटे की उस विंडो में कोटे की सीमा पार नहीं की गई है, तो अनुरोध को अनुमति दी जाती है.

एक मिनट बाद, शाम 4:46 बजे एक और अनुरोध आता है. अब नीति, कोटा काउंट की गिनती दोपहर 2:46 बजे से करती है. इससे यह तय किया जाता है कि सीमा पार हो गई है या नहीं.

rollingwindow टाइप के लिए, काउंटर कभी रीसेट नहीं होता. हालांकि, हर अनुरोध पर इसकी फिर से गिनती की जाती है.

कोटा काउंटर के बारे में जानकारी

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

उदाहरण के लिए, आपने MyQuotaPolicy नाम की एक कोटा नीति बनाई है. इसमें अनुरोधों की सीमा पांच है. आपने इसे एपीआई प्रॉक्सी में कई फ़्लो (फ़्लो A, B, और C) पर लागू किया है. इसका इस्तेमाल कई फ़्लो में किया जाता है. हालांकि, यह एक ही काउंटर को बनाए रखता है. इस काउंटर को नीति के सभी इंस्टेंस अपडेट करते हैं:

• फ़्लो A को एक्ज़ीक्यूट किया जाता है -> MyQuotaPolicy को एक्ज़ीक्यूट किया जाता है और इसका काउंटर = 1
• फ़्लो B को एक्ज़ीक्यूट किया जाता है -> MyQuotaPolicy को एक्ज़ीक्यूट किया जाता है और इसका काउंटर = 2
• फ़्लो A को एक्ज़ीक्यूट किया जाता है -> MyQuotaPolicy को एक्ज़ीक्यूट किया जाता है और इसका काउंटर = 3
• फ़्लो C को एक्ज़ीक्यूट किया जाता है -> MyQuotaPolicy को एक्ज़ीक्यूट किया जाता है और इसका काउंटर = 4
• फ़्लो A को एक्ज़ीक्यूट किया जाता है -> MyQuotaPolicy को एक्ज़ीक्यूट किया जाता है और इसका काउंटर = 5

इन तीनों फ़्लो में से किसी के लिए भी अगला अनुरोध अस्वीकार कर दिया जाता है, क्योंकि कोटा काउंटर अपनी सीमा तक पहुंच गया है.

एपीआई प्रॉक्सी फ़्लो में एक से ज़्यादा जगहों पर एक ही कोटा नीति का इस्तेमाल करना, The Book of Apigee Edge Antipatterns में बताई गई एक एंटी-पैटर्न है. इससे अनजाने में कोटा, आपकी उम्मीद से ज़्यादा तेज़ी से खत्म हो सकता है.

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

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

समय का नोटेशन

सभी कोटा के समय, कोऑर्डिनेटेड यूनिवर्सल टाइम (यूटीसी) टाइम ज़ोन के हिसाब से सेट किए जाते हैं.

कोटा टाइम नोटेशन, तारीख के लिए अंतरराष्ट्रीय स्टैंडर्ड नोटेशन के मुताबिक होता है. यह नोटेशन, अंतरराष्ट्रीय स्टैंडर्ड आईएसओ 8601 में तय किया गया है.

तारीखों को साल, महीने, और दिन के हिसाब से तय किया जाता है. इनका फ़ॉर्मैट यह होता है: YYYY-MM-DD. उदाहरण के लिए, 2015-02-04 का मतलब 4 फ़रवरी, 2015 है.

दिन के समय को घंटे, मिनट, और सेकंड के हिसाब से इस फ़ॉर्मैट में दिखाया जाता है: hours:minutes:seconds. उदाहरण के लिए, 23:59:59 आधी रात से एक सेकंड पहले का समय दिखाता है.

ध्यान दें कि एक तारीख से जुड़ी दो आधी रातों के बीच अंतर करने के लिए, दो नोटेशन 00:00:00 और 24:00:00 उपलब्ध हैं. इसलिए, 2015-02-04 24:00:00 और 2015-02-05 00:00:00 की तारीख और समय एक ही है. आम तौर पर, बाद वाले नोटेशन को प्राथमिकता दी जाती है.

एपीआई प्रॉडक्ट के कॉन्फ़िगरेशन से कोटा सेटिंग पाना

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

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

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

कोटे की सीमाओं के साथ एपीआई प्रॉडक्ट कॉन्फ़िगर करने के बारे में जानकारी के लिए, एपीआई प्रॉडक्ट बनाना लेख पढ़ें.

एलिमेंट का रेफ़रंस

इस नीति के लिए, यहां दिए गए एलिमेंट और एट्रिब्यूट कॉन्फ़िगर किए जा सकते हैं. ध्यान दें कि कुछ एलिमेंट के कॉम्बिनेशन, एक-दूसरे से अलग होते हैं या उनकी ज़रूरत नहीं होती. इस्तेमाल के खास उदाहरण देखें. अनुरोध में ऐप्लिकेशन की एपीआई कुंजी की जांच करने के लिए, "VerifyAPIKey" नाम की Verify API Key नीति का इस्तेमाल करने पर, नीचे दिए गए verifyapikey.VerifyAPIKey.apiproduct.* वैरिएबल डिफ़ॉल्ट रूप से उपलब्ध होते हैं. वैरिएबल की वैल्यू, उस एपीआई प्रॉडक्ट की कोटा सेटिंग से मिलती हैं जिससे कुंजी जुड़ी है. इसके बारे में एपीआई प्रॉडक्ट के कॉन्फ़िगरेशन से कोटा सेटिंग पाना लेख में बताया गया है.

<Quota async="false" continueOnError="false" enabled="true" name="Quota-3" type="calendar">
   <DisplayName>Quota 3</DisplayName>
   <Allow count="2000" countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.limit"/>
   <Allow>
      <Class ref="request.queryparam.time_variable">
        <Allow class="peak_time" count="5000"/>
        <Allow class="off_peak_time" count="1000"/>
      </Class>
   </Allow>
   <Interval ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.interval">1</Interval>
   <TimeUnit ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.timeunit">month</TimeUnit>
   <StartTime>2017-7-16 12:00:00</StartTime>
   <Distributed>false</Distributed>
   <Synchronous>false</Synchronous>
   <AsynchronousConfiguration>
      <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
      <SyncMessageCount>5</SyncMessageCount>
   </AsynchronousConfiguration>
   <Identifier/>
   <MessageWeight/>
</Quota>

<Quota> एट्रिब्यूट

<Quota async="false" continueOnError="false" enabled="true" name="Quota-3" type="calendar">

यहां दिए गए एट्रिब्यूट, इस नीति के लिए खास तौर पर बनाए गए हैं.

यहां दी गई टेबल में, ऐसे एट्रिब्यूट के बारे में बताया गया है जो नीति के सभी पैरंट एलिमेंट में एक जैसे होते हैं:

&lt;DisplayName&gt; एलिमेंट

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

<DisplayName>Policy Display Name</DisplayName>

<Allow> एलिमेंट

कोटे के लिए गिनती की सीमा तय करता है. अगर नीति के लिए काउंटर इस सीमा तक पहुंच जाता है, तो काउंटर रीसेट होने तक बाद के कॉल अस्वीकार कर दिए जाते हैं.

<Allow> एलिमेंट को सेट करने के तीन तरीके यहां दिए गए हैं:

<Allow count="2000"/>

<Allow countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.limit"/>

<Allow count="2000" countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.limit"/>

अगर आपने count और countRef, दोनों एट्रिब्यूट की वैल्यू सबमिट की हैं, तो countRef एट्रिब्यूट को प्राथमिकता दी जाएगी. अगर रनटाइम के दौरान countRef हल नहीं होता है, तो count की वैल्यू का इस्तेमाल किया जाता है.

विशेषताएं

<Allow>/<Class> एलिमेंट

<Class> एलिमेंट की मदद से, फ़्लो वैरिएबल की वैल्यू के आधार पर <Allow> एलिमेंट की वैल्यू को शर्त के साथ सेट किया जा सकता है. नीति, <Class> के हर अलग <Allow> चाइल्ड टैग के लिए, अलग काउंटर बनाए रखती है.

<Class> एलिमेंट का इस्तेमाल करने के लिए, <Class> टैग के ref एट्रिब्यूट का इस्तेमाल करके, फ़्लो वैरिएबल तय करें. इसके बाद, Edge फ़्लो वैरिएबल की वैल्यू का इस्तेमाल करके, <Allow> चाइल्ड टैग में से किसी एक को चुनता है. इससे यह तय किया जाता है कि नीति के तहत कितने अनुरोध किए जा सकते हैं. Edge, फ़्लो वैरिएबल की वैल्यू को class टैग के class एट्रिब्यूट से मैच करता है. इसे यहां दिखाया गया है:<Allow>

<Allow>
  <Class ref="request.queryparam.time_variable">
    <Allow class="peak_time" count="5000"/>
    <Allow class="off_peak_time" count="1000"/>
  </Class>
</Allow>

इस उदाहरण में, मौजूदा कोटा काउंटर का पता लगाने के लिए, time_variable क्वेरी पैरामीटर की वैल्यू का इस्तेमाल किया जाता है. यह पैरामीटर, हर अनुरोध के साथ पास किया जाता है. उस वैरिएबल की वैल्यू peak_time या off_peak_time हो सकती है. अगर क्वेरी पैरामीटर में अमान्य वैल्यू शामिल है, तो नीति, कोटे के उल्लंघन की गड़बड़ी का मैसेज दिखाती है.

विशेषताएं

<Allow>/<Class>/<Allow> element

<Allow> एलिमेंट, <Class> एलिमेंट से तय किए गए कोटा काउंटर की सीमा तय करता है. <Allow> के हर अलग <Allow> चाइल्ड टैग के लिए, नीति अलग काउंटर बनाए रखती है.<Class>

उदाहरण के लिए:

<Allow>
  <Class ref="request.queryparam.time_variable">
    <Allow class="peak_time" count="5000"/>
    <Allow class="off_peak_time" count="1000"/>
  </Class>
</Allow>

इस उदाहरण में, कोटा नीति peak_time और off_peak_time नाम के दो कोटा काउंटर बनाए रखती है.

विशेषताएं

<Interval> एलिमेंट

इसका इस्तेमाल पूर्णांक (उदाहरण के लिए, 1, 2, 5, 60 वगैरह) तय करने के लिए किया जाता है. यह पूर्णांक, TimeUnit के साथ जोड़ा जाता है. TimeUnit से मिनट, घंटा, दिन, हफ़्ता या महीना तय किया जाता है. इससे यह तय होता है कि Edge किस समयावधि के दौरान, कोटे के इस्तेमाल का हिसाब लगाएगा.

उदाहरण के लिए, hour के TimeUnit के साथ 24 का Interval का मतलब है कि कोटा का हिसाब 24 घंटे के दौरान लगाया जाएगा.

<Interval ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.interval">1</Interval>

विशेषताएं

<TimeUnit> एलिमेंट

इस पैरामीटर का इस्तेमाल, कोटा पर लागू होने वाली समय की इकाई के बारे में बताने के लिए किया जाता है.

उदाहरण के लिए, hour के TimeUnit के साथ 24 का Interval का मतलब है कि कोटा का हिसाब 24 घंटे के दौरान लगाया जाएगा.

<TimeUnit ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.timeunit">month</TimeUnit>

विशेषताएं

<StartTime> एलिमेंट

type को calendar, पर सेट करने से, उस तारीख और समय के बारे में पता चलता है जब कोटा काउंटर गिनती शुरू करेगा. भले ही, किसी ऐप्लिकेशन से कोई अनुरोध मिला हो या नहीं.

उदाहरण के लिए:

<StartTime>2017-7-16 12:00:00</StartTime>

<Distributed> एलिमेंट

Edge के इंस्टॉलेशन में, अनुरोधों को प्रोसेस करने के लिए एक या उससे ज़्यादा मैसेज प्रोसेसर का इस्तेमाल किया जा सकता है. इस एलिमेंट को true पर सेट करें, ताकि यह तय किया जा सके कि नीति को एक सेंट्रल काउंटर बनाए रखना चाहिए और उसे सभी मैसेज प्रोसेसर के साथ लगातार सिंक करना चाहिए. मैसेज प्रोसेसर, उपलब्धता क्षेत्र और/या क्षेत्रों में उपलब्ध हो सकते हैं.

अगर false की डिफ़ॉल्ट वैल्यू का इस्तेमाल किया जाता है, तो हो सकता है कि आपका कोटा पूरा हो जाए. इसकी वजह यह है कि हर मैसेज प्रोसेसर के लिए, मैसेज की संख्या शेयर नहीं की जाती:

<Distributed>true</Distributed>

यह पक्का करने के लिए कि काउंटर सिंक किए गए हैं और हर अनुरोध पर अपडेट किए गए हैं, <Distributed> और <Synchronous> को सही पर सेट करें:

<Distributed>true</Distributed>
<Synchronous>true</Synchronous>

<Synchronous> एलिमेंट

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

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

डिफ़ॉल्ट रूप से, एसिंक्रोनस अपडेट का इंटरवल 10 सेकंड होता है. इस एसिंक्रोनस व्यवहार को कॉन्फ़िगर करने के लिए, AsynchronousConfiguration एलिमेंट का इस्तेमाल करें.

<Synchronous>false</Synchronous>

<AsynchronousConfiguration> एलिमेंट

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

SyncIntervalInSeconds या SyncMessageCount चाइल्ड एलिमेंट का इस्तेमाल करके, किसी समयावधि या मैसेज की संख्या के बाद सिंक्रनाइज़ किया जा सकता है. ये दोनों एक-दूसरे से अलग होते हैं. उदाहरण के लिए,

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
</AsynchronousConfiguration>

या

<AsynchronousConfiguration>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>

<AsynchronousConfiguration>/<SyncIntervalInSeconds> element

इस विकल्प का इस्तेमाल करके, डिफ़ॉल्ट सेटिंग को बदला जा सकता है. डिफ़ॉल्ट सेटिंग में, एसिंक्रोनस अपडेट 10 सेकंड के अंतराल के बाद किए जाते हैं.

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
</AsynchronousConfiguration>

सिंक करने का इंटरवल 10 सेकंड से ज़्यादा या इसके बराबर होना चाहिए. इसके बारे में सीमाएं विषय में बताया गया है.

<AsynchronousConfiguration>/<SyncMessageCount> एलिमेंट

इस विकल्प से, कोटा अपडेट के बीच सभी Apigee मैसेज प्रोसेसर के लिए अनुरोधों की संख्या तय की जाती है.

<AsynchronousConfiguration>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>

इस उदाहरण में बताया गया है कि Apigee Edge के हर मैसेज प्रोसेसर पर, हर पांच अनुरोधों के बाद कोटा काउंट अपडेट किया जाता है.

<Identifier> एलिमेंट

<Identifier> एलिमेंट का इस्तेमाल करके, नीति को कॉन्फ़िगर करें. इससे फ़्लो वैरिएबल के आधार पर यूनीक काउंटर बनाए जा सकते हैं.

इस एलिमेंट का इस्तेमाल न करने पर, नीति एक काउंटर का इस्तेमाल करती है. यह काउंटर, कोटे पर लागू होता है.

इस एलिमेंट के बारे में, Apigee Community की इस पोस्ट में भी बताया गया है: Quota identifier across different policies.

<Identifier ref="verifyapikey.verify-api-key.client_id"/>

विशेषताएं

<MessageWeight> एलिमेंट

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

उदाहरण के लिए, आपको POST मैसेज को GET मैसेज की तुलना में दो गुना "भारी" या महंगा मानना है. इसलिए, POST के लिए MessageWeight को 2 पर और GET के लिए 1 पर सेट करें. MessageWeight को 0 पर भी सेट किया जा सकता है, ताकि अनुरोध से काउंटर पर कोई असर न पड़े. इस उदाहरण में, अगर कोटा हर मिनट 10 मैसेज है और POST अनुरोधों के लिए MessageWeight 2 है, तो कोटा किसी भी 10 मिनट के अंतराल में 5 POST अनुरोधों की अनुमति देगा. काउंटर रीसेट होने से पहले, POST या GET के किसी भी अन्य अनुरोध को अस्वीकार कर दिया जाता है.

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

<MessageWeight ref="message_weight"/>

फ़्लो वैरिएबल

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

गड़बड़ी की जानकारी

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

रनटाइम की गड़बड़ियां

नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.

डिप्लॉयमेंट से जुड़ी गड़बड़ियां

गड़बड़ी के वैरिएबल

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

गड़बड़ी के रिस्पॉन्स का उदाहरण

{  
   "fault":{  
      "detail":{  
         "errorcode":"policies.ratelimit.QuotaViolation"
      },
      "faultstring":"Rate limit quota violation. Quota limit  exceeded. Identifier : _default"
   }
}

गड़बड़ी के नियम का उदाहरण

<FaultRules>
    <FaultRule name="Quota Errors">
        <Step>
            <Name>JavaScript-1</Name>
            <Condition>(fault.name Matches "QuotaViolation") </Condition>
        </Step>
        <Condition>ratelimit.Quota-1.failed=true</Condition>
    </FaultRule>
</FaultRules>

स्कीमा

मिलते-जुलते विषय

ResetQuota नीति

SpikeArrest नीति

कोटा, स्पाइक अरेस्ट, और एक साथ कई अनुरोध करने पर रोक लगाने से जुड़ी नीतियों की तुलना करना