นโยบายโควต้า

คุณกำลังดูเอกสารประกอบของ Apigee Edge
ไปที่เอกสารประกอบของ Apigee X info

อะไร

ใช้นโยบายโควต้าเพื่อกำหนดค่าจำนวนข้อความคำขอที่พร็อกซี API อนุญาตในช่วงเวลาหนึ่งๆ เช่น นาที ชั่วโมง วัน สัปดาห์ หรือเดือน คุณสามารถตั้งโควต้าให้เหมือนกันทั้งหมดสำหรับแอปทั้งหมดที่เข้าถึงพร็อกซี API หรือตั้งโควต้าตามเกณฑ์ต่อไปนี้ได้

  • ผลิตภัณฑ์ที่มีพร็อกซี API
  • แอปที่ขอใช้ API
  • นักพัฒนาแอป
  • เกณฑ์อื่นๆ อีกมากมาย

อย่าใช้โควต้าเพื่อป้องกันการเพิ่มขึ้นของการเข้าชมโดยรวม โดยใช้นโยบาย Spike Arrest ดูนโยบายการจับกุม

วิดีโอ

วิดีโอเหล่านี้จะแนะนำการจัดการโควต้าตามนโยบายโควต้า

บทนำ (Microsoft Edge ใหม่)

ข้อมูลเบื้องต้น (Edge แบบคลาสสิก)

โควต้าแบบไดนามิก

แบบกระจายและแบบซิงโครนัส

น้ำหนักของข้อความ

ปฏิทิน

ช่วงเวลาต่อเนื่อง

Flexi

โควต้าแบบมีเงื่อนไข

ตัวแปรโฟลว์

การจัดการข้อผิดพลาด

ตัวอย่าง

ตัวอย่างโค้ดนโยบายเหล่านี้แสดงวิธีเริ่มและสิ้นสุดระยะเวลาโควต้าโดยทำดังนี้

โควต้าแบบไดนามิกเพิ่มเติม

<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>

โควต้าแบบไดนามิกช่วยให้คุณกำหนดค่านโยบายโควต้าเดียวที่บังคับใช้การตั้งค่าโควต้าที่แตกต่างกันได้ โดยอิงตามข้อมูลที่ส่งไปยังนโยบายโควต้า อีกคำหนึ่งสำหรับการตั้งค่าโควต้าใน บริบทนี้คือ "แพ็กเกจบริการ" โควต้าแบบไดนามิกจะตรวจสอบ "แพ็กเกจบริการ" ของแอป แล้ว บังคับใช้การตั้งค่าเหล่านั้น

หมายเหตุ: หากคุณระบุทั้งค่าและการอ้างอิงสำหรับองค์ประกอบ การอ้างอิงจะมีความสำคัญเหนือกว่า หากการอ้างอิงไม่ได้รับการแก้ไขในรันไทม์ ระบบจะใช้ค่า

เช่น เมื่อสร้างผลิตภัณฑ์ API คุณสามารถเลือกตั้งค่าโควต้าที่อนุญาต ขีดจำกัด หน่วยเวลา และช่วงเวลาได้ อย่างไรก็ตาม การตั้งค่าเหล่านี้ในผลิตภัณฑ์ API จะไม่บังคับให้ใช้ในพร็อกซี API นอกจากนี้ คุณยังต้องเพิ่มนโยบายโควต้าลงในพร็อกซี API ที่ อ่านค่าเหล่านี้ด้วย ดูข้อมูลเพิ่มเติมได้ที่สร้างผลิตภัณฑ์ API

ในตัวอย่างด้านบน พร็อกซี API ที่มีนโยบายโควต้าจะใช้นโยบาย VerifyAPIKey ชื่อ verify-api-key เพื่อตรวจสอบคีย์ API ที่ส่งในคำขอ จากนั้นนโยบายโควต้าจะเข้าถึงตัวแปรโฟลว์จากนโยบาย VerifyAPIKey เพื่ออ่านโควต้า ที่ตั้งค่าไว้ในผลิตภัณฑ์ API ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวแปรโฟลว์ VerifyAPIKey ได้ที่นโยบายตรวจสอบคีย์ API

อีกทางเลือกหนึ่งคือการตั้งค่าแอตทริบิวต์ที่กําหนดเองในนักพัฒนาแอปหรือแอปแต่ละราย แล้วอ่าน ค่าเหล่านั้นในนโยบายโควต้า เช่น คุณต้องการตั้งค่าโควต้าที่แตกต่างกันต่อ นักพัฒนาแอป ในกรณีนี้ คุณตั้งค่าแอตทริบิวต์ที่กำหนดเองในนักพัฒนาแอปซึ่งมีขีดจำกัด หน่วยเวลา และช่วงเวลา จากนั้นอ้างอิงค่าเหล่านี้ในนโยบายโควต้าดังที่แสดง ด้านล่าง

<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>

ตัวอย่างนี้ยังใช้ตัวแปรโฟลว์ VerifyAPIKey เพื่ออ้างอิงแอตทริบิวต์ที่กำหนดเอง ซึ่งตั้งค่าไว้ในนักพัฒนาแอปด้วย

คุณสามารถใช้ตัวแปรใดก็ได้เพื่อตั้งค่าพารามิเตอร์ของนโยบายโควต้า ตัวแปรเหล่านั้นอาจมาจากแหล่งที่มาต่อไปนี้

  • ตัวแปรโฟลว์
  • พร็อพเพอร์ตี้ในผลิตภัณฑ์ API, แอป หรือนักพัฒนาแอป
  • แมปค่าคีย์ (KVM)
  • ส่วนหัว พารามิเตอร์การค้นหา พารามิเตอร์แบบฟอร์ม ฯลฯ

สำหรับพร็อกซี API แต่ละรายการ คุณสามารถเพิ่มนโยบายโควต้าที่อ้างอิงตัวแปรเดียวกันกับ นโยบายโควต้าอื่นๆ ทั้งหมดในพร็อกซีอื่นๆ ทั้งหมด หรือนโยบายโควต้าจะอ้างอิง ตัวแปรที่ไม่ซ้ำกันสำหรับนโยบายและพร็อกซีนั้นก็ได้

เวลาเริ่มต้น

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

สำหรับโควต้าที่มี type ตั้งค่าเป็น calendar คุณต้องกำหนดค่า <StartTime> ที่ชัดเจน ค่าเวลาคือเวลา GMT ไม่ใช่เวลาท้องถิ่น หากคุณไม่ได้ระบุค่า <StartTime> สำหรับนโยบายประเภท calendar Edge จะแสดงข้อผิดพลาด

ระบบจะรีเฟรชตัวนับโควต้าของแต่ละแอปตามค่า <StartTime> <Interval> และ <TimeUnit> สำหรับตัวอย่างนี้ โควต้าจะเริ่มนับที่เวลา 10:30 น. GMT ในวันที่ 18 กุมภาพันธ์ 2017 และจะรีเฟรชทุกๆ 5 ชั่วโมง ดังนั้น การรีเฟรชครั้งถัดไปจะเกิดขึ้นในเวลา 15:30 น. GMT ของวันที่ 18 กุมภาพันธ์ 2017

ตัวนับการเข้าถึง

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

พร็อกซี API มีสิทธิ์เข้าถึงตัวแปรโฟลว์ที่กำหนดโดยนโยบายโควต้า คุณสามารถเข้าถึงตัวแปรโฟลว์เหล่านี้ในพร็อกซี API เพื่อทำการประมวลผลแบบมีเงื่อนไข ตรวจสอบนโยบายเมื่อใกล้ถึงขีดจำกัดโควต้า แสดงตัวนับโควต้าปัจจุบันต่อแอป หรือด้วยเหตุผลอื่นๆ

เนื่องจากการเข้าถึงตัวแปรโฟลว์สำหรับนโยบายนั้นอิงตามแอตทริบิวต์ name ของนโยบาย สำหรับนโยบายด้านบนที่ชื่อ QuotaPolicy คุณจะเข้าถึงตัวแปรโฟลว์ในรูปแบบต่อไปนี้

  • ratelimit.QuotaPolicy.allowed.count: จำนวนที่อนุญาต
  • ratelimit.QuotaPolicy.used.count: ค่าตัวนับปัจจุบัน
  • ratelimit.QuotaPolicy.expiry.time: เวลา UTC เมื่อตัวนับรีเซ็ต

คุณเข้าถึงตัวแปรโฟลว์อื่นๆ ได้อีกมากมายตามที่อธิบายไว้ด้านล่าง

เช่น คุณสามารถใช้นโยบาย AssignMessage ต่อไปนี้เพื่อแสดงค่าของตัวแปรโฟลว์ 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>

ใช้โค้ดตัวอย่างนี้เพื่อบังคับใช้โควต้าการเรียก 10,000 ครั้งต่อชั่วโมง นโยบายนี้จะรีเซ็ตตัวนับโควต้าที่ต้นชั่วโมง หากตัวนับถึงโควต้าการโทร 10,000 ครั้ง ก่อนสิ้นชั่วโมง ระบบจะปฏิเสธการโทรที่เกิน 10,000 ครั้ง

เช่น หากตัวนับเริ่มต้นที่ 2017-07-08 07:00:00 ตัวนับจะรีเซ็ตเป็น 0 ที่ 2017-07-08 08:00:00 (1 ชั่วโมงนับจากเวลาเริ่มต้น) หากได้รับข้อความแรกที่ 2017-07-08 07:35:28 และจำนวนข้อความถึง 10,000 ก่อน 2017-07-08 08:00:00 ระบบจะปฏิเสธการโทรที่เกินจำนวนดังกล่าวจนกว่า จำนวนจะรีเซ็ตเมื่อถึงต้นชั่วโมง

เวลาที่รีเซ็ตตัวนับจะอิงตามชุดค่าผสมของ <Interval> และ <TimeUnit> เช่น หากคุณตั้งค่า <Interval> เป็น 12 สำหรับ <TimeUnit> ของชั่วโมง ตัวนับจะรีเซ็ตทุกๆ 12 ชั่วโมง คุณตั้งค่า <TimeUnit> เป็นนาที ชั่วโมง วัน สัปดาห์ หรือเดือนได้

คุณอ้างอิงนโยบายนี้ได้หลายที่ในพร็อกซี API เช่น คุณอาจวางไว้ใน Proxy PreFlow เพื่อให้ดำเนินการกับทุกคำขอ หรือจะวางไว้ใน หลายโฟลว์ในพร็อกซี API ก็ได้ หากคุณใช้นโยบายนี้ในหลายที่ในพร็อกซี ระบบจะใช้ตัวนับเดียวที่อัปเดตโดยอินสแตนซ์ทั้งหมดของนโยบาย

หรือจะกำหนดนโยบายโควต้าหลายรายการในพร็อกซี API ก็ได้ นโยบายโควต้าแต่ละรายการ จะรักษามิเตอร์ของตัวเองตามname แอตทริบิวต์ของนโยบาย

ตั้งค่าตัวระบุ

<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>

โดยค่าเริ่มต้น นโยบายโควต้าจะกำหนดตัวนับเดียวสำหรับพร็อกซี API โดยไม่คำนึงถึงต้นทางของคำขอ หรือจะใช้แอตทริบิวต์ <Identifier> กับนโยบายโควต้าเพื่อรักษามูลค่าของเคาน์เตอร์แยกต่างหากตามค่าของแอตทริบิวต์ <Identifier> ก็ได้

ตัวอย่างเช่น ใช้แท็ก <Identifier> เพื่อกำหนดตัวนับแยกต่างหากสำหรับ รหัสไคลเอ็นต์ทุกรายการ เมื่อมีการส่งคำขอไปยังพร็อกซี แอปไคลเอ็นต์จะส่งต่อส่วนหัวที่มี clientID ดังที่แสดงในตัวอย่างด้านบน

คุณระบุตัวแปรโฟลว์ใดก็ได้ให้กับแอตทริบิวต์ <Identifier> เช่น คุณอาจระบุว่าพารามิเตอร์การค้นหาชื่อ id มีตัวระบุที่ไม่ซ้ำกัน ดังนี้

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

หากใช้นโยบาย VerifyAPIKey เพื่อตรวจสอบคีย์ API หรือนโยบาย OAuthV2 ที่มีโทเค็น OAuth คุณจะใช้ข้อมูลในคีย์หรือโทเค็น API เพื่อกำหนดตัวนับแต่ละรายการ สำหรับนโยบายโควต้าเดียวกันได้ ตัวอย่างเช่น แท็กต่อไปนี้ <Identifier> ใช้ตัวแปรโฟลว์ client_id ของนโยบาย VerifyAPIKey ที่ชื่อ verify-api-key

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

ตอนนี้ค่า client_id ที่ไม่ซ้ำกันแต่ละค่าจะกำหนดตัวนับของตัวเองในนโยบายโควต้า

ระดับ

<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>

คุณตั้งค่าขีดจำกัดโควต้าแบบไดนามิกได้โดยใช้การนับโควต้าตามคลาส ในตัวอย่างนี้ โควต้าจะกำหนดโดยค่าของส่วนหัว developer_segment ที่ส่งพร้อมกับคำขอแต่ละรายการ ตัวแปรดังกล่าวอาจมีค่าเป็น platinum หรือ silver หากส่วนหัวมีค่าที่ไม่ถูกต้อง นโยบายจะแสดงข้อผิดพลาดการละเมิดโควต้า

เกี่ยวกับนโยบายโควต้า

โควต้าคือการจัดสรรข้อความคำขอที่พร็อกซี API สามารถจัดการได้ในช่วงระยะเวลาหนึ่ง เช่น นาที ชั่วโมง วัน สัปดาห์ หรือเดือน นโยบายจะดูแลตัวนับที่รวบรวมจำนวนคำขอที่พร็อกซี API ได้รับ ความสามารถนี้ช่วยให้ผู้ให้บริการ API บังคับใช้ขีดจำกัดเกี่ยวกับ จำนวนการเรียก API ที่แอปดำเนินการในช่วงระยะเวลาหนึ่งได้ การใช้นโยบายโควต้าช่วยให้คุณจำกัดแอปได้ เช่น ให้ส่งคำขอได้ 1 รายการต่อนาที หรือ 10,000 รายการต่อเดือน

เช่น หากกำหนดโควต้าเป็น 10,000 ข้อความต่อเดือน การจำกัดอัตราจะเริ่มขึ้นหลังจากข้อความที่ 10,000 ไม่ว่าระบบจะนับข้อความ 10,000 รายการในวันแรกหรือวันสุดท้ายของระยะเวลาดังกล่าว ก็จะไม่อนุญาตให้ส่งคำขอเพิ่มเติมจนกว่าตัวนับโควต้าจะรีเซ็ตโดยอัตโนมัติเมื่อสิ้นสุดช่วงเวลาที่ระบุ หรือจนกว่าจะรีเซ็ตโควต้าอย่างชัดเจนโดยใช้นโยบายรีเซ็ตโควต้า

การเปลี่ยนแปลงโควต้าที่เรียกว่า SpikeArrest จะป้องกันการรับส่งข้อมูลที่เพิ่มขึ้นอย่างฉับพลัน (หรือการรับส่งข้อมูลที่เพิ่มขึ้นอย่างรวดเร็ว) ซึ่งอาจเกิดจากการใช้งานที่เพิ่มขึ้นอย่างฉับพลัน ไคลเอ็นต์ที่มีข้อบกพร่อง หรือการโจมตีที่เป็นอันตราย ดูข้อมูลเพิ่มเติมเกี่ยวกับ SpikeArrest ได้ที่นโยบาย Spike Arrest

โควต้าจะมีผลกับพร็อกซี API แต่ละรายการ และจะไม่กระจายไปยังพร็อกซี API อื่นๆ เช่น หากคุณมีพร็อกซี API 3 รายการในผลิตภัณฑ์ API ระบบจะไม่แชร์โควต้าเดียวในทั้ง 3 รายการ แม้ว่าทั้ง 3 รายการจะใช้การกำหนดค่านโยบายโควต้าเดียวกันก็ตาม

ประเภทนโยบายโควต้า

นโยบายโควต้ารองรับนโยบายหลายประเภท ได้แก่ ค่าเริ่มต้น calendar flexi และ rollingwindow แต่ละประเภทจะกำหนดเวลาที่ตัวนับโควต้า เริ่มต้นและเวลาที่รีเซ็ต ดังที่แสดงในตารางต่อไปนี้

หน่วยเวลา รีเซ็ตค่าเริ่มต้น (หรือ Null) รีเซ็ตปฏิทิน การรีเซ็ตแบบยืดหยุ่น
นาที เริ่มนาทีถัดไป 1 นาทีหลังจาก <StartTime> 1 นาทีหลังจากคำขอแรก
ชั่วโมง ต้นชั่วโมงถัดไป 1 ชั่วโมงหลังจาก<StartTime> 1 ชั่วโมงหลังจากคำขอแรก
วัน เที่ยงคืน GMT ของวันปัจจุบัน 24 ชั่วโมงหลังจาก<StartTime> 24 ชั่วโมงหลังจากคำขอแรก
สัปดาห์ เที่ยงคืน GMT วันอาทิตย์ในตอนท้ายของสัปดาห์ 1 สัปดาห์หลังจาก<StartTime> 1 สัปดาห์หลังจากคำขอแรก
เดือน เวลา 00:00 น. GMT ของวันสุดท้ายของเดือน 1 เดือน (28 วัน) หลังจาก<StartTime> 1 เดือน (28 วัน) หลังจากคำขอแรก
แทนการใช้ second

สำหรับ type="calendar" คุณต้องระบุค่าของ <StartTime>

ตารางไม่ได้แสดงค่าสำหรับประเภท rollingwindow โควต้าแบบกรอบเวลาต่อเนื่อง จะทำงานโดยการกำหนดขนาดของ "กรอบเวลา" ของโควต้า เช่น กรอบเวลา 1 ชั่วโมงหรือ 1 วัน เมื่อมีคำขอใหม่เข้ามา นโยบายจะพิจารณาว่ามีการใช้โควต้าเกินใน "ช่วงเวลา" ที่ผ่านมาหรือไม่

เช่น คุณกำหนดช่วงเวลา 2 ชั่วโมงที่อนุญาตคำขอ 1, 000 รายการ คำขอใหม่ เข้ามาตอน 16:45 น.นโยบายจะคำนวณจำนวนโควต้าสำหรับช่วง 2 ชั่วโมงที่ผ่านมา ซึ่งหมายถึงจำนวนคำขอนับตั้งแต่เวลา 14:45 น. หากไม่ได้ใช้โควต้าเกินขีดจำกัดในกรอบเวลา 2 ชั่วโมงนั้น ระบบจะอนุญาตคำขอ

1 นาทีต่อมา เวลา 16:46 น. มีคำขอเข้ามาอีก ตอนนี้ นโยบายจะคำนวณจำนวนโควต้าตั้งแต่เวลา 14:46 น. เพื่อพิจารณาว่าเกินขีดจำกัดหรือไม่

สําหรับrollingwindowประเภท ตัวนับจะไม่รีเซ็ต แต่จะ คํานวณใหม่ในแต่ละคําขอ

ทำความเข้าใจตัวนับโควต้า

โดยค่าเริ่มต้น นโยบายโควต้าจะรักษาตัวนับเดียวไว้ ไม่ว่าคุณจะอ้างอิงตัวนับนั้นในพร็อกซี API กี่ครั้งก็ตาม ชื่อของตัวนับโควต้าจะอิงตามแอตทริบิวต์ name ของนโยบาย

เช่น คุณสร้างนโยบายโควต้าชื่อ MyQuotaPolicy โดยมีขีดจำกัดคำขอ 5 รายการ และวางไว้ในหลายโฟลว์ (โฟลว์ ก ข และ ค) ในพร็อกซี API แม้ว่าจะใช้ในหลายโฟลว์ แต่ก็ยังคงมีตัวนับเดียวที่อัปเดตโดยอินสแตนซ์ทั้งหมดของนโยบาย

  • ระบบจะเรียกใช้โฟลว์ A -> ระบบจะเรียกใช้ MyQuotaPolicy และตัวนับของนโยบาย = 1
  • ระบบจะดำเนินการโฟลว์ B -> ระบบจะดำเนินการ MyQuotaPolicy และตัวนับของโฟลว์ = 2
  • ระบบจะเรียกใช้โฟลว์ A -> ระบบจะเรียกใช้ MyQuotaPolicy และตัวนับของโฟลว์ = 3
  • ระบบจะเรียกใช้โฟลว์ C -> ระบบจะเรียกใช้ MyQuotaPolicy และตัวนับของนโยบาย = 4
  • ระบบจะเรียกใช้โฟลว์ A -> ระบบจะเรียกใช้ MyQuotaPolicy และตัวนับของนโยบาย = 5

คำขอถัดไปที่ส่งไปยังโฟลว์ใดก็ตามใน 3 โฟลว์จะถูกปฏิเสธเนื่องจากตัวนับโควต้าถึงขีดจำกัดแล้ว

การใช้นโยบายโควต้าเดียวกันในหลายที่ในโฟลว์พร็อกซี API ซึ่งอาจ ทําให้โควต้าหมดเร็วกว่าที่คาดไว้โดยไม่ตั้งใจ เป็นรูปแบบที่ไม่ควรใช้ตามที่อธิบายไว้ใน The Book of Apigee Edge Antipatterns

หรือจะกำหนดนโยบายโควต้าหลายรายการในพร็อกซี API และใช้นโยบายที่แตกต่างกันในแต่ละโฟลว์ก็ได้ นโยบายโควต้าแต่ละรายการจะดูแลรักษาตัวนับของตัวเองโดยอิงตามแอตทริบิวต์ name ของนโยบาย

หรือใช้องค์ประกอบ <Class> หรือ <Identifier> ใน นโยบายโควต้าเพื่อกำหนดตัวนับที่ไม่ซ้ำกันหลายรายการในนโยบายเดียว การใช้องค์ประกอบเหล่านี้ นโยบายเดียวสามารถดูแลตัวนับที่แตกต่างกันได้โดยอิงตามแอปที่ส่งคำขอ นักพัฒนาแอปที่ส่งคำขอ รหัสไคลเอ็นต์หรือตัวระบุไคลเอ็นต์อื่นๆ และอื่นๆ ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้องค์ประกอบ <Class> หรือ <Identifier> ได้ที่ตัวอย่างด้านบน

การกำหนดเวลา

เวลาโควต้าทั้งหมดจะตั้งค่าเป็นเขตเวลาเวลาสากลเชิงพิกัด (UTC)

การแสดงเวลาโควต้าเป็นไปตามการแสดงวันที่ตามมาตรฐานสากลที่กำหนดไว้ในมาตรฐานสากล ISO 8601

วันที่กำหนดเป็นปี เดือน และวัน ในรูปแบบ YYYY-MM-DD เช่น 2015-02-04 หมายถึงวันที่ 4 กุมภาพันธ์ 2015

เวลาของวันจะกำหนดเป็นชั่วโมง นาที และวินาทีในรูปแบบต่อไปนี้ hours:minutes:seconds เช่น 23:59:59 แสดงเวลา 1 วินาทีก่อนเที่ยงคืน

โปรดทราบว่ามีสัญกรณ์ 2 แบบคือ 00:00:00 และ 24:00:00 เพื่อ แยกความแตกต่างของเวลาเที่ยงคืน 2 ครั้งที่เชื่อมโยงกับวันที่เดียวกันได้ ดังนั้น 2015-02-04 24:00:00 จึงเป็นวันที่และเวลาเดียวกันกับ 2015-02-05 00:00:00 โดยปกติแล้วเราขอแนะนำให้ใช้รูปแบบหลัง

การรับการตั้งค่าโควต้าจากการกำหนดค่าผลิตภัณฑ์ API

คุณกำหนดขีดจำกัดโควต้าได้ในการกำหนดค่าผลิตภัณฑ์ API ขีดจำกัดดังกล่าวจะไม่บังคับใช้โควต้าโดยอัตโนมัติ แต่คุณสามารถอ้างอิงการตั้งค่าโควต้าผลิตภัณฑ์ในนโยบายโควต้าได้ ข้อดีบางประการของการตั้งโควต้าในผลิตภัณฑ์เพื่อให้เป็นข้อมูลอ้างอิงสำหรับนโยบายโควต้ามีดังนี้

  • นโยบายโควต้าสามารถใช้การตั้งค่าแบบเดียวกันในพร็อกซี API ทั้งหมดในผลิตภัณฑ์ API
  • คุณสามารถทำการเปลี่ยนแปลงการตั้งค่าโควต้าในผลิตภัณฑ์ API ในช่วงรันไทม์ได้ และนโยบายโควต้า ที่อ้างอิงค่าดังกล่าวจะมีค่าโควต้าที่อัปเดตโดยอัตโนมัติ

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้การตั้งค่าโควต้าจากผลิตภัณฑ์ API ได้ที่ตัวอย่าง "โควต้าแบบไดนามิก" ด้านบน

ดูข้อมูลเกี่ยวกับการกำหนดค่าผลิตภัณฑ์ API ที่มีขีดจำกัดโควต้าได้ที่สร้างผลิตภัณฑ์ API

การอ้างอิงองค์ประกอบ

ต่อไปนี้คือองค์ประกอบและแอตทริบิวต์ที่คุณกำหนดค่าในนโยบายนี้ได้ โปรดทราบว่าการผสมผสานองค์ประกอบบางอย่าง อาจใช้ร่วมกันไม่ได้หรือไม่จำเป็น ดูตัวอย่างการใช้งานที่เฉพาะเจาะจง ตัวแปร verifyapikey.VerifyAPIKey.apiproduct.* ด้านล่างจะพร้อมใช้งานโดยค่าเริ่มต้นเมื่อใช้นโยบายคีย์ API ที่ตรวจสอบแล้วที่ชื่อ "VerifyAPIKey" เพื่อตรวจสอบคีย์ API ของแอปในคำขอ ค่าตัวแปรมาจากค่าโควต้าในการตั้งค่าผลิตภัณฑ์ API ที่คีย์เชื่อมโยงด้วย ตามที่อธิบายไว้ในการรับการตั้งค่าโควต้าจากการกำหนดค่าผลิตภัณฑ์ API

<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">

แอตทริบิวต์ต่อไปนี้เป็นแอตทริบิวต์เฉพาะสำหรับนโยบายนี้

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ประเภท

ใช้เพื่อกำหนดเวลาและวิธีที่ตัวนับโควต้าจะตรวจสอบการใช้งานโควต้า ดูข้อมูลเพิ่มเติมได้ใน ประเภทนโยบายโควต้า

หากคุณละเว้นค่า type ตัวนับจะเริ่มที่จุดเริ่มต้น ของนาที/ชั่วโมง/วัน/สัปดาห์/เดือน

ค่าที่ใช้ได้มีดังนี้

  • calendar: กำหนดค่าโควต้าตามเวลาเริ่มต้นที่ชัดเจน ระบบจะรีเฟรชตัวนับโควต้า สำหรับแต่ละแอปตามค่า <StartTime>, <Interval> และ <TimeUnit> ที่คุณตั้งค่าไว้
  • rollingwindow: กำหนดค่าโควต้าที่ใช้ "ช่วงเวลาต่อเนื่อง" เพื่อ พิจารณาการใช้โควต้า เมื่อใช้ rollingwindow คุณจะกำหนดขนาดของกรอบเวลาได้ด้วยองค์ประกอบ <Interval> และ <TimeUnit> เช่น 1 วัน เมื่อได้รับคำขอ Edge จะดูเวลาที่แน่นอนของคำขอ (เช่น 17:01 น.) นับจำนวนคำขอที่เข้ามาในช่วงเวลานั้นจนถึง 17:01 น. ของวันก่อนหน้า (1 วัน) และพิจารณาว่ามีการใช้โควต้าเกินในช่วงเวลานั้นหรือไม่
  • flexi: กำหนดค่าโควต้าที่ทำให้ตัวนับเริ่มทำงานเมื่อได้รับข้อความคำขอแรกจากแอป และรีเซ็ตตามค่า <Interval>, และ <TimeUnit>
 ปฏิทิน ไม่บังคับ

ตารางต่อไปนี้อธิบายแอตทริบิวต์ทั่วไปในองค์ประกอบระดับบนสุดของนโยบายทั้งหมด

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
name

ชื่อภายในของนโยบาย ค่าของแอตทริบิวต์ name สามารถ ประกอบด้วยตัวอักษร ตัวเลข การเว้นวรรค ขีดกลางสั้น ขีดล่าง และจุด ค่านี้ไม่สามารถ เกิน 255 อักขระ

(ไม่บังคับ) ใช้องค์ประกอบ <DisplayName> เพื่อติดป้ายกำกับนโยบายใน เครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติต่างกัน

 ไม่มี ต้องระบุ
continueOnError

ตั้งค่าเป็น false เพื่อแสดงผลข้อผิดพลาดเมื่อนโยบายล้มเหลว เป็นเรื่องปกติ พฤติกรรมสำหรับนโยบายส่วนใหญ่

ตั้งค่าเป็น true เพื่อให้ดำเนินการตามขั้นตอนได้อย่างต่อเนื่องแม้จะมีนโยบายแล้วก็ตาม ล้มเหลว

 เท็จ ไม่บังคับ
enabled

ตั้งค่าเป็น true เพื่อบังคับใช้นโยบาย

ตั้งค่าเป็น false เพื่อปิดนโยบาย นโยบายจะไม่ บังคับใช้ แม้ว่าจะยังคงแนบกับขั้นตอน

 จริง ไม่บังคับ
async

แอตทริบิวต์นี้เลิกใช้งานแล้ว

 เท็จ เลิกใช้

&lt;DisplayName&gt; องค์ประกอบ

ใช้เพิ่มเติมจากแอตทริบิวต์ name เพื่อติดป้ายกำกับนโยบายใน เครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติต่างกัน

<DisplayName>Policy Display Name</DisplayName>
ค่าเริ่มต้น

ไม่มี

หากไม่ใส่องค์ประกอบนี้ ค่าของแอตทริบิวต์ name ของนโยบายจะเป็น

การมีบุคคลอยู่ ไม่บังคับ
ประเภท สตริง

องค์ประกอบ <Allow>

ระบุขีดจำกัดการนับสำหรับโควต้า หากตัวนับสำหรับนโยบายถึงค่าขีดจำกัดนี้ ระบบจะปฏิเสธการเรียกใช้ครั้งต่อๆ ไปจนกว่าตัวนับจะรีเซ็ต

ด้านล่างนี้คือ 3 วิธีในการตั้งค่าองค์ประกอบ <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

ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท: จำนวนเต็ม

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
จำนวน

ใช้เพื่อระบุจำนวนข้อความสำหรับโควต้า

เช่น ค่าแอตทริบิวต์ count เป็น 100, Interval เป็น 1 และ TimeUnit เป็นเดือนจะระบุโควต้าข้อความ 100 ข้อความต่อเดือน

 2000 ไม่บังคับ
countRef

ใช้เพื่อระบุตัวแปรโฟลว์ที่มีจำนวนข้อความสำหรับโควต้า countRef จะมีความสำคัญเหนือกว่าแอตทริบิวต์ count

 ไม่มี ไม่บังคับ

องค์ประกอบ <Allow>/<Class>

องค์ประกอบ <Class> ช่วยให้คุณกำหนดค่าขององค์ประกอบ <Allow> แบบมีเงื่อนไขได้ โดยอิงตามค่าของตัวแปรโฟลว์ สำหรับ แท็กย่อย <Allow> แต่ละแท็กของ <Class> นโยบายจะรักษาตัวนับที่แตกต่างกัน

หากต้องการใช้องค์ประกอบ <Class> ให้ระบุตัวแปรโฟลว์โดยใช้แอตทริบิวต์ ref กับแท็ก <Class> จากนั้น Edge จะใช้ค่าของตัวแปรโฟลว์เพื่อเลือกแท็กย่อย <Allow> รายการใดรายการหนึ่งเพื่อกำหนดจำนวนที่อนุญาตของนโยบาย Edge จะจับคู่ค่าของตัวแปรโฟลว์กับแอตทริบิวต์ 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 หากพารามิเตอร์การค้นหามีค่าที่ไม่ถูกต้อง นโยบายจะแสดงข้อผิดพลาดการละเมิดโควต้า

ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท: ไม่มี

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref

ใช้เพื่อระบุตัวแปรโฟลว์ที่มีคลาสโควต้าสำหรับโควต้า

 ไม่มี ต้องระบุ

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

องค์ประกอบ <Allow> ระบุขีดจำกัดสำหรับตัวนับโควต้าที่กำหนดโดยองค์ประกอบ <Class> สำหรับแท็กย่อย <Allow> ของ <Class> แต่ละรายการ นโยบายจะรักษาตัวนับที่แตกต่างกัน

เช่น

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

ในตัวอย่างนี้ นโยบายโควต้าจะดูแลตัวนับโควต้า 2 รายการชื่อ peak_time และ off_peak_time

ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท: ไม่มี

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
คลาส

กำหนดชื่อของตัวนับโควต้า

 ไม่มี ต้องระบุ
จำนวน ระบุขีดจำกัดโควต้าสำหรับตัวนับ ไม่มี ต้องระบุ

องค์ประกอบ <Interval>

ใช้เพื่อระบุจำนวนเต็ม (เช่น 1, 2, 5, 60 และอื่นๆ) ที่จะจับคู่กับ TimeUnit ที่คุณระบุ (นาที ชั่วโมง วัน สัปดาห์ หรือเดือน) เพื่อกำหนดระยะเวลา ที่ Edge จะคำนวณการใช้โควต้า

เช่น Interval 24 ที่มีTimeUnit hour หมายความว่าระบบจะคำนวณโควต้าในช่วง 24 ชั่วโมง

<Interval ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.interval">1</Interval>
ค่าเริ่มต้น: ไม่มี
การแสดงตน: ต้องระบุ
ประเภท: จำนวนเต็ม

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref

ใช้เพื่อระบุตัวแปรโฟลว์ที่มีช่วงเวลาสำหรับ โควต้า ref จะมีความสำคัญเหนือกว่าค่าช่วงเวลาที่ชัดเจน หากระบุทั้งการอ้างอิงและค่า การอ้างอิงจะมีความสำคัญเหนือกว่า หาก ref ไม่ได้รับการแก้ไขในรันไทม์ ระบบจะใช้ค่าดังกล่าว

 ไม่มี ไม่บังคับ

องค์ประกอบ <TimeUnit>

ใช้เพื่อระบุหน่วยเวลาที่ใช้กับโควต้า

เช่น Interval ของ 24 ที่มี TimeUnit ของ hour หมายความว่าระบบจะ คํานวณโควต้าในช่วง 24 ชั่วโมง

<TimeUnit ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.timeunit">month</TimeUnit>
ค่าเริ่มต้น: ไม่มี
การแสดงตน: ต้องระบุ
ประเภท:

สตริง เลือกจาก minute, hour, day, week หรือ month

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref ใช้เพื่อระบุตัวแปรโฟลว์ที่มีหน่วยเวลาสำหรับโควต้า ref จะมีความสำคัญเหนือกว่าค่าช่วงเวลาที่ชัดเจน หาก ref ไม่สามารถ แก้ไขได้ในขณะรันไทม์ ระบบจะใช้ค่าดังกล่าว ไม่มี ไม่บังคับ

องค์ประกอบ <StartTime>

เมื่อตั้งค่า type เป็น calendar, จะระบุวันที่ และเวลาที่ตัวนับโควต้าจะเริ่มนับ ไม่ว่าระบบจะได้รับคำขอจากแอปใดก็ตาม

เช่น

<StartTime>2017-7-16 12:00:00</StartTime>
ค่าเริ่มต้น: ไม่มี
การแสดงตน: ต้องระบุเมื่อตั้งค่า type เป็น calendar
ประเภท:

สตริงในรูปแบบวันที่และเวลา ISO 8601

องค์ประกอบ <Distributed>

การติดตั้ง Edge สามารถใช้ Message Processor อย่างน้อย 1 รายการเพื่อประมวลผลคำขอ ตั้งค่าองค์ประกอบนี้เป็น true เพื่อระบุว่านโยบายควรมีตัวนับส่วนกลาง และซิงค์อย่างต่อเนื่องใน Message Processor ทั้งหมด โปรเซสเซอร์ข้อความ สามารถอยู่ใน Availability Zone และ/หรือภูมิภาคต่างๆ

หากคุณใช้ค่าเริ่มต้นของ false คุณอาจใช้โควต้าเกินเนื่องจาก จำนวน Message Processor แต่ละรายการจะไม่แชร์

<Distributed>true</Distributed>

หากต้องการรับประกันว่าตัวนับจะซิงค์และอัปเดตในทุกคำขอ ให้ตั้งค่า <Distributed> และ <Synchronous> เป็น "จริง" ดังนี้

<Distributed>true</Distributed>
<Synchronous>true</Synchronous>
ค่าเริ่มต้น: เท็จ
การแสดงตน: ไม่บังคับ
ประเภท: บูลีน

องค์ประกอบ <Synchronous>

ตั้งค่าเป็น true เพื่ออัปเดตตัวนับโควต้าแบบกระจายพร้อมกัน ซึ่งหมายความว่าการอัปเดตตัวนับจะเกิดขึ้นพร้อมกับการตรวจสอบโควต้าในคำขอไปยัง API ตั้งค่าเป็น true หากคุณไม่ต้องการอนุญาตการเรียก API ใดๆ ที่เกินโควต้า

ตั้งค่าเป็น false เพื่ออัปเดตตัวนับโควต้าแบบไม่พร้อมกัน ซึ่งหมายความว่า การเรียก API บางรายการที่เกินโควต้าอาจดำเนินการได้ ทั้งนี้ขึ้นอยู่กับเวลาที่ ระบบอัปเดตตัวนับโควต้าในที่เก็บส่วนกลางแบบไม่พร้อมกัน แต่คุณจะไม่ได้รับผลกระทบด้านประสิทธิภาพที่อาจเกิดขึ้นซึ่งเชื่อมโยงกับการอัปเดตแบบซิงโครนัส

ช่วงเวลาการอัปเดตแบบไม่พร้อมกันเริ่มต้นคือ 10 วินาที ใช้องค์ประกอบ AsynchronousConfiguration เพื่อกำหนดค่าลักษณะการทำงานแบบไม่พร้อมกันนี้

<Synchronous>false</Synchronous>
ค่าเริ่มต้น: เท็จ
การแสดงตน: ไม่บังคับ
ประเภท: บูลีน

องค์ประกอบ <AsynchronousConfiguration>

กำหนดค่าช่วงเวลาการซิงค์ระหว่างตัวนับโควต้าแบบกระจายเมื่อองค์ประกอบการกำหนดค่านโยบาย <Synchronous> ไม่มีอยู่ หรือมีอยู่และตั้งค่าเป็น false

คุณสามารถซิงโครไนซ์หลังจากระยะเวลาหนึ่งหรือหลังจากมีข้อความจำนวนหนึ่ง โดยใช้องค์ประกอบย่อย SyncIntervalInSeconds หรือ SyncMessageCount โดยจะใช้ร่วมกันไม่ได้ ตัวอย่างเช่น

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

หรือ

<AsynchronousConfiguration>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>
ค่าเริ่มต้น: SyncIntervalInSeconds = 10 วินาที
การแสดงตน: ไม่บังคับ ระบบจะไม่สนใจเมื่อตั้งค่า <Synchronous> เป็น true
ประเภท:

อาคารและพื้นที่โดยรอบ

องค์ประกอบ <AsynchronousConfiguration>/<SyncIntervalInSeconds>

ใช้พารามิเตอร์นี้เพื่อลบล้างลักษณะการทำงานเริ่มต้นซึ่งจะมีการอัปเดตแบบไม่พร้อมกันหลังจากผ่านช่วงเวลา 10 วินาที

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

ช่วงเวลาการซิงค์ต้องมากกว่าหรือเท่ากับ 10 วินาทีตามที่อธิบายไว้ในหัวข้อขีดจำกัด

ค่าเริ่มต้น: 10
การแสดงตน: ไม่บังคับ
ประเภท:

จำนวนเต็ม

องค์ประกอบ <AsynchronousConfiguration>/<SyncMessageCount>

ระบุจำนวนคำขอในเครื่องมือประมวลผลข้อความ Apigee ทั้งหมดระหว่างการอัปเดตโควต้า 

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

ตัวอย่างนี้ระบุว่าระบบจะอัปเดตจำนวนโควต้าทุกๆ 5 คำขอในเครื่องมือประมวลผลข้อความ Apigee Edge แต่ละรายการ

ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท:

จำนวนเต็ม

องค์ประกอบ <Identifier>

ใช้องค์ประกอบ <Identifier> เพื่อกำหนดค่านโยบายในการสร้างตัวนับที่ไม่ซ้ำกัน โดยอิงตามตัวแปรโฟลว์

คุณสร้างตัวนับที่ไม่ซ้ำกันสำหรับลักษณะที่กำหนดโดยตัวแปรโฟลว์ได้ เช่น คุณอาจใช้อีเมลของนักพัฒนาแอปเพื่อเชื่อมโยงโควต้ากับนักพัฒนาแอปที่เฉพาะเจาะจง คุณใช้ตัวแปรได้หลากหลายเพื่อระบุโควต้า ไม่ว่าคุณจะใช้ตัวแปรที่กำหนดเอง หรือตัวแปรที่กำหนดไว้ล่วงหน้า เช่น ตัวแปรที่ใช้ได้กับนโยบายยืนยันคีย์ API ดูข้อมูลอ้างอิงตัวแปรด้วย

หากคุณไม่ได้ใช้องค์ประกอบนี้ นโยบายจะใช้ตัวนับเดียวที่ใช้กับ โควต้า

นอกจากนี้ องค์ประกอบนี้ยังกล่าวถึงในโพสต์ชุมชน Apigee ต่อไปนี้ด้วย ตัวระบุโควต้าในนโยบายต่างๆ

<Identifier ref="verifyapikey.verify-api-key.client_id"/>
ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท:

สตริง

Attributes

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref

ระบุตัวแปรโฟลว์ที่ระบุตัวนับที่จะใช้สำหรับคำขอ ตัวระบุ อาจเป็นส่วนหัว HTTP, พารามิเตอร์การค้นหา, พารามิเตอร์แบบฟอร์ม หรือเนื้อหาข้อความ ที่ไม่ซ้ำกันสำหรับแต่ละแอป ผู้ใช้แอป นักพัฒนาแอป ผลิตภัณฑ์ API หรือลักษณะอื่นๆ

<Identifier>ที่ใช้กันโดยทั่วไปมากที่สุดในการระบุแอปที่ไม่ซ้ำกันคือclient_id client_id เป็นชื่ออื่นของคีย์ API หรือคีย์ผู้ใช้ที่สร้างขึ้นสำหรับแอปเมื่อลงทะเบียนในองค์กรใน Apigee Edge คุณสามารถใช้ตัวระบุนี้ได้หากเปิดใช้นโยบายการให้สิทธิ์คีย์ API หรือ OAuth สำหรับ API

ในบางกรณี คุณต้องดึงข้อมูลการตั้งค่าโควต้าในกรณีที่ไม่มี client_id เช่น เมื่อไม่มีการใช้นโยบายความปลอดภัย ใน สถานการณ์เหล่านั้น คุณสามารถใช้นโยบาย Access Entity เพื่อดึงการตั้งค่าผลิตภัณฑ์ API ที่เหมาะสม จากนั้นดึงค่าโดยใช้ ExtractVariables แล้วใช้ตัวแปรบริบทที่ดึงออกมา ในนโยบายโควต้า ดูข้อมูลเพิ่มเติมได้ที่นโยบาย เอนทิตีการเข้าถึง

 ไม่มี ไม่บังคับ

องค์ประกอบ <MessageWeight>

ใช้เพื่อระบุน้ำหนักที่กำหนดให้กับแต่ละข้อความ ใช้ระดับความสำคัญของข้อความเพื่อเพิ่มผลกระทบของ ข้อความคำขอที่ใช้ทรัพยากรการคำนวณมากกว่าข้อความอื่นๆ เช่น

เช่น คุณต้องการนับข้อความ POST เป็น "หนัก" หรือมีค่าใช้จ่ายเป็น 2 เท่าของข้อความ GET ดังนั้น คุณจึงตั้งค่า MessageWeight เป็น 2 สำหรับ POST และ 1 สำหรับ GET คุณยังตั้งค่า MessageWeight เป็น 0 เพื่อให้คำขอไม่มีผลต่อตัวนับได้ด้วย ในตัวอย่างนี้ หากโควต้าคือ 10 ข้อความต่อนาทีและ MessageWeightสำหรับคำขอ POST คือ 2 โควต้าจะ อนุญาตคำขอ POST 5 รายการในช่วงเวลา 10 นาที ระบบจะปฏิเสธคำขอ POST หรือ GET เพิ่มเติม ก่อนที่ตัวนับจะรีเซ็ต

ค่าที่แสดง MessageWeight ต้องระบุโดยตัวแปรโฟลว์ และสามารถดึงข้อมูลจากส่วนหัว HTTP, พารามิเตอร์การค้นหา, เพย์โหลดคำขอ XML หรือ JSON หรือตัวแปรโฟลว์อื่นๆ เช่น คุณตั้งค่าในส่วนหัวชื่อ weight:

<MessageWeight ref="message_weight"/>
ค่าเริ่มต้น: ไม่มี
การแสดงตน: ไม่บังคับ
ประเภท:

จำนวนเต็ม

ตัวแปรโฟลว์

ระบบจะป้อนค่าตัวแปรโฟลว์ที่กำหนดไว้ล่วงหน้าต่อไปนี้โดยอัตโนมัติเมื่อนโยบายโควต้า ทํางาน ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวแปรโฟลว์ได้ที่ข้อมูลอ้างอิงตัวแปร

ตัวแปร ประเภท สิทธิ์ คำอธิบาย
ratelimit.{policy_name}.allowed.count ยาว อ่านอย่างเดียว แสดงผลจำนวนโควต้าที่อนุญาต
ratelimit.{policy_name}.used.count ยาว อ่านอย่างเดียว แสดงผลโควต้าปัจจุบันที่ใช้ภายในช่วงโควต้า
ratelimit.{policy_name}.available.count ยาว อ่านอย่างเดียว แสดงผลจำนวนโควต้าที่ใช้ได้ในช่วงโควต้า
ratelimit.{policy_name}.exceed.count ยาว อ่านอย่างเดียว แสดงผล 1 หลังจากเกินโควต้า
ratelimit.{policy_name}.total.exceed.count ยาว อ่านอย่างเดียว แสดงผล 1 หลังจากเกินโควต้า
ratelimit.{policy_name}.expiry.time ยาว อ่านอย่างเดียว

แสดงเวลา UTC เป็นมิลลิวินาทีซึ่งกำหนดเวลาที่โควต้าหมดอายุและช่วงเวลาโควต้าใหม่ เริ่มต้น

เมื่อประเภทนโยบายโควต้าเป็น rollingwindow ค่านี้จะใช้ไม่ได้ เนื่องจากช่วงเวลาของโควต้าจะไม่มีวันหมดอายุ
ratelimit.{policy_name}.identifier สตริง อ่านอย่างเดียว แสดงการอ้างอิงตัวระบุ (ไคลเอ็นต์) ที่แนบมากับนโยบาย
ratelimit.{policy_name}.class สตริง อ่านอย่างเดียว แสดงชั้นเรียนที่เชื่อมโยงกับตัวระบุไคลเอ็นต์
ratelimit.{policy_name}.class.allowed.count ยาว อ่านอย่างเดียว แสดงผลจำนวนโควต้าที่อนุญาตซึ่งกำหนดไว้ในคลาส
ratelimit.{policy_name}.class.used.count ยาว อ่านอย่างเดียว แสดงผลโควต้าที่ใช้ภายในคลาส
ratelimit.{policy_name}.class.available.count ยาว อ่านอย่างเดียว แสดงผลจำนวนโควต้าที่ใช้ได้ในชั้นเรียน
ratelimit.{policy_name}.class.exceed.count ยาว อ่านอย่างเดียว แสดงผลจำนวนคำขอที่เกินขีดจำกัดในคลาสในช่วงโควต้าปัจจุบัน
ratelimit.{policy_name}.class.total.exceed.count ยาว อ่านอย่างเดียว แสดงผลจำนวนคำขอทั้งหมดที่เกินขีดจำกัดในชั้นเรียนในช่วงโควต้าทั้งหมด จึงเป็นผลรวมของ class.exceed.count สำหรับช่วงโควต้าทั้งหมด
ratelimit.{policy_name}.failed บูลีน อ่านอย่างเดียว

ระบุว่านโยบายไม่สำเร็จหรือไม่ (จริงหรือเท็จ)

ข้อมูลอ้างอิงข้อผิดพลาด

ส่วนนี้จะอธิบายรหัสข้อผิดพลาดและข้อความแสดงข้อผิดพลาดที่แสดงกลับมา และตัวแปรข้อผิดพลาดที่ Edge ตั้งค่าไว้เมื่อนโยบายนี้ทริกเกอร์ข้อผิดพลาด ข้อมูลนี้มีความสำคัญต่อการทราบว่าคุณจะสร้างกฎความผิดพลาดเพื่อ จัดการกับข้อผิดพลาด หากต้องการเรียนรู้เพิ่มเติม โปรดดูที่สิ่งที่คุณจำเป็นต้องทราบ เกี่ยวกับข้อผิดพลาดของนโยบายและการจัดการ ข้อผิดพลาด

ข้อผิดพลาดเกี่ยวกับรันไทม์

ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อนโยบายทำงาน

รหัสข้อผิดพลาด สถานะ HTTP สาเหตุ แก้ไข
policies.ratelimit.FailedToResolveQuotaIntervalReference 500 เกิดขึ้นเมื่อไม่ได้กำหนดองค์ประกอบ <Interval> ภายในนโยบายโควต้า องค์ประกอบนี้ เป็นข้อมูลบังคับและใช้เพื่อระบุช่วงเวลาที่ใช้กับโควต้า ช่วงเวลา อาจเป็นนาที ชั่วโมง วัน สัปดาห์ หรือเดือนตามที่กำหนดไว้ในองค์ประกอบ <TimeUnit>
policies.ratelimit.FailedToResolveQuotaIntervalTimeUnitReference 500 เกิดขึ้นเมื่อไม่ได้กำหนดองค์ประกอบ <TimeUnit> ภายในนโยบายโควต้า องค์ประกอบนี้ เป็นข้อมูลบังคับและใช้เพื่อระบุหน่วยเวลาที่ใช้กับโควต้า ช่วงเวลา อาจเป็นนาที ชั่วโมง วัน สัปดาห์ หรือเดือน
policies.ratelimit.InvalidMessageWeight 500 เกิดขึ้นเมื่อค่าขององค์ประกอบ <MessageWeight> ที่ระบุผ่านตัวแปรโฟลว์ ไม่ถูกต้อง (ค่าที่ไม่ใช่จำนวนเต็ม)
policies.ratelimit.QuotaViolation 500 เกินโควต้าแล้ว ไม่มี

ข้อผิดพลาดในการทำให้ใช้งานได้

ชื่อข้อผิดพลาด สาเหตุ แก้ไข
InvalidQuotaInterval หากช่วงเวลาโควต้าที่ระบุในองค์ประกอบ <Interval> ไม่ จำนวนเต็ม การทำให้พร็อกซี API ใช้งานได้ล้มเหลว ตัวอย่างเช่น ถ้าช่วงโควต้า ที่ระบุคือ 0.1 ในองค์ประกอบ <Interval> แล้วการทำให้ใช้งานได้ของ พร็อกซี API ล้มเหลว
InvalidQuotaTimeUnit หากระบบไม่รองรับหน่วยเวลาที่ระบุในองค์ประกอบ <TimeUnit> การทำให้พร็อกซี API ใช้งานได้ล้มเหลว หน่วยเวลาที่รองรับคือ minute hour, day, week และ month
InvalidQuotaType หากประเภทของโควต้าที่ระบุโดยแอตทริบิวต์ type ใน <Quota> องค์ประกอบไม่ถูกต้อง การทำให้พร็อกซี API ใช้งานได้จึงล้มเหลว ประเภทโควต้าที่รองรับคือ default, calendar, flexi และ rollingwindow
InvalidStartTime หากรูปแบบของเวลาที่ระบุในองค์ประกอบ <StartTime> คือ จะทำให้การใช้งานพร็อกซี API ล้มเหลว รูปแบบที่ถูกต้องคือ yyyy-MM-dd HH:mm:ss ซึ่งจะอยู่ในรูปแบบวันที่และเวลา ISO 8601 สำหรับ ตัวอย่างเช่น หากเวลาที่ระบุในองค์ประกอบ <StartTime> คือ 7-16-2017 12:00:00 การทำให้พร็อกซี API ใช้งานได้ล้มเหลว
StartTimeNotSupported หากมีการระบุองค์ประกอบ <StartTime> ซึ่งไม่ได้กำหนดประเภทโควต้า calendar การทำให้พร็อกซี API ใช้งานได้ล้มเหลว องค์ประกอบ <StartTime> คือ รองรับเฉพาะโควต้าประเภท calendar ตัวอย่างเช่น หากมีการตั้งค่าแอตทริบิวต์ type เป็น flexi หรือ rolling window ในองค์ประกอบ <Quota> แล้วตามด้วยค่า การทำให้พร็อกซี API ใช้งานได้ล้มเหลว
InvalidTimeUnitForDistributedQuota หากตั้งค่าองค์ประกอบ <Distributed> เป็น true และตั้งค่าองค์ประกอบ <TimeUnit> เป็น second การทำให้พร็อกซี API ใช้งานได้ล้มเหลว หน่วยเวลา second ไม่ถูกต้องสำหรับ โควต้าแบบกระจาย
InvalidSynchronizeIntervalForAsyncConfiguration หากค่าที่ระบุสำหรับองค์ประกอบ <SyncIntervalInSeconds> ภายในองค์ประกอบ องค์ประกอบ <AsynchronousConfiguration> ในนโยบายโควต้ามีค่าน้อยกว่า 0 ดังนั้นค่า การทำให้พร็อกซี API ใช้งานได้ล้มเหลว
InvalidAsynchronizeConfigurationForSynchronousQuota หากค่าขององค์ประกอบ <AsynchronousConfiguration> ได้รับการตั้งค่าเป็น true ในนโยบายโควต้า ซึ่ง มีการกำหนดค่าอะซิงโครนัสโดยใช้องค์ประกอบ <AsynchronousConfiguration> แล้ว การทำให้พร็อกซี API ใช้งานได้ล้มเหลว

ตัวแปรความผิดพลาด

ระบบจะตั้งค่าตัวแปรเหล่านี้เมื่อนโยบายนี้ทำให้เกิดข้อผิดพลาด โปรดดูข้อมูลเพิ่มเติมที่หัวข้อสิ่งที่คุณจำเป็นต้องทราบ เกี่ยวกับข้อผิดพลาดของนโยบาย

ตัวแปร สถานที่ ตัวอย่าง
fault.name="fault_name" fault_name คือชื่อของข้อผิดพลาดตามที่ระบุไว้ในตารางข้อผิดพลาดรันไทม์ด้านบน ชื่อข้อผิดพลาดคือส่วนสุดท้ายของรหัสข้อผิดพลาด fault.name Matches "QuotaViolation"
ratelimit.policy_name.failed policy_name คือชื่อที่ผู้ใช้ระบุของนโยบายที่เป็นสาเหตุของข้อผิดพลาด ratelimit.QT-QuotaPolicy.failed = true

ตัวอย่างการตอบสนองข้อผิดพลาด

{  
   "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

การเปรียบเทียบ นโยบายโควต้า การป้องกันการเพิ่มขึ้นของทราฟิก และการจำกัดอัตราพร้อมกัน