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

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

อะไร

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

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

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

วิดีโอ

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

บทนำ (Edge ใหม่)

บทนำ (คลาสสิก Edge)

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

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

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

ปฏิทิน

หน้าต่างบานม้วน

ยืดหยุ่น

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

ตัวแปรของโฟลว์

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

ลองฟัง

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

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

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

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

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

  • ตัวแปรโฟลว์
  • พร็อพเพอร์ตี้ในผลิตภัณฑ์ แอป หรือนักพัฒนา 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 ต่อไปนี้เพื่อแสดงผลค่าของตัวแปรโฟลว์โควต้าเป็นส่วนหัวการตอบกลับ

<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 ของคุณ ตัวอย่างเช่น คุณอาจวางไว้ใน 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"/>

หากใช้นโยบาย ConfirmAPIKey เพื่อตรวจสอบคีย์ API หรือนโยบาย OAuthV2 กับโทเค็น OAuth คุณจะใช้ข้อมูลในคีย์ API หรือโทเค็นเพื่อกำหนดตัวนับแต่ละรายการสำหรับนโยบายโควต้าเดียวกันได้ ตัวอย่างเช่น แท็ก <Identifier> ต่อไปนี้ใช้ตัวแปรโฟลว์ client_id ของนโยบาย ConfirmAPIKey ชื่อ 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) รีเซ็ตปฏิทิน รีเซ็ต Flexi
นาที เริ่มต้นนาทีถัดไป 1 นาทีหลังจาก <StartTime> 1 นาทีหลังจากคำขอครั้งแรก
hour ครึ่งแรกของชั่วโมงถัดไป 1 ชั่วโมงหลัง <StartTime> 1 ชั่วโมงหลังจากส่งคำขอครั้งแรก
วัน เที่ยงคืน GMT ของวันปัจจุบัน 24 ชั่วโมงหลังจาก<StartTime> 24 ชั่วโมงหลังจากส่งคำขอครั้งแรก
สัปดาห์ เที่ยงคืน GMT วันอาทิตย์ปลายสัปดาห์ 1 สัปดาห์หลังจาก<StartTime> 1 สัปดาห์หลังจากคำขอครั้งแรก
เดือน เที่ยงคืน GMT ของวันสุดท้ายของเดือน 1 เดือน (28 วัน) หลัง <StartTime> 1 เดือน (28 วัน) หลังส่งคำขอครั้งแรก

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

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

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

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

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

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

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

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

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

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

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

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

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

เครื่องหมายเวลา

เวลาของโควต้าทั้งหมดจะกำหนดตามเขตเวลา Coordinated Universal Time (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 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 เพื่อให้การดำเนินการโฟลว์ดำเนินต่อไปได้แม้ว่านโยบายจะล้มเหลวก็ตาม

false ไม่บังคับ
enabled

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

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

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

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

false เลิกใช้

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

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

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

ไม่มีข้อมูล

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

การมีบุคคลอยู่ ไม่บังคับ
Type สตริง

องค์ประกอบ <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 ข้อความต่อเดือน

2,000 ไม่บังคับ
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

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

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

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

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

องค์ประกอบ <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 แก้ไขระหว่างรันไทม์ไม่ได้ ระบบจะใช้ค่าดังกล่าว

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

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

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

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

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

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

Attributes

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

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

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

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

เช่น

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

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

องค์ประกอบ <กระจาย>

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

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

<Distributed>true</Distributed>

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

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

องค์ประกอบแบบ<ซิงโครนัส>

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

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

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

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

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

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

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

<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 อีกด้วย 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"/>
ค่าเริ่มต้น: ไม่มีข้อมูล
สถานที่ตั้ง: ไม่บังคับ
ประเภท:

สตริง

Attributes

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

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

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

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

ไม่มีข้อมูล ไม่บังคับ

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

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

เช่น คุณต้องการนับข้อความ 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>

สคีมา

หัวข้อที่เกี่ยวข้อง

นโยบายการรีเซ็ตโควต้า

นโยบายของ SpikeArrest

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