Anda sedang melihat dokumentasi Apigee Edge.
Buka
Dokumentasi Apigee X. info
Apa
Gunakan kebijakan Kuota untuk mengonfigurasi jumlah pesan permintaan yang diizinkan oleh proxy API periode waktu, seperti menit, jam, hari, minggu, atau bulan. Anda dapat menetapkan kuota untuk sama untuk semua aplikasi yang mengakses proxy API, atau Anda dapat menyetel kuota berdasarkan:
- Produk yang berisi proxy API
- Aplikasi yang meminta API
- Developer aplikasi
- Banyak kriteria lain
Jangan gunakan Kuota untuk melindungi dari lonjakan traffic secara keseluruhan. Untuk itu, gunakan Spike Arrest lebih lanjut. Lihat Penangkapan Lonjakan kebijakan kami.
Video
Video berikut memperkenalkan pengelolaan kuota dengan kebijakan Kuota:
Pengantar (Edge Baru)
Pengantar (Edge Klasik)
Kuota Dinamis
Didistribusikan & Sinkron
Bobot Pesan
Kalender
Jendela Berkelanjutan
Flexi
Kuota Bersyarat
Variabel Alur
Penanganan Error
Contoh
Contoh kode kebijakan ini menggambarkan cara memulai dan mengakhiri periode kuota dengan:
Kuota Dinamis Lainnya
<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>
Kuota dinamis memungkinkan Anda mengonfigurasi satu kebijakan Kuota yang menerapkan Kuota yang berbeda berdasarkan informasi yang diteruskan ke kebijakan Kuota. Istilah lain untuk setelan Kuota di konteks ini adalah "Paket Layanan". Kuota dinamis memeriksa aplikasi "Paket Layanan" Lalu memberlakukan setelan tersebut.
Catatan: Jika Anda menentukan nilai dan referensi untuk suatu elemen, maka referensi yang diprioritaskan akan diprioritaskan. Jika referensi tidak di-resolve saat runtime, nilainya adalah data
Misalnya, ketika Anda membuat produk API, Anda bisa secara opsional menetapkan kuota yang diizinkan batas, satuan waktu, dan interval. Namun, menetapkan nilai ini pada produk API tidak menerapkan penggunaannya dalam proxy API. Anda juga harus menambahkan kebijakan Quota ke proxy API yang akan membaca nilai-nilai ini. Lihat Create API produk untuk mengetahui lebih banyak lagi.
Pada contoh di atas, proxy API yang berisi kebijakan Quota menggunakan VerifyAPIKey
kebijakan bernama verify-api-key
untuk memvalidasi kunci API yang diteruskan dalam permintaan. Tujuan
Kemudian, kebijakan kuota mengakses variabel alur dari kebijakan VerifyAPIKey untuk membaca kuota
yang ditetapkan pada produk API. Untuk informasi selengkapnya tentang variabel alur VerifyAPIKey, lihat Memverifikasi kebijakan Kunci API.
Pilihan lainnya adalah menyetel atribut khusus pada masing-masing developer atau aplikasi, lalu membaca nilai-nilai tersebut di kebijakan Quota. Misalnya, Anda ingin menetapkan nilai kuota yang berbeda per developer. Dalam hal ini, Anda menetapkan atribut khusus pada pengembang yang berisi batas, satuan waktu, dan interval. Kemudian, Anda akan mereferensikan nilai ini dalam kebijakan Quota seperti yang ditunjukkan di bawah ini:
<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>
Contoh ini juga menggunakan variabel alur VerifyAPIKey untuk mereferensikan atribut khusus ditetapkan pada pengembang.
Anda dapat menggunakan variabel apa pun untuk menetapkan parameter kebijakan Quota. Variabel-variabel tersebut dapat berasal dari:
- Variabel flow
- Properti di produk, aplikasi, atau developer API
- Peta nilai kunci (KVM)
- Header, parameter kueri, parameter formulir, dll.
Untuk setiap proxy API, Anda dapat menambahkan kebijakan Kuota, baik yang merujuk ke variabel yang sama seperti semua kebijakan Kuota lainnya di semua proxy lainnya, atau kebijakan Kuota dapat variabel yang unik untuk kebijakan dan {i>proxy<i} tersebut.
Waktu Mulai
<Quota name="QuotaPolicy" type="calendar"> <StartTime>2017-02-18 10:30:00</StartTime> <Interval>5</Interval> <TimeUnit>hour</TimeUnit> <Allow count="99"/> </Quota>
Untuk Kuota dengan type
yang ditetapkan ke calendar
, Anda harus menentukan
nilai <StartTime>
eksplisit. Nilai waktu adalah waktu GMT, bukan waktu lokal
baik. Jika Anda tidak memberikan nilai <StartTime>
untuk jenis kebijakan
calendar
, Edge mengeluarkan error.
Penghitung Kuota untuk setiap aplikasi dimuat ulang berdasarkan <StartTime>
,
Nilai <Interval>
, dan <TimeUnit>
. Untuk ini
misalnya, Kuota mulai dihitung pada pukul 10.30 GMT pada tanggal 18 Februari 2017, dan diperbarui setiap
5 jam. Oleh karena itu, pembaruan berikutnya adalah pada 18 Februari 2017 pukul 15.30 GMT.
Penghitung Akses
<Quota name="QuotaPolicy"> <Interval>5</Interval> <TimeUnit>hour</TimeUnit> <Allow count="99"/> </Quota>
Proxy API memiliki akses ke variabel alur yang ditetapkan oleh kebijakan Kuota. Anda dapat mengakses variabel alur ini di proxy API untuk melakukan pemrosesan bersyarat, memantau kebijakan karena mendekati batas kuota, mengembalikan penghitung kuota saat ini ke aplikasi, atau alasan.
Karena akses variabel alur untuk kebijakan didasarkan pada kebijakan
Atribut name
, untuk kebijakan di atas yang bernama QuotaPolicy
Anda
mengakses variabel alurnya dalam bentuk:
ratelimit.QuotaPolicy.allowed.count
: Jumlah yang diizinkan.ratelimit.QuotaPolicy.used.count
: Nilai penghitung saat ini.ratelimit.QuotaPolicy.expiry.time
: Waktu UTC saat penghitung direset.
Ada banyak variabel alur lain yang dapat Anda akses, seperti yang dijelaskan di bawah ini.
Misalnya, Anda dapat menggunakan kebijakan MenetapkanMessage berikut untuk menampilkan nilai Quota variabel alur sebagai header respons:
<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>
Permintaan Pertama
<Quota name="MyQuota"> <Interval>1</Interval> <TimeUnit>hour</TimeUnit> <Allow count="10000"/> </Quota>
Gunakan kode contoh ini untuk menerapkan kuota 10.000 panggilan per satu jam. Kebijakan akan direset penghitung kuota di bagian atas setiap jam. Jika penghitung mencapai kuota 10.000 panggilan sebelum akhir jam tersebut, panggilan yang melebihi 10.000 akan ditolak.
Misalnya, jika penghitung dimulai pada 2017-07-08 07:00:00
, penghitung akan direset ke
0 pukul 2017-07-08 08:00:00
(1 jam dari waktu mulai). Jika pesan pertama adalah
diterima di 2017-07-08 07:35:28
dan jumlah pesan mencapai 10.000
sebelum 2017-07-08 08:00:00
, panggilan yang melebihi jumlah tersebut akan ditolak hingga
hitungan ulang akan diatur ulang di bagian atas jam.
Waktu reset penghitung didasarkan pada kombinasi <Interval>
dan
<TimeUnit>
. Misalnya, jika Anda menetapkan <Interval>
ke
12 selama <TimeUnit>
jam, lalu penghitung direset setiap dua belas jam.
Anda dapat menyetel <TimeUnit>
ke menit, jam, hari, minggu, atau bulan.
Anda dapat merujuk kebijakan ini di beberapa tempat di proxy API. Misalnya, Anda dapat menempatkannya di Proxy PreFlow sehingga dieksekusi pada setiap permintaan. Atau, Anda bisa menempatkan di beberapa alur di proxy API. Jika Anda menggunakan kebijakan ini di beberapa tempat di proxy, ia mengelola satu penghitung yang diperbarui oleh semua instance kebijakan.
Atau, Anda dapat menentukan beberapa kebijakan Quota di proxy API Anda. Setiap kebijakan Kuota
mempertahankan penghitungnya sendiri, berdasarkan atribut name
kebijakan.
Tetapkan ID
<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>
Secara default, kebijakan Kuota menentukan satu penghitung untuk proxy API, terlepas dari
asal permintaan. Atau, Anda dapat menggunakan atribut <Identifier>
dengan kebijakan Kuota untuk mempertahankan penghitung terpisah berdasarkan nilai
Atribut <Identifier>
.
Misalnya, gunakan tag <Identifier>
untuk menentukan penghitung terpisah untuk
setiap client ID. Berdasarkan permintaan ke proxy Anda, aplikasi klien kemudian meneruskan header yang berisi
clientID
, seperti yang ditunjukkan dalam contoh di atas.
Anda dapat menentukan variabel alur apa pun ke atribut <Identifier>
. Sebagai
sebagai contoh, Anda dapat menentukan bahwa parameter kueri bernama id
berisi
ID:
<Identifier ref="request.queryparam.id"/>
Jika Anda menggunakan kebijakan VerifyAPIKey untuk memvalidasi kunci API, atau kebijakan OAuthV2
dengan token OAuth, Anda dapat menggunakan informasi dalam token atau kunci API untuk menentukan
untuk kebijakan Kuota yang sama. Misalnya,
Tag <Identifier>
menggunakan variabel alur client_id
dari
Kebijakan VerifyAPIKey bernama verify-api-key
:
<Identifier ref="verifyapikey.verify-api-key.client_id"></Identifier>
Setiap nilai client_id
unik kini menentukan penghitungnya sendiri di Kuota
lebih lanjut.
Kelas
<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>
Anda dapat menetapkan batas Kuota secara dinamis menggunakan jumlah Kuota berbasis class. Dalam contoh ini,
batas kuota ditentukan oleh nilai developer_segment
header yang diteruskan dengan setiap permintaan. Variabel tersebut dapat memiliki nilai platinum
atau silver
. Jika header memiliki nilai yang tidak valid, kebijakan akan menampilkan kuota
kesalahan pelanggaran.
Tentang kebijakan Kuota
Kuota adalah alokasi pesan permintaan yang dapat ditangani oleh proxy API selama jangka waktu tertentu, seperti menit, jam, hari, minggu, atau bulan. Kebijakan ini mempertahankan penghitung yang menghitung jumlah permintaan yang diterima oleh proxy API. Kemampuan ini memungkinkan penyedia API menerapkan batasan jumlah panggilan API yang dilakukan oleh aplikasi selama interval waktu tertentu. Dengan menggunakan kebijakan Kuota, Anda dapat, misalnya, batasi aplikasi hingga 1 permintaan per menit, atau hingga 10.000 permintaan per bulan.
Misalnya, jika Kuota ditetapkan sebagai 10.000 pesan per bulan, pembatasan kapasitas dimulai setelah pesan yang ke-10.000. Tidak masalah apakah 10.000 pesan dihitung pada hari atau hari terakhir menstruasi tersebut; tidak ada area permintaan tambahan yang diizinkan hingga penghitung Kuota otomatis direset pada akhir interval waktu yang ditentukan, atau hingga Kuota secara eksplisit reset menggunakan Reset Kuota kebijakan kami.
Variasi pada Kuota yang disebut SpikeArrest mencegah lonjakan traffic (atau burst) yang dapat disebabkan oleh peningkatan penggunaan yang mendadak, klien yang memiliki bug, atau serangan berbahaya. Untuk selengkapnya untuk mengetahui informasi tentang SpikeArrest, lihat kebijakanSpike Arrest.
Kuota berlaku untuk proxy API individual dan tidak didistribusikan di antara proxy API. Misalnya, jika Anda memiliki tiga proxy API dalam satu produk API, satu kuota tidak dibagikan di ketiganya meskipun ketiganya menggunakan konfigurasi kebijakan kuota yang sama.
Jenis kebijakan kuota
Kebijakan Kuota mendukung beberapa jenis kebijakan: default, calendar
,
flexi
, dan rollingwindow
. Setiap jenis menentukan kapan penghitung kuota
dimulai dan saat direset, seperti ditunjukkan dalam tabel berikut:
Unit Waktu | Reset default (atau null) | kalender direset | reset flexi |
---|---|---|---|
menit | Awal menit berikutnya | Satu menit setelah <StartTime> |
Satu menit setelah permintaan pertama |
jam | Atas jam berikutnya | Satu jam setelah <StartTime> |
Satu jam setelah permintaan pertama |
hari | GMT tengah malam hari ini | 24 jam setelah <StartTime> |
24 jam setelah permintaan pertama |
week | Tengah malam GMT pada akhir minggu | Satu minggu setelah <StartTime> |
Satu minggu setelah permintaan pertama |
bulan | Tengah malam GMT dari hari terakhir bulan ini | Satu bulan (28 hari) setelah <StartTime> |
Satu bulan (28 hari) setelah permintaan pertama |
Untuk type="calendar"
, Anda harus menentukan nilai
<StartTime>
.
Tabel tidak mencantumkan nilai untuk jenis rollingwindow
. Jendela Berkelanjutan
kuota bekerja dengan menetapkan ukuran "periode" kuota, misalnya periode satu jam atau satu hari. Ketika seorang
permintaan baru masuk, kebijakan akan menentukan apakah kuota telah terlampaui sebelumnya
"jendela" waktu tertentu.
Misalnya, Anda menentukan periode dua jam yang mengizinkan 1.000 permintaan. Permintaan baru masuk pada pukul 16:45.Kebijakan itu menghitung jumlah kuota selama dua jam terakhir, yang berarti jumlah permintaan sejak pukul 14:45. Jika batas kuota belum terlampaui dua jam, maka permintaan akan diperbolehkan.
Satu menit kemudian, pada pukul 16.46, permintaan lain masuk. Sekarang kebijakan tersebut menghitung jumlah kuota sejak pukul 14.46 untuk menentukan apakah batas telah terlampaui.
Untuk jenis rollingwindow
, penghitung tidak pernah direset, tetapi
dihitung ulang pada setiap permintaan.
Memahami penghitung kuota
Secara default, kebijakan Kuota mempertahankan satu penghitung, terlepas dari berapa kali Anda
merujuknya dalam proxy API. Nama penghitung kuota didasarkan pada
atribut name
kebijakan.
Misalnya, Anda membuat kebijakan Kuota bernama MyQuotaPolicy
dengan batas 5
dan menempatkannya di beberapa flow (Alur A, B, dan C) di proxy API. Meskipun
digunakan dalam beberapa alur, ia mempertahankan satu penghitung yang diperbarui oleh semua instance
kebijakan:
- Alur A dieksekusi -> MyQuotaPolicy dijalankan dan penghitungnya = 1
- Alur B dieksekusi -> MyQuotaPolicy dijalankan dan penghitungnya = 2
- Alur A dieksekusi -> MyQuotaPolicy dijalankan dan penghitungnya = 3
- Alur C dieksekusi -> MyQuotaPolicy dijalankan dan penghitungnya = 4
- Alur A dieksekusi -> MyQuotaPolicy dijalankan dan penghitungnya = 5
Permintaan berikutnya ke salah satu dari ketiga alur ditolak karena penghitung kuota telah mencapai batasnya.
Menggunakan kebijakan Kuota yang sama di lebih dari satu tempat dalam alur proxy API, yang dapat secara tidak sengaja menyebabkan Kuota habis lebih cepat dari yang diperkirakan, adalah anti-pola yang dijelaskan di The Book of Apigee Edge Anti-pola.
Atau, Anda dapat menetapkan beberapa kebijakan Quota di proxy API dan menggunakan
kebijakan di setiap alur. Setiap kebijakan Kuota mempertahankan penghitungnya sendiri, berdasarkan
atribut name
kebijakan.
Atau, gunakan
<Class>
atau <Identifier>
elemen di
kebijakan Kuota untuk menentukan beberapa penghitung unik dalam satu kebijakan. Dengan menggunakan
satu kebijakan dapat mempertahankan penghitung
yang berbeda berdasarkan aplikasi yang membuat permintaan,
pengembang aplikasi yang membuat permintaan, ID klien atau ID klien lainnya, dan banyak lagi. Lihat
contoh di atas untuk informasi lebih lanjut tentang penggunaan
Elemen <Class>
atau <Identifier>
.
Notasi waktu
Semua waktu Kuota ditetapkan ke aplikasi Universal Terkoordinasi Zona waktu (UTC).
Notasi waktu kuota mengikuti notasi tanggal standar internasional yang ditentukan dalam ISO 8601 standar.
Tanggal didefinisikan sebagai tahun, bulan, dan hari, dalam format berikut: YYYY-MM-DD
.
Misalnya, 2015-02-04
merepresentasikan 4 Februari 2015.
Waktu dalam sehari didefinisikan sebagai jam, menit, dan detik dalam format berikut:
hours:minutes:seconds
. Misalnya, 23:59:59
mewakili waktu
detik sebelum tengah malam.
Perhatikan bahwa dua notasi, 00:00:00
dan 24:00:00
, tersedia untuk
membedakan dua tengah malam yang
dapat dikaitkan dengan satu tanggal. Oleh karena itu, 2015-02-04
24:00:00
adalah tanggal dan waktu yang sama dengan 2015-02-05 00:00:00
. Yang terakhir adalah
biasanya notasi yang disukai.
Mendapatkan setelan kuota dari konfigurasi produk API
Anda dapat menetapkan batas kuota dalam konfigurasi produk API. Batasan tersebut tidak otomatis memberlakukan kuota. Sebagai gantinya, Anda dapat merujuk setelan kuota produk dalam kebijakan kuota. Berikut beberapa keuntungan penetapan kuota pada produk untuk referensi kebijakan kuota:
- Kebijakan kuota dapat menggunakan setelan seragam di semua proxy API di produk API.
- Anda dapat membuat perubahan runtime pada setelan kuota di produk API, dan kebijakan kuota yang mereferensikan nilai tersebut akan otomatis memiliki nilai kuota yang diperbarui.
Untuk informasi selengkapnya tentang cara menggunakan setelan kuota dari produk API, lihat "Kuota Dinamis" contoh di atas..
Untuk info tentang cara mengonfigurasi produk API dengan batas kuota, lihat Membuat produk API.
Referensi elemen
Berikut adalah elemen dan atribut yang dapat Anda konfigurasi di kebijakan ini. Perhatikan bahwa beberapa elemen
kombinasi keduanya bersifat eksklusif
atau tidak wajib. Lihat contoh untuk penggunaan tertentu. Tujuan
verifyapikey.VerifyAPIKey.apiproduct.*
variabel di bawah tersedia secara default jika
kebijakan Verify API Key bernama "VerifyAPIKey" digunakan untuk memeriksa kunci API aplikasi dalam permintaan.
Nilai variabel berasal dari setelan kuota pada produk API yang dikaitkan dengan kunci
seperti yang dijelaskan dalam Mendapatkan setelan kuota dari produk API
konfigurasi.
<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> atribut
<Quota async="false" continueOnError="false" enabled="true" name="Quota-3" type="calendar">
Atribut berikut khusus untuk kebijakan ini.
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
jenis |
Gunakan untuk menentukan kapan dan bagaimana penghitung kuota memeriksa penggunaan kuota. Lihat Jenis kebijakan kuota untuk mengetahui informasi selengkapnya. Jika Anda menghapus nilai Nilai yang valid mencakup:
|
kalender | Opsional |
Tabel berikut menjelaskan atribut yang umum untuk semua elemen induk kebijakan:
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
name |
Nama internal kebijakan. Nilai atribut Secara opsional, gunakan elemen |
T/A | Wajib |
continueOnError |
Tetapkan ke Setel ke |
salah | Opsional |
enabled |
Setel ke Setel ke |
true | Opsional |
async |
Atribut ini tidak digunakan lagi. |
salah | Tidak digunakan lagi |
<DisplayName> elemen
Gunakan selain atribut name
untuk memberi label kebijakan di
editor proxy UI dengan nama natural language yang berbeda.
<DisplayName>Policy Display Name</DisplayName>
Default |
T/A Jika Anda menghapus elemen ini, nilai atribut |
---|---|
Ketersediaan | Opsional |
Jenis | String |
<Allow> elemen
Menentukan batas jumlah untuk kuota. Jika penghitung untuk kebijakan mencapai batas ini , panggilan berikutnya akan ditolak hingga penghitung direset.
Berikut adalah tiga cara untuk menetapkan elemen <Allow>
:
<Allow count="2000"/>
<Allow countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.limit"/>
<Allow count="2000" countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.limit"/>
Jika Anda menentukan count
dan countRef
, maka countRef
yang mendapatkan prioritas. Jika countRef
tidak di-resolve saat runtime, nilai
count
digunakan.
Default: | T/A |
Kehadiran: | Opsional |
Jenis: | Bilangan Bulat |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
jumlah |
Gunakan untuk menentukan jumlah pesan untuk kuota. Misalnya, nilai atribut |
2000 | Opsional |
countRef |
Gunakan untuk menentukan variabel alur yang berisi jumlah pesan untuk kuota.
|
tidak ada | Opsional |
<Allow>/<Class> elemen
Elemen <Class>
memungkinkan Anda mengubah kondisi nilai
dari elemen <Allow>
berdasarkan nilai variabel flow. Sebagai
setiap tag turunan <Allow>
yang berbeda dari <Class>
,
kebijakan tersebut mempertahankan
penghitungan yang berbeda.
Untuk menggunakan elemen <Class>
, tentukan variabel alur menggunakan elemen
ref
ke tag <Class>
. Edge kemudian menggunakan nilai
variabel alur untuk memilih salah satu tag turunan <Allow>
guna menentukan tag yang diizinkan
penghitungan kebijakan. Edge mencocokkan nilai variabel flow dengan class
dari tag <Allow>
, seperti yang ditunjukkan di bawah ini:
<Allow> <Class ref="request.queryparam.time_variable"> <Allow class="peak_time" count="5000"/> <Allow class="off_peak_time" count="1000"/> </Class> </Allow>
Dalam contoh ini, penghitung kuota saat ini ditentukan oleh nilai
Parameter kueri time_variable
diteruskan dengan setiap permintaan. Variabel itu dapat
memiliki nilai
dari peak_time
atau off_peak_time
. Jika parameter kueri berisi nilai yang tidak valid
kebijakan akan menampilkan error pelanggaran kuota.
Default: | T/A |
Kehadiran: | Opsional |
Jenis: | T/A |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
referensi |
Gunakan untuk menentukan variabel flow yang berisi class kuota untuk kuota. |
tidak ada | Wajib |
<Allow>/<Class>/<Allow> elemen
Elemen <Allow>
menentukan batas untuk penghitung kuota
ditentukan oleh elemen <Class>
. Untuk setiap
tag turunan <Allow>
yang berbeda dari <Class>
,
tetapi menghasilkan penghitung
yang berbeda.
Contoh:
<Allow> <Class ref="request.queryparam.time_variable"> <Allow class="peak_time" count="5000"/> <Allow class="off_peak_time" count="1000"/> </Class> </Allow>
Dalam contoh ini, kebijakan Kuota menyimpan dua penghitung kuota yang bernama
dari peak_time
dan off_peak_time
.
Default: | T/A |
Kehadiran: | Opsional |
Jenis: | T/A |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
class |
Menentukan nama penghitung kuota. |
tidak ada | Wajib |
jumlah | Menentukan batas kuota untuk penghitung. | tidak ada | Wajib |
<Interval> elemen
Gunakan untuk menentukan bilangan bulat (misalnya, 1, 2, 5, 60, dan seterusnya) yang akan dipasangkan dengan
TimeUnit
yang Anda tentukan (menit, jam, hari, minggu, atau bulan) untuk menentukan waktu
periode saat Edge menghitung penggunaan kuota.
Misalnya, Interval
dari 24
dengan
TimeUnit
dari hour
berarti kuota akan
dihitung selama
24 jam.
<Interval ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.interval">1</Interval>
Default: | tidak ada |
Kehadiran: | Wajib |
Jenis: | Bilangan Bulat |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
referensi |
Gunakan untuk menentukan variabel alur yang berisi interval untuk
kuota tambahan. |
tidak ada | Opsional |
<TimeUnit> elemen
Gunakan untuk menentukan satuan waktu yang berlaku untuk kuota.
Misalnya, Interval
dari 24
dengan
TimeUnit
dari hour
berarti kuota akan
dihitung selama
24 jam.
<TimeUnit ref="verifyapikey.VerifyAPIKey.apiproduct.developer.quota.timeunit">month</TimeUnit>
Default: | tidak ada |
Kehadiran: | Wajib |
Jenis: |
String. Pilih dari |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
referensi | Gunakan untuk menentukan variabel alur yang berisi unit waktu untuk kuota. ref
lebih diprioritaskan daripada nilai interval eksplisit. Jika ref memiliki
tidak di-resolve saat runtime, maka nilainya akan digunakan. |
tidak ada | Opsional |
<StartTime> elemen
Jika type
ditetapkan ke calendar,
, Anda akan menentukan tanggal
dan waktu saat penghitung kuota akan mulai menghitung, terlepas dari apakah ada permintaan
diterima dari aplikasi apa pun.
Anda harus memberikan StartTime
eksplisit saat type
ditetapkan secara eksplisit
ke calendar,
Anda tidak dapat menggunakan referensi ke variabel alur, jika menentukan
nilai StartTime
jika tidak ada nilai type
yang ditetapkan, Anda akan menerima
{i>error<i}.
Contoh:
<StartTime>2017-7-16 12:00:00</StartTime>
Default: | tidak ada |
Kehadiran: | Wajib jika type ditetapkan ke calendar . |
Jenis: |
String dalam ISO 8601 tanggal dan waktu. |
<Terdistribusi> elemen
Penginstalan Edge dapat menggunakan satu atau beberapa Pemroses Pesan untuk memproses permintaan. Setel ini
ke true
untuk menentukan bahwa kebijakan harus mempertahankan
dan terus menyinkronkannya di semua Pemroses Pesan. Pemroses pesan
dapat berada di seluruh zona ketersediaan dan/atau region.
Jika menggunakan nilai default false
, Anda mungkin akan melebihi kuota karena
jumlah untuk setiap Pemroses Pesan tidak dibagikan:
<Distributed>true</Distributed>
Untuk menjamin bahwa penghitung disinkronkan, dan diperbarui pada setiap permintaan, atur
<Distributed>
dan <Synchronous>
ke benar:
<Distributed>true</Distributed> <Synchronous>true</Synchronous>
Default: | salah |
Kehadiran: | Opsional |
Jenis: | Boolean |
<Synchronous> elemen
Tetapkan ke true
untuk memperbarui penghitung kuota terdistribusi secara sinkron. Ini
berarti bahwa pembaruan pada penghitung dilakukan pada saat yang sama kuota diperiksa pada permintaan
ke API. Tetapkan ke true
jika Anda tidak mengizinkan API apa pun
panggilan melebihi kuota.
Tetapkan ke false
untuk memperbarui penghitung kuota secara asinkron. Artinya
beberapa panggilan API yang melebihi kuota akan dapat dilakukan, tergantung pada
penghitung kuota di repositori pusat diupdate secara asinkron. Namun, Anda tidak akan menghadapi
dampak kinerja potensial yang
terkait dengan pembaruan sinkron.
Interval update asinkron default adalah 10 detik. Gunakan
AsynchronousConfiguration
untuk mengonfigurasi perilaku asinkron ini.
<Synchronous>false</Synchronous>
Default: | salah |
Kehadiran: | Opsional |
Jenis: | Boolean |
<AsynchronousConfiguration> elemen
Mengonfigurasi interval sinkronisasi di antara penghitung kuota terdistribusi saat kebijakan
elemen konfigurasi <Synchronous>
tidak ada atau tidak ada dan disetel
ke false
.
Anda dapat menyinkronkan baik setelah jangka waktu tertentu atau setelah jumlah pesan, menggunakan
Elemen turunan SyncIntervalInSeconds
atau SyncMessageCount
.
Keduanya saling eksklusif. Misalnya,
<AsynchronousConfiguration> <SyncIntervalInSeconds>20</SyncIntervalInSeconds> </AsynchronousConfiguration>
atau
<AsynchronousConfiguration> <SyncMessageCount>5</SyncMessageCount> </AsynchronousConfiguration>
Default: | SyncIntervalInSeconds = 10 detik |
Kehadiran: | Opsional; diabaikan saat <Synchronous> ditetapkan ke
true . |
Jenis: |
Kompleks |
<AsynchronousConfiguration>/<SyncIntervalInSeconds> elemen
Gunakan ini untuk mengganti perilaku default saat pembaruan asinkron dijalankan setelah dengan interval 10 detik.
<AsynchronousConfiguration> <SyncIntervalInSeconds>20</SyncIntervalInSeconds> </AsynchronousConfiguration>
Interval sinkronisasi harus >= 10 detik seperti yang dijelaskan dalam Membatasi topik.
Default: | 10 |
Kehadiran: | Opsional |
Jenis: |
Bilangan Bulat |
<AsynchronousConfiguration>/<SyncMessageCount> elemen
Menentukan jumlah permintaan di semua pemroses pesan Apigee di antara kuota pembaruan.
<AsynchronousConfiguration> <SyncMessageCount>5</SyncMessageCount> </AsynchronousConfiguration>
Contoh ini menunjukkan bahwa jumlah kuota diperbarui setiap 5 permintaan di setiap Apigee Pemroses pesan edge.
Default: | t/a |
Kehadiran: | Opsional |
Jenis: |
Bilangan Bulat |
<Identifier> elemen
Gunakan elemen <Identifier>
untuk mengonfigurasi kebijakan agar dapat membuat kode unik
penghitung berdasarkan variabel {i>flow<i}.
Jika Anda tidak menggunakan elemen ini, kebijakan akan menggunakan satu penghitung yang diterapkan pada kuota.
Elemen ini juga dibahas dalam Postingan komunitas Apigee berikut: 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"/>
Default: | T/A |
Kehadiran: | Opsional |
Jenis: |
String |
Atribut
Atribut | Deskripsi | Default | Ketersediaan |
---|---|---|---|
referensi |
Menentukan variabel alur yang mengidentifikasi penghitung yang akan digunakan untuk permintaan. Tujuan ID dapat berupa header HTTP, parameter kueri, parameter formulir, atau konten pesan yang unik untuk setiap aplikasi, pengguna aplikasi, developer aplikasi, produk API, atau karakteristik.
Dalam beberapa situasi, setelan Kuota harus diambil jika tidak
|
T/A | Opsional |
<MessageWeight> elemen
Gunakan untuk menetapkan bobot yang ditetapkan pada setiap pesan. Gunakan bobot pesan untuk meningkatkan dampak pesan yang, misalnya, memakai lebih banyak sumber daya komputasi dibandingkan yang lain.
Misalnya, Anda ingin menghitung pesan POST dua kali lebih banyak daripada "berat" atau mahal, seperti GET
membuat pesan teks. Oleh karena itu, Anda menetapkan MessageWeight
ke 2 untuk POST dan 1 untuk
DAPATKAN. Anda bahkan dapat menyetel MessageWeight
ke 0 sehingga permintaan tidak
akan memengaruhi penghitung. Dalam contoh ini, jika kuotanya adalah
10 pesan per menit dan
MessageWeight
untuk permintaan POST adalah 2
, maka kuota akan
mengizinkan 5 permintaan POST dalam setiap interval 10 menit. Setiap permintaan tambahan, seperti POST atau GET,
sebelum reset penghitung ditolak.
Nilai yang mewakili MessageWeight
harus ditentukan oleh flow
variabel, dan dapat diekstrak dari header HTTP, parameter kueri, permintaan XML atau JSON
payload, atau variabel alur lainnya. Misalnya, Anda mengaturnya
pada {i>header <i}bernama
weight
:
<MessageWeight ref="message_weight"/>
Default: | T/A |
Kehadiran: | Opsional |
Jenis: |
Bilangan Bulat |
Variabel flow
Variabel Flow yang telah ditetapkan sebelumnya akan otomatis diisi saat kebijakan Kuota akan dijalankan. Untuk mengetahui informasi selengkapnya tentang variabel Alur, lihat Referensi variabel.
Variabel | Jenis | Izin | Deskripsi |
---|---|---|---|
ratelimit.{policy_name}.allowed.count | Panjang | Hanya Baca | Menampilkan jumlah kuota yang diizinkan |
ratelimit.{policy_name}.used.count | Panjang | Hanya Baca | Menampilkan kuota saat ini yang digunakan dalam interval kuota |
ratelimit.{policy_name}.available.count | Panjang | Hanya Baca | Menampilkan jumlah kuota yang tersedia dalam interval kuota |
ratelimit.{policy_name}.exceed.count | Panjang | Hanya Baca | Menampilkan 1 setelah kuota terlampaui. |
ratelimit.{policy_name}.total.exceed.count | Panjang | Hanya Baca | Menampilkan 1 setelah kuota terlampaui. |
ratelimit.{policy_name}.expiry.time | Panjang | Hanya Baca |
Menampilkan waktu UTC dalam milidetik yang menentukan kapan kuota berakhir dan kuota baru Interval kuota dimulai. Jika jenis kebijakan Kuota adalah |
batas kapasitas.{policy_name}.ID | String | Hanya Baca | Menampilkan referensi ID (klien) yang dilampirkan ke kebijakan |
kapasitas.{policy_name}.class | String | Hanya Baca | Menampilkan class yang terkait dengan ID klien |
ratelimit.{policy_name}.class.allowed.count | Panjang | Hanya Baca | Menampilkan jumlah kuota yang diizinkan dan ditentukan di class |
ratelimit.{policy_name}.class.used.count | Panjang | Hanya Baca | Menampilkan kuota yang telah digunakan dalam class |
ratelimit.{policy_name}.class.available.count | Panjang | Hanya Baca | Menampilkan jumlah kuota yang tersedia di kelas |
ratelimit.{policy_name}.class.exceed.count | Panjang | Hanya Baca | Menampilkan jumlah permintaan yang melebihi batas di class dalam interval kuota saat ini |
ratelimit.{policy_name}.class.total.exceed.count | Panjang | Hanya Baca | Menampilkan jumlah total permintaan yang melebihi batas di class di semua
interval kuota, jadi ini adalah jumlah dari class.exceed.count untuk semua
interval kuota. |
batas kapasitas.{policy_name}.failed | Boolean | Hanya Baca |
Menunjukkan apakah kebijakan gagal atau tidak (benar atau salah). |
Referensi error
Bagian ini menjelaskan kode kesalahan dan pesan kesalahan yang dikembalikan dan variabel kesalahan yang disetel oleh Edge saat kebijakan ini memicu kesalahan. Informasi ini penting untuk diketahui jika Anda mengembangkan aturan kesalahan untuk menangani kesalahan. Untuk mempelajari lebih lanjut, lihat Yang perlu Anda ketahui tentang error kebijakan dan Penanganan kesalahan.
Error runtime
Error ini dapat terjadi saat kebijakan dijalankan.
Kode error | Status HTTP | Penyebab | Perbaiki |
---|---|---|---|
policies.ratelimit.FailedToResolveQuotaIntervalReference |
500 | Terjadi jika elemen <Interval> tidak ditentukan dalam kebijakan Quota. Elemen ini
bersifat wajib dan digunakan untuk menentukan interval waktu yang berlaku untuk kuota. Interval waktu
bisa berupa menit, jam, hari, minggu, atau bulan seperti yang ditentukan dengan elemen <TimeUnit> . |
build |
policies.ratelimit.FailedToResolveQuotaIntervalTimeUnitReference |
500 | Terjadi jika elemen <TimeUnit> tidak ditentukan dalam kebijakan Quota. Elemen ini
bersifat wajib dan digunakan untuk menentukan satuan waktu yang berlaku untuk kuota. Interval waktu
bisa dalam hitungan menit, jam, hari, minggu, atau bulan. |
build |
policies.ratelimit.InvalidMessageWeight |
500 | Terjadi jika nilai elemen <MessageWeight> ditentukan melalui variabel flow
tidak valid (nilai bukan bilangan bulat). |
build |
policies.ratelimit.QuotaViolation |
500 | Batas kuota terlampaui. | T/A |
Error saat deployment
Nama error | Penyebab | Perbaiki |
---|---|---|
InvalidQuotaInterval |
Jika interval kuota yang ditentukan dalam elemen <Interval> tidak
bilangan bulat, maka deployment proxy API akan gagal. Misalnya, jika interval kuota
yang ditentukan adalah 0.1 dalam elemen <Interval> , maka deployment
Proxy API gagal.
|
build |
InvalidQuotaTimeUnit |
Jika satuan waktu yang ditentukan dalam elemen <TimeUnit> tidak didukung,
maka deployment proxy API akan gagal. Satuan waktu yang didukung adalah minute ,
hour , day , week , dan month .
|
build |
InvalidQuotaType |
Jika jenis kuota yang ditentukan oleh atribut type di <Quota>
tidak valid, maka deployment proxy API akan gagal. Tujuan
jenis kuota yang didukung adalah default , calendar , flexi , dan rollingwindow .
|
build |
InvalidStartTime |
Jika format waktu yang ditentukan dalam elemen <StartTime> adalah
tidak valid, berarti deployment proxy API akan gagal. Format yang valid adalah yyyy-MM-dd HH:mm:ss ,
yang merupakan format tanggal dan waktu ISO 8601. Sebagai
contoh, jika waktu yang ditentukan dalam elemen <StartTime>
7-16-2017 12:00:00 , deployment proxy API akan gagal.
|
build |
StartTimeNotSupported |
Jika elemen <StartTime> ditentukan yang jenis kuotanya tidak
calendar , deployment proxy API akan gagal. Elemen <StartTime> merupakan
hanya didukung untuk jenis kuota calendar . Misalnya, jika atribut type ditetapkan
ke flexi atau rolling window dalam elemen <Quota> , lalu
deployment proxy API gagal.
|
build |
InvalidTimeUnitForDistributedQuota |
Jika elemen <Distributed> disetel ke true dan elemen <TimeUnit> disetel ke
second maka deployment proxy API akan gagal. Satuan waktu second tidak valid untuk
kuota terdistribusi. |
build |
InvalidSynchronizeIntervalForAsyncConfiguration |
Jika nilai yang ditentukan untuk elemen <SyncIntervalInSeconds> dalam
Elemen <AsynchronousConfiguration> dalam kebijakan Kuota kurang dari nol, maka
deployment proxy API gagal. |
build |
InvalidAsynchronizeConfigurationForSynchronousQuota |
Jika nilai elemen <AsynchronousConfiguration> disetel ke true dalam kebijakan Kuota, yang juga
memiliki konfigurasi asinkron yang ditentukan menggunakan elemen <AsynchronousConfiguration> , maka
deployment proxy API gagal. |
build |
Variabel kesalahan
Variabel ini ditetapkan saat kebijakan ini memicu error. Untuk informasi selengkapnya, lihat Yang perlu Anda ketahui tentang error kebijakan.
Variabel | Di mana | Contoh |
---|---|---|
fault.name="fault_name" |
fault_name adalah nama kesalahan, seperti yang tercantum dalam tabel Error runtime di atas. Nama kesalahan adalah bagian terakhir dari kode kesalahan. | fault.name Matches "QuotaViolation" |
ratelimit.policy_name.failed |
policy_name adalah nama kebijakan yang ditentukan pengguna yang menampilkan kesalahan. | ratelimit.QT-QuotaPolicy.failed = true |
Contoh respons error
{ "fault":{ "detail":{ "errorcode":"policies.ratelimit.QuotaViolation" }, "faultstring":"Rate limit quota violation. Quota limit exceeded. Identifier : _default" } }
Contoh aturan kesalahan
<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>
Skema
Topik terkait
Membandingkan Kebijakan Kuota, Lonjakan, dan Batas Kapasitas Serentak