कोटा नीति

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 के बारे में ज़्यादा जानकारी के लिए, 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> एलिमेंट इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, ऊपर दिए गए उदाहरण देखें.

समय के लिए इस्तेमाल होने वाले सिंबल

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

कोटा के समय के लिए, तारीख के इंटरनैशनल स्टैंडर्ड नोटेशन का इस्तेमाल किया जाता है. यह नोटेशन, इंटरनैशनल स्टैंडर्ड ISO 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" नाम की एपीआई कुंजी की पुष्टि करने की नीति का इस्तेमाल करने पर, यहां दिए गए 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> चाइल्ड टैग में से किसी एक को चुनने के लिए, फ़्लो वैरिएबल की वैल्यू का इस्तेमाल करता है. इससे, नीति के लिए अनुमति वाली संख्या का पता चलता है. एज, फ़्लो वैरिएबल की वैल्यू को <Allow> टैग के class एट्रिब्यूट से मैच करता है, जैसा कि यहां दिखाया गया है:

<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> एलिमेंट

<Allow> एलिमेंट, <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>

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

विशेषताएं

<Interval> एलिमेंट

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

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

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

विशेषताएं

<TimeUnit> एलिमेंट

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

उदाहरण के लिए, 24 के Interval और hour के TimeUnit का मतलब है कि कोटा का हिसाब 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> एलिमेंट

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

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

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

<AsynchronousConfiguration>/<SyncMessageCount> element

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

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

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

<Identifier> एलिमेंट

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

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

इस एलिमेंट के बारे में, Apigee कम्यूनिटी की इस पोस्ट में भी बताया गया है: http://community.apigee.com/questions/2807/how-does-the-edge-quota-policy-work-when-no-identi.html.

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

विशेषताएं

<MessageWeight> एलिमेंट

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

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

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

<MessageWeight ref="message_weight"/>

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

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

गड़बड़ी का रेफ़रंस

This section describes the fault codes and error messages that are returned and fault variables that are set by Edge when this policy triggers an error. This information is important to know if you are developing fault rules to handle faults. To learn more, see What you need to know about policy errors and Handling faults.

Runtime errors

These errors can occur when the policy executes.

Deployment errors

Fault variables

These variables are set when this policy triggers an error. For more information, see What you need to know about policy errors.

Example error response

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

Example fault rule

<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 की नीति

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