Kebijakan LLMTokenQuota

Kebijakan yang dapat diperluas

Halaman ini berlaku untuk Apigee dan Apigee hybrid.

Lihat dokumentasi Apigee Edge.

Ringkasan

Kebijakan LLMTokenQuota dirancang untuk mengelola dan mengontrol penggunaan token untuk workload AI/LLM. Karena interaksi Model Bahasa Besar (LLM) berbasis token, pengelolaan yang efektif sangat penting untuk mengontrol biaya, mengoptimalkan performa, dan menjaga stabilitas platform.

Kuota adalah alokasi token LLM (Input atau Output) yang diizinkan untuk digunakan oleh proxy API selama periode waktu tertentu, seperti menit, jam, hari, minggu, atau bulan. Kebijakan LLMTokenQuota mengelola penghitung yang mencatat jumlah token yang digunakan oleh proxy API. Kemampuan ini memungkinkan penyedia API menerapkan batasan pada penggunaan token oleh aplikasi selama interval waktu tertentu.

Kebijakan ini menggunakan elemen <LLMTokenUsageSource> dan <LLMModelSource> untuk mengekstrak jumlah token dari respons LLM, dan nama model dari permintaan atau respons, sehingga memungkinkan pemberlakuan kuota yang presisi dan real-time.

Kebijakan ini adalah Kebijakan yang dapat diperluas dan penggunaan kebijakan ini mungkin memiliki implikasi biaya atau penggunaan, bergantung pada lisensi Apigee Anda. Untuk mengetahui informasi tentang jenis kebijakan dan implikasi penggunaan, lihat Jenis kebijakan.

Cara kerja penerapan LLMTokenQuota

Berikut adalah deskripsi fungsi kebijakan LLMTokenQuota:

  • Penghitungan Token (<CountOnly>): Kebijakan LLMTokenQuota mengelola penghitung yang melacak jumlah token yang digunakan oleh respons LLM yang melewati proxy API.
  • Menerapkan Batas (<EnforceOnly>): Kemampuan ini memungkinkan penyedia API menetapkan batas ketat pada jumlah token yang digunakan oleh aplikasi selama interval yang ditentukan. Misalnya, Anda dapat membatasi aplikasi hingga 1.000 token per menit atau 10.000.000 token per bulan.
  • Kelebihan Kuota: Saat proxy API mencapai batas kuota token yang ditentukan, Apigee akan menolak permintaan berikutnya yang menggunakan token. Pesan error akan ditampilkan hingga penghitung LLMTokenQuota otomatis direset di akhir interval waktu yang ditentukan. Misalnya, jika kuota ditetapkan sebesar 10.000 token per bulan, pembatasan token akan dimulai setelah token ke-10.000 dihitung, terlepas dari kapan batas tersebut tercapai dalam bulan tersebut.

Cara kerja LLMTokenQuota dengan produk API

Berikut ini menjelaskan cara kerja kebijakan LLMTokenQuota dengan produk API:

Alur proxy untuk LLMTokenQuota
  1. Terapkan kebijakan VerifyAPIKey atau VerifyAccessToken bersama dengan kebijakan terkait Proses Penegakan Kebijakan LLMTokenQuota dalam permintaan Proxy API (Proxy atau Target tidak masalah).
  2. Terapkan kebijakan penghitungan LLMTokenQuota sebagai respons terhadap Proxy API (Proxy atau Target tidak menjadi masalah).
  3. Kebijakan VerifyAPIKey atau VerifyAccessToken mencocokkan kunci atau token dengan produk API, set operasi, developer, dan aplikasi. Kebijakan ini mengekspos variabel alur untuk kuota LLM bagi semua model dari set operasi LLM yang cocok.
  4. Dalam kebijakan terkait Proses Penegakan Kebijakan kuota, kita mengekstrak model sesuai dengan template pesan yang diberikan.
  5. Kemudian, variabel kuota LLM dicocokkan untuk model tersebut. Jika kecocokan ditemukan, referensi akan dimasukkan.
  6. Setelah referensi dimasukkan, nilai tersebut digunakan untuk menjalankan operasi kuota.

Cara kerja LLMTokenQuota dengan respons SSE

Agar LLMTokenQuota berfungsi dengan respons SSE, tambahkan kebijakan sebagai bagian dari alur peristiwa seperti yang ditunjukkan di bawah:

<EventFlow content-type="text/event-stream">
    <Response>
      <Step>
        <Name>LLM_TOKEN_QUOTA_COUNT_POLICY_NAME</Name>
      </Step>
    </Response>
  </EventFlow>

Saat memproses aliran peristiwa, penghitungan token hanya dijalankan saat metadata penggunaan token dari respons LLM ditemukan dalam peristiwa. Saat metadata penggunaan token ditemukan, metadata tersebut akan diekstrak dan kebijakan akan dijalankan. Untuk semua peristiwa lainnya, kebijakan menghasilkan NO-OP.

Jenis kebijakan LLMTokenQuota

Kebijakan LLMTokenQuota mendukung beberapa cara berbeda untuk memulai dan mereset penghitung kuota. Anda dapat menentukan mana yang akan digunakan dengan atribut type pada elemen <LLMTokenQuota>, seperti yang ditunjukkan contoh berikut:

<LLMTokenQuota name="LLMTokenQuotaPolicy" type="calendar">
  ...
</LLMTokenQuota>

Nilai type yang valid mencakup:

  • calendar: Mengonfigurasi kuota berdasarkan waktu mulai yang eksplisit. Penghitung LLMTokenQuota untuk setiap aplikasi diperbarui berdasarkan nilai <StartTime>, <Interval>, dan <TimeUnit> yang Anda tetapkan.
  • rollingwindow: Mengonfigurasi kuota yang menggunakan periode berjalan untuk menentukan penggunaan kuota. Dengan rollingwindow, Anda menentukan ukuran periode dengan elemen <Interval> dan <TimeUnit>; misalnya, 1 hari. Saat permintaan masuk, Apigee akan melihat waktu persis permintaan (misalnya 17.01), menghitung jumlah token yang digunakan antara waktu tersebut dan 17.01 pada hari sebelumnya (1 hari), dan menentukan apakah kuota telah terlampaui atau tidak selama periode tersebut.
  • flexi: Mengonfigurasi kuota yang menyebabkan penghitung dimulai saat pesan permintaan pertama diterima dari aplikasi, dan direset berdasarkan nilai <Interval> dan <TimeUnit>.

Tabel berikut menjelaskan kapan kuota direset untuk setiap jenis:

Satuan Waktu Jenis
default (atau null) calendar flexi
menit Awal menit berikutnya Satu menit setelah <StartTime> Satu menit setelah permintaan pertama
jam Awal jam berikutnya Satu jam setelah <StartTime> Satu jam setelah permintaan pertama
hari Tengah malam GMT pada hari ini 24 jam setelah <StartTime> 24 jam setelah permintaan pertama
minggu Tengah malam GMT pada hari Minggu di akhir minggu Satu minggu setelah <StartTime> Satu minggu setelah permintaan pertama
bulan Tengah malam GMT pada hari terakhir setiap bulan Satu bulan (28 hari) setelah <StartTime> Satu bulan (28 hari) setelah permintaan pertama

Untuk type="calendar", Anda harus menentukan nilai <StartTime>.

Tabel ini tidak menjelaskan kapan jumlah direset untuk jenis rollingwindow. Hal ini karena kuota periode berjalan berfungsi sedikit berbeda, berdasarkan periode lihat kembali, seperti satu jam atau satu hari. Untuk jenis rollingwindow, penghitung tidak pernah direset, tetapi dihitung ulang pada setiap permintaan. Saat permintaan baru masuk, kebijakan akan menentukan apakah kuota telah terlampaui dalam jangka waktu sebelumnya.

Misalnya, Anda menentukan periode dua jam yang mengizinkan 1.000 token. Permintaan baru masuk pada pukul 16.45. Kebijakan ini menghitung jumlah kuota untuk periode dua jam terakhir, yang berarti jumlah token yang digunakan sejak pukul 14.45. Jika batas kuota belum terlampaui dalam periode dua jam tersebut, permintaan akan diizinkan.

Satu menit kemudian, pada pukul 16.46, permintaan lain masuk. Sekarang, kebijakan menghitung jumlah kuota sejak pukul 14.46 untuk menentukan apakah batas telah terlampaui.

Memahami penghitung kuota

Saat kebijakan LLMTokenQuota dijalankan dalam alur proxy API, penghitung kuota akan bertambah. Saat penghitung mencapai batasnya, tidak ada lagi panggilan API yang terkait dengan penghitung tersebut yang diizinkan. Bergantung pada konfigurasi yang Anda gunakan untuk Produk API, kebijakan LLMTokenQuota dapat menggunakan satu penghitung, atau beberapa penghitung independen. Penting untuk memahami skenario penggunaan beberapa penghitung, dan cara kerjanya.

Mengonfigurasi setelan kuota untuk produk API

Produk API dapat menentukan setelan kuota di tingkat produk atau di tingkat operasi individual, atau keduanya. Jika proxy API Anda disertakan dalam produk API, Anda dapat mengonfigurasi kebijakan LLMTokenQuota untuk menggunakan setelan kuota (jumlah yang diizinkan, unit waktu, dan interval) yang ditentukan dalam produk tersebut. Cara termudah untuk melakukannya adalah melalui elemen useQuotaConfigInAPIProduct. Atau, Anda dapat mereferensikan setelan ini di kebijakan LLMTokenQuota melalui referensi variabel individual.

Cara Penghitungan Kuota

Secara default, Apigee mempertahankan penghitung kuota terpisah untuk setiap operasi yang ditentukan dalam produk API, dan aturan berikut diamati:

  • Jika suatu operasi memiliki kuota yang ditentukan, setelan kuota operasi tersebut akan lebih diutamakan daripada setelan kuota yang ditentukan di tingkat produk.
  • Jika operasi tidak memiliki kuota yang ditentukan, setelan kuota tingkat produk akan berlaku.
  • Jika produk API tidak menyertakan setelan kuota apa pun — baik di tingkat produk maupun operasi — setelan kuota untuk jumlah yang diizinkan, unit waktu, dan interval seperti yang ditentukan dalam kebijakan LLMTokenQuota berlaku.

Dalam semua kasus, Apigee mempertahankan penghitung kuota terpisah untuk setiap operasi yang ditentukan dalam produk API. Setiap panggilan API yang cocok dengan operasi akan meningkatkan penghitungnya.

Mengonfigurasi penghitung tingkat proxy API

Produk API dapat dikonfigurasi untuk mempertahankan jumlah kuota pada cakupan proxy API. Dalam kasus ini, konfigurasi kuota yang ditentukan di tingkat produk API digunakan bersama oleh semua operasi yang tidak memiliki kuota sendiri. Efek dari konfigurasi ini adalah membuat penghitung di tingkat proxy API untuk produk API ini.

Untuk mencapai konfigurasi ini, Anda harus menggunakan Apigee API/apiproducts untuk membuat atau memperbarui produk dan menetapkan atribut quotaCounterScope ke PROXY dalam permintaan pembuatan atau pembaruan. Dengan konfigurasi PROXY, permintaan yang cocok dengan salah satu operasi yang ditentukan untuk produk API yang terkait dengan proxy yang sama, dan tidak memiliki setelan kuotanya sendiri, akan berbagi penghitung kuota umum untuk proxy tersebut.

Pada Gambar 1, Operasi 1 dan 2 dikaitkan dengan Proxy1, sedangkan Operasi 4 dan 5 dikaitkan dengan Proxy3. Karena quotaCounterScope=PROXY ditetapkan di produk API, setiap operasi ini menggunakan setelan kuota tingkat produk API. Operasi 1 dan 2, yang terkait dengan Proxy1, menggunakan penghitung bersama, dan Operasi 4 dan 5, yang terkait dengan Proxy3, menggunakan penghitung bersama yang terpisah. Operasi 3 memiliki setelan konfigurasi kuotanya sendiri, dan karena itu menggunakan penghitungnya sendiri, terlepas dari nilai atribut quotaCounterScope.

Gambar 1: Penggunaan flag quotaCounterScope

Cara penghitungan kuota jika tidak ada produk API yang digunakan

Jika tidak ada produk API yang terkait dengan proxy API, kebijakan LLMTokenQuota akan mempertahankan satu penghitung, terlepas dari berapa kali Anda mereferensikannya dalam proxy API. Nama penghitung kuota didasarkan pada atribut name kebijakan.

Misalnya, Anda membuat kebijakan LLMTokenQuota bernama MyLLMTokenQuotaPolicy dengan batas 5 token dan menempatkannya di beberapa alur (Alur A, B, dan C) di proxy API. Meskipun digunakan dalam beberapa alur, kebijakan ini mempertahankan satu penghitung yang diperbarui oleh semua instance kebijakan. Dengan asumsi respons LLM menggunakan 1 token setiap kali:

  • Alur A dieksekusi -> MyLLMTokenQuotaPolicy dieksekusi dan counternya = 1
  • Alur B dieksekusi -> MyLLMTokenQuotaPolicy dieksekusi dan counternya = 2
  • Alur A dijalankan -> MyLLMTokenQuotaPolicy dijalankan dan penghitungnya = 3
  • Alur C dieksekusi -> MyLLMTokenQuotaPolicy dieksekusi dan penghitungnya = 4
  • Alur A dieksekusi -> MyLLMTokenQuotaPolicy dieksekusi dan counternya = 5

Permintaan berikutnya ke salah satu dari tiga alur ditolak karena penghitung kuota telah mencapai batasnya.

Menggunakan kebijakan LLMTokenQuota yang sama di lebih dari satu tempat dalam alur proxy API, yang dapat secara tidak sengaja menyebabkan LLMTokenQuota habis lebih cepat dari yang Anda harapkan, adalah antipola yang dijelaskan dalam Pengantar antipola.

Atau, Anda dapat menentukan beberapa kebijakan LLMTokenQuota di proxy API dan menggunakan kebijakan yang berbeda di setiap alur. Setiap kebijakan LLMTokenQuota mengelola penghitungnya sendiri, berdasarkan atribut name kebijakan.

Membuat beberapa penghitung melalui konfigurasi kebijakan

Anda dapat menggunakan elemen <Class> atau <Identifier> dalam kebijakan LLMTokenQuota untuk menentukan beberapa penghitung unik dalam satu kebijakan. Dengan menggunakan elemen-elemen ini, satu kebijakan dapat mempertahankan penghitung yang berbeda berdasarkan aplikasi yang membuat permintaan, developer aplikasi yang membuat permintaan, client ID atau ID klien lainnya, dan banyak lagi. Lihat contoh di atas untuk mengetahui informasi selengkapnya tentang cara menggunakan elemen <Class> atau <Identifier>.

Notasi waktu

Semua waktu LLMTokenQuota ditetapkan ke zona waktu Coordinated Universal Time (UTC).

Notasi waktu LLMTokenQuota mengikuti notasi tanggal standar internasional yang ditentukan dalam Standar Internasional ISO 8601.

Tanggal ditentukan sebagai tahun, bulan, dan hari, dalam format berikut: YYYY-MM-DD. Misalnya, 2025-02-04 mewakili 4 Februari 2025.

Waktu dalam sehari ditentukan sebagai jam, menit, dan detik dalam format berikut: hours:minutes:seconds. Misalnya, 23:59:59 mewakili waktu satu 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, 2025-02-04 24:00:00 memiliki tanggal dan waktu yang sama dengan 2025-02-05 00:00:00. Notasi yang terakhir biasanya lebih disukai.

Mendapatkan setelan kuota dari konfigurasi produk API

Anda dapat menetapkan batas kuota dalam konfigurasi produk API. Batas tersebut tidak otomatis menerapkan kuota. Sebagai gantinya, Anda dapat mereferensikan setelan kuota produk dalam kebijakan LLMTokenQuota. Berikut adalah beberapa keuntungan menetapkan kuota pada produk untuk dijadikan referensi oleh kebijakan LLMTokenQuota:

  • Kebijakan LLMTokenQuota dapat menggunakan setelan yang seragam di semua proxy API dalam produk API.
  • Anda dapat membuat perubahan runtime pada setelan kuota di produk API, dan kebijakan LLMTokenQuota yang mereferensikan nilai tersebut akan otomatis memiliki nilai kuota yang diperbarui.

Untuk mengetahui informasi selengkapnya tentang penggunaan setelan kuota dari produk API, lihat contoh Kuota Dinamis.

Untuk mengetahui info tentang cara mengonfigurasi produk API dengan batas kuota, lihat Mengelola produk API.

Mengonfigurasi penghitung kuota bersama

Dalam kasus sederhana, kebijakan LLMTokenQuota menambah penghitungnya satu kali untuk setiap token yang dikirim ke proxy API, selama pemrosesan permintaan awal. Dalam beberapa kasus, Anda mungkin ingin memeriksa apakah kuota terlampaui saat penanganan awal permintaan yang masuk, tetapi menambah penghitung hanya selama penanganan respons.

Tiga elemen kebijakan LLMTokenQuota—<SharedName>, <CountOnly>, dan <EnforceOnly>—jika digunakan bersama, memungkinkan Anda menyesuaikan kebijakan LLMTokenQuota untuk menerapkan kuota pada permintaan yang masuk, tetapi hanya menambah penghitung dalam alur respons.

Misalnya, Anda memiliki proxy API yang menggunakan LLM sebagai target, dan Anda ingin menerapkan kuota 100.000 token per jam. Respons LLM memberikan nilai totalTokenCount. Untuk melakukannya, lakukan hal berikut:

  • Lampirkan kebijakan LLMTokenQuota ke alur Permintaan ProxyEndpoint dengan elemen <SharedName> yang ditetapkan dengan nilai nama dan elemen <EnforceOnly> yang ditetapkan ke true.
  • Gunakan elemen <LLMTokenUsageSource> dalam kebijakan LLMTokenQuota untuk mengambil jumlah token

Untuk contoh yang menunjukkan cara menggunakan penghitung bersama, lihat Penghitung bersama di bagian Contoh.

Sampel

Contoh kode kebijakan ini menggambarkan cara memulai dan mengakhiri periode kuota dengan:

Lebih banyak Dynamic LLMTokenQuota

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

Kuota dinamis memungkinkan Anda mengonfigurasi satu kebijakan LLMTokenQuota yang menerapkan setelan kuota yang berbeda berdasarkan informasi yang diteruskan ke kebijakan LLMTokenQuota. Istilah lain untuk setelan LLMTokenQuota dalam konteks ini adalah paket layanan. LLMTokenQuota dinamis memeriksa paket layanan aplikasi, lalu menerapkan setelan tersebut.

Misalnya, saat membuat produk API, Anda dapat menetapkan batas kuota, unit waktu, dan interval yang diizinkan. Namun, menyetel nilai ini pada produk API tidak mewajibkan penggunaannya di proxy API. Anda juga harus menambahkan kebijakan LLMTokenQuota ke proxy API yang membaca nilai ini. Lihat Membuat produk API untuk mengetahui informasi selengkapnya.

Dalam contoh di atas, proxy API yang berisi kebijakan LLMTokenQuota menggunakan kebijakan VerifyAPIKey, yang bernama verify-api-key, untuk memvalidasi kunci API yang diteruskan dalam permintaan. Kebijakan LLMTokenQuota kemudian mengakses flow variable dari kebijakan VerifyAPIKey untuk membaca nilai kuota yang ditetapkan pada produk API.

Opsi lainnya adalah menetapkan atribut kustom pada masing-masing developer atau aplikasi, lalu membaca nilai tersebut dalam kebijakan LLMTokenQuota. Misalnya, untuk menetapkan nilai kuota yang berbeda per developer, Anda menetapkan atribut kustom pada developer yang berisi batas, unit waktu, dan interval. Kemudian, Anda mereferensikan nilai ini dalam kebijakan LLMTokenQuota seperti yang ditunjukkan di bawah:

<LLMTokenQuota name="DeveloperLLMTokenQuota">
  <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"/>
</LLMTokenQuota>

Contoh ini juga menggunakan flow variable VerifyAPIKey untuk mereferensikan atribut kustom yang ditetapkan pada developer.

Anda dapat menggunakan variabel apa pun untuk menetapkan parameter kebijakan LLMTokenQuota. Variabel tersebut dapat berasal dari:

  • Variabel alur
  • Properti di produk API, aplikasi, atau developer
  • Peta nilai kunci (KVM)
  • Header, parameter kueri, parameter formulir, dan lainnya

Untuk setiap proxy API, Anda dapat menambahkan kebijakan LLMTokenQuota yang mereferensikan variabel yang sama dengan semua kebijakan LLMTokenQuota lainnya di semua proxy lainnya, atau kebijakan LLMTokenQuota dapat mereferensikan variabel unik untuk kebijakan dan proxy tersebut.

Waktu mulai

<LLMTokenQuota name="LLMTokenQuotaPolicy" type="calendar">
  <StartTime>2025-02-18 10:30:00</StartTime>
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</LLMTokenQuota>

Untuk LLMTokenQuota dengan type yang ditetapkan ke calendar, Anda harus menentukan nilai <StartTime> eksplisit. Nilai waktu adalah waktu GMT, bukan waktu lokal. Jika Anda tidak memberikan nilai <StartTime> untuk kebijakan jenis calendar, Apigee akan menampilkan error.

Penghitung LLMTokenQuota untuk setiap aplikasi diperbarui berdasarkan nilai <StartTime>, <Interval>, dan <TimeUnit>. Untuk contoh ini, LLMTokenQuota mulai menghitung pada 18 Februari 2025 pukul 10.30 GMT, dan diperbarui setiap 5 jam. Oleh karena itu, pembaruan berikutnya akan dilakukan pada 18 Februari 2025 pukul 15.30 GMT.

Penghitung Akses

<LLMTokenQuota name="LLMTokenQuotaPolicy">
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</LLMTokenQuota>

Proxy API memiliki akses ke variabel flow yang ditetapkan oleh kebijakan LLMTokenQuota. Anda dapat mengakses flow variable ini di Proxy API untuk melakukan pemrosesan bersyarat, memantau kebijakan saat mendekati batas kuota, menampilkan penghitung kuota saat ini ke aplikasi, atau untuk alasan lainnya.

Karena akses variabel alur untuk kebijakan didasarkan pada atribut name kebijakan, untuk kebijakan di atas yang bernama <LLMTokenQuota>, Anda mengakses variabel alurnya dalam bentuk:

  • ratelimit.LLMTokenQuotaPolicy.allowed.count: Jumlah yang diizinkan.
  • ratelimit.LLMTokenQuotaPolicy.used.count: Nilai penghitung saat ini.
  • ratelimit.LLMTokenQuotaPolicy.expiry.time: Waktu UTC saat penghitung direset.

Ada banyak variabel alur lainnya yang dapat Anda akses, seperti yang dijelaskan di bawah.

Misalnya, Anda dapat menggunakan kebijakan AssignMessage berikut untuk menampilkan nilai flow variable LLMTokenQuota sebagai header respons:

<AssignMessage continueOnError="false" enabled="true" name="ReturnQuotaVars">
  <AssignTo createNew="false" type="response"/>
  <Set>
    <Headers>
      <Header name="LLMTokenQuotaLimit">{ratelimit.LLMTokenQuotaPolicy.allowed.count}</Header>
      <Header name="LLMTokenQuotaUsed">{ratelimit.LLMTokenQuotaPolicy.used.count}</Header>
      <Header name="LLMTokenQuotaResetUTC">{ratelimit.LLMTokenQuotaPolicy.expiry.time}</Header>
    </Headers>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

Penghitung bersama

Contoh berikut menggambarkan cara mengonfigurasi penghitung bersama untuk proxy API, dengan penghitung kuota juga bertambah saat respons target adalah status HTTP 200. Karena kedua kebijakan LLMTokenQuota menggunakan nilai <SharedName> yang sama, kedua kebijakan LLMTokenQuota akan menggunakan penghitung kuota yang sama. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi penghitung kuota bersama.

Contoh konfigurasi ProxyEndpoint: 

<ProxyEndpoint name="default">
  <PreFlow name="PreFlow">
    <Request>
      <Step>
        <Name>LLMTokenQuota-Enforce-Only</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Name>LLMTokenQuota-Count-Only</Name>
      </Step>
    </Response>
    <Response/>
  </PreFlow>
  <Flows/>
  <PostFlow name="PostFlow">
    <Request/>
    <Response/>
  </PostFlow>
  <HTTPProxyConnection>
    <BasePath>/quota-shared-name</BasePath>
  </HTTPProxyConnection>
  <RouteRule name="noroute"/>
</ProxyEndpoint>

Contoh kebijakan LLMTokenQuota pertama:

<LLMTokenQuota name="LLMTokenQuota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
</LLMTokenQuota>

Contoh kebijakan LLMTokenQuota kedua:

<LLMTokenQuota name="LLMTokenQuota-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>  <!-- Same name as the first LLMTokenQuota policy -->
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

Permintaan Pertama

<LLMTokenQuota name="MyLLMTokenQuota">
  <Interval>1</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="10000"/>
</LLMTokenQuota>

Gunakan kode contoh ini untuk menerapkan kuota 10.000 token per satu jam. Kebijakan ini mereset penghitung kuota di awal setiap jam. Jika penghitung mencapai kuota 10.000 token sebelum akhir jam, panggilan API yang menggunakan token melebihi 10.000 akan ditolak.

Misalnya, jika penghitung dimulai pada pukul 2025-07-08 07:00:00, penghitung akan direset ke 0 pada pukul 2025-07-08 08:00:00 (1 jam dari waktu mulai). Jika permintaan pertama diterima pada pukul 2025-07-08 07:35:28 dan jumlah token mencapai 10.000 sebelum pukul 2025-07-08 08:00:00, permintaan yang menggunakan token melebihi jumlah tersebut akan ditolak hingga jumlahnya direset pada awal jam.

Waktu reset penghitung didasarkan pada kombinasi <Interval> dan <TimeUnit>. Misalnya, jika Anda menetapkan <Interval> ke 12 untuk <TimeUnit> jam, penghitung akan direset setiap dua belas jam. Anda dapat menetapkan <TimeUnit> ke menit, jam, hari, minggu, atau bulan.

Anda dapat mereferensikan kebijakan ini di beberapa tempat dalam proxy API. Misalnya, Anda dapat menempatkannya di Proxy PreFlow sehingga dijalankan pada setiap permintaan. Atau, Anda dapat menempatkannya di beberapa alur dalam proxy API. Jika Anda menggunakan kebijakan ini di beberapa tempat di proxy, kebijakan ini akan mempertahankan satu penghitung yang diperbarui oleh semua instance kebijakan.

Atau, Anda dapat menentukan beberapa kebijakan LLMTokenQuota di proxy API Anda. Setiap kebijakan LLMTokenQuota mengelola penghitungnya sendiri, berdasarkan atribut name kebijakan.

Menetapkan ID

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

Secara default, kebijakan LLMTokenQuota menentukan satu penghitung untuk proxy API, terlepas dari asal permintaan. Atau, Anda dapat menggunakan atribut <Identifier> dengan kebijakan LLMTokenQuota untuk mempertahankan penghitung terpisah berdasarkan nilai atribut <Identifier>.

Misalnya, gunakan tag <Identifier> untuk menentukan penghitung terpisah untuk setiap client ID. Saat permintaan dikirim ke proxy Anda, aplikasi klien akan meneruskan header yang berisi clientID, seperti yang ditunjukkan dalam contoh di atas.

Anda dapat menentukan variabel alur apa pun ke atribut <Identifier>. Misalnya, Anda dapat menentukan bahwa parameter kueri bernama id berisi ID unik:

<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 kunci API atau token untuk menentukan penghitung individual untuk kebijakan LLMTokenQuota yang sama. Misalnya, elemen <Identifier> berikut 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 yang unik kini menentukan penghitungnya sendiri dalam kebijakan LLMTokenQuota.

Class

<LLMTokenQuota name="LLMTokenQuotaPolicy">
  <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>
</LLMTokenQuota>

Anda dapat menetapkan batas LLMTokenQuota secara dinamis menggunakan jumlah LLMTokenQuota berbasis class. Dalam contoh ini, batas kuota ditentukan oleh nilai header developer_segment yang diteruskan dengan setiap permintaan. Variabel tersebut dapat memiliki nilai platinum atau silver. Jika header memiliki nilai yang tidak valid, kebijakan akan menampilkan error pelanggaran kuota.

Contoh berikut mengilustrasikan berbagai konfigurasi kebijakan LLMTokenQuota.

Menghitung Token

Contoh ini menunjukkan cara menghitung token.

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

Menghitung Variabel Dinamis Kuota menggunakan Produk API, Developer, dan Aplikasi

Contoh ini menunjukkan cara menghitung variabel dinamis kuota menggunakan Produk API, Developer, dan Aplikasi.

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
<Interval ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.limit"/>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

Menerapkan Kuota tanpa Produk API

Contoh ini menunjukkan cara menerapkan kuota tanpa Produk API.

<LLMTokenQuota name="Quota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
</LLMTokenQuota>

Menerapkan Kuota dengan Produk API, Developer, dan Aplikasi

Contoh ini menunjukkan cara menerapkan kuota dengan Produk API, Developer, dan Aplikasi.

<LLMTokenQuota name="Quota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
<Interval ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.limit"/>
  <Distributed>true</Distributed>
</LLMTokenQuota>

Dengan streaming SSE

Contoh ini menunjukkan cara menggunakan LLMTokenQuota dengan streaming SSE.

Kebijakan penghitungan Kuota Token:

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.event.current.data,false)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.modelVersion',response.event.current.data,false)}</LLMModelSource>
</LLMTokenQuota>

Alur Peristiwa:

<EventFlow content-type="text/event-stream">
    <Response>
      <Step>
        <Name>LTQ-Count-Only</Name>
      </Step>
    </Response>
  </EventFlow>

Elemen <LLMTokenQuota>

Berikut adalah atribut dan elemen turunan <LLMTokenQuota>. Perhatikan bahwa beberapa kombinasi elemen tidak kompatibel atau tidak diperlukan. Lihat contoh untuk penggunaan tertentu.

Variabel verifyapikey.my-verify-key-policy.apiproduct.* di bawah tersedia secara default saat kebijakan VerifyAPIKey yang disebut my-verify-key-policy digunakan untuk memeriksa kunci API aplikasi dalam permintaan. Nilai variabel berasal dari setelan kuota pada produk API yang terkait dengan kunci, seperti yang dijelaskan dalam Mendapatkan setelan kuota dari konfigurasi produk API.

<LLMTokenQuota continueOnError="false" enabled="true" name="LTQ-TokenQuota-1" type="calendar">
  <DisplayName>Quota 3</DisplayName>
  <LLMTokenUsageSource>{jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}</LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',request.content,true)}</LLMModelSource>
  <Allow count="UPPER_REQUEST_LIMIT"
      countRef="verifyapikey.my-verify-key-policy.apiproduct.developer.llmQuota.limit"/>
  <Allow>
    <Class ref="request.queryparam.time_variable">
      <Allow class="peak_time" count="UPPER_LIMIT_DURING_PEAK"/>
      <Allow class="off_peak_time" count="UPPER_LIMIT_DURING_OFFPEAK"/>
    </Class>
  </Allow>
  <Interval ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmQuota.interval">
    1
  </Interval>
  <TimeUnit ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmQuota.timeunit">
    month
  </TimeUnit>
  <StartTime>2025-7-16 12:00:00</StartTime>
  <Distributed>false</Distributed>
  <Synchronous>false</Synchronous>
  <AsynchronousConfiguration>
    <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
    <SyncMessageCount>5</SyncMessageCount>
  </AsynchronousConfiguration>
  <Identifier/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <UseQuotaConfigInAPIProduct>
    <DefaultConfig>
      <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.my-verify-key-policy.apiproduct.developer.llmQuota.interval">
        1
      </Interval>
      <TimeUnit ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmQuota.timeunit">
        month
      </TimeUnit>
    </DefaultConfig>
  </UseQuotaConfigInAPIProduct>
  <SharedName/>
  <EnforceOnly>true</EnforceOnly>
</LLMTokenQuota>

Atribut berikut bersifat spesifik untuk kebijakan ini:

Atribut Deskripsi Default Kehadiran
type

Menetapkan jenis kebijakan LLMTokenQuota, yang menentukan kapan dan bagaimana penghitung kuota memeriksa penggunaan kuota serta cara meresetnya.

Jika Anda tidak menyetel type, penghitung akan dimulai di awal menit/jam/hari/minggu/bulan.

Nilai yang valid mencakup:

  • calendar
  • rollingwindow
  • flexi

Untuk deskripsi lengkap setiap jenis, lihat Jenis kebijakan LLMTokenQuota.

 T/A Opsional

Tabel berikut menjelaskan atribut yang umum untuk semua elemen induk kebijakan:

Atribut Deskripsi Default Kehadiran
name

Nama internal kebijakan. Nilai atribut name dapat berisi huruf, angka, spasi, tanda hubung, garis bawah, dan titik. Nilai ini tidak boleh melebihi 255 karakter.

Secara opsional, gunakan elemen <DisplayName> untuk memberi label pada kebijakan di editor proxy UI pengelolaan dengan nama bahasa alami yang berbeda.

 T/A Wajib
continueOnError

Tetapkan ke false untuk menampilkan error saat kebijakan gagal. Perilaku ini wajar terjadi untuk sebagian besar kebijakan.

Tetapkan ke true agar eksekusi alur berlanjut meskipun setelah kebijakan gagal. Lihat juga:

 false Opsional
enabled

Tetapkan ke true untuk menerapkan kebijakan.

Tetapkan ke false untuk menonaktifkan kebijakan. Kebijakan tidak akan diterapkan meskipun tetap terlampir ke alur.

 benar Opsional
async

Atribut ini tidak digunakan lagi.

 false Tidak digunakan lagi

Elemen <DisplayName>

Gunakan selain atribut name untuk melabeli kebijakan di editor proxy UI pengelolaan dengan nama bahasa alami yang berbeda.

<DisplayName>Policy Display Name</DisplayName>
Default

T/A

Jika Anda menghapus elemen ini, nilai atribut name kebijakan akan digunakan.
Kehadiran Opsional
Jenis String

<Allow>

Menentukan jumlah total token yang diizinkan untuk interval waktu yang ditentukan. Jika penghitung untuk kebijakan mencapai nilai batas ini, panggilan API berikutnya akan ditolak hingga penghitung direset.

Dapat juga berisi elemen <Class> yang mengondisikan elemen <Allow> berdasarkan variabel alur.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis Integer atau Complex
Elemen Induk <LLMTokenQuota>
Elemen Turunan <Class>

Di bawah ini adalah tiga cara untuk menyetel elemen <Allow>:

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

Jika Anda menentukan count dan countRef, countRef akan diprioritaskan. Jika countRef tidak di-resolve saat runtime, nilai count akan digunakan.

Anda juga dapat menentukan elemen <Class> sebagai turunan <Allow> untuk menentukan jumlah kebijakan yang diizinkan berdasarkan flow variable. Apigee mencocokkan nilai flow variable dengan atribut class dari elemen <Allow>, seperti yang ditunjukkan di bawah:

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

Tabel berikut mencantumkan atribut <Allow>:

Atribut Deskripsi Default Kehadiran
count

Gunakan untuk menentukan jumlah token untuk kuota.

Misalnya, nilai atribut count sebesar 100, Interval sebesar 1, dan TimeUnit sebesar bulan menentukan kuota 100 token per bulan.

 2000 Opsional
countRef

Gunakan untuk menentukan flow variable yang berisi jumlah token untuk kuota. countRef lebih diprioritaskan daripada atribut count.

 tidak ada Opsional

<Class>

Memungkinkan Anda mengondisikan nilai elemen <Allow> berdasarkan nilai variabel flow. Untuk setiap tag turunan <Allow> yang berbeda dari <Class>, kebijakan akan mempertahankan penghitung yang berbeda.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis kompleks
Elemen Induk <Allow>
Elemen Turunan <Allow> (turunan <Class>)

Untuk menggunakan elemen <Class>, tentukan variabel flow menggunakan atribut ref ke elemen <Class>. Apigee kemudian menggunakan nilai flow variable untuk memilih salah satu elemen turunan <Allow> guna menentukan jumlah kebijakan yang diizinkan. Apigee mencocokkan nilai flow variable dengan atribut class dari elemen <Allow>, seperti yang ditunjukkan di bawah:

<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 yang diteruskan dengan setiap permintaan. Variabel tersebut dapat memiliki nilai peak_time atau off_peak_time. Jika parameter kueri berisi nilai yang tidak valid, kebijakan akan menampilkan error pelanggaran kuota.

Tabel berikut mencantumkan atribut <Class>:

Atribut Deskripsi Default Kehadiran
ref Gunakan untuk menentukan flow variable yang berisi class kuota untuk kuota. tidak ada Wajib

<Allow> (turunan dari <Class>)

Menentukan batas untuk penghitung kuota yang ditentukan oleh elemen <Class>. Untuk setiap tag anak <Allow> yang berbeda dari <Class>, kebijakan mempertahankan penghitung yang berbeda.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis kompleks
Elemen Induk <Class>
Elemen Turunan Tidak ada

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 LLMTokenQuota mengelola dua penghitung kuota bernama peak_time dan off_peak_time. Mana yang digunakan bergantung pada parameter kueri yang diteruskan, seperti yang ditunjukkan dalam contoh <Class>.

Tabel berikut mencantumkan atribut <Allow>:

Atribut Deskripsi Default Kehadiran
class Menentukan nama penghitung kuota. tidak ada Wajib
count Menentukan batas kuota untuk penghitung. tidak ada Wajib

<IgnoreUnresolvedVariables>

Menentukan apakah pemrosesan kebijakan LLMTokenQuota berhenti jika Apigee tidak dapat menyelesaikan variabel yang dirujuk oleh atribut ref dalam kebijakan.

Nilai Default false
Wajib? Opsional
Jenis Boolean
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Tetapkan ke true untuk mengabaikan variabel yang belum terselesaikan dan melanjutkan pemrosesan; jika tidak, false. Nilai defaultnya adalah false.

Jika <IgnoreUnresolvedVariables> disetel ke true, dan variabel yang ditentukan dalam atribut ref tidak dapat diselesaikan, Apigee akan mengabaikan atribut ref. Jika elemen yang berisi atribut ref juga berisi nilai, seperti <Allow count="2000"/>, maka Apigee akan menggunakan nilai tersebut. Jika tidak ada nilai, Apigee akan memperlakukan nilai elemen sebagai null dan mengganti nilai default, jika ada, atau string kosong.

Jika <IgnoreUnresolvedVariables> adalah false, dan variabel yang ditentukan dalam atribut ref tidak dapat diselesaikan, Apigee akan menampilkan error.

<Interval>

Menentukan jumlah jangka waktu saat kuota dihitung.

Nilai Default T/A
Wajib? Wajib
Jenis Bilangan bulat
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Gunakan untuk menentukan bilangan bulat (misalnya, 1, 2, 5, 60, dan seterusnya) yang akan dipasangkan dengan elemen <TimeUnit> yang Anda tentukan (menit, jam, hari, minggu, atau bulan) untuk menentukan jangka waktu saat Apigee menghitung penggunaan kuota.

Misalnya, interval 24 dengan <TimeUnit> hour berarti kuota akan dihitung selama 24 jam.

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

Tabel berikut mencantumkan atribut <Interval>:

Atribut Deskripsi Default Kehadiran
ref

Gunakan untuk menentukan flow variable yang berisi interval untuk kuota. ref lebih diprioritaskan daripada nilai interval eksplisit. Jika referensi dan nilai ditentukan, referensi akan diprioritaskan. Jika ref tidak diselesaikan saat runtime, nilai tersebut akan digunakan.

 tidak ada Opsional

<TimeUnit>

Menentukan unit waktu yang berlaku untuk kuota.

Nilai Default T/A
Wajib? Wajib
Jenis String
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Pilih dari minute, hour, day, week, month, atau year.

Misalnya, Interval 24 dengan TimeUnit hour berarti kuota akan dihitung selama 24 jam.

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

Tabel berikut mencantumkan atribut <TimeUnit>:

Atribut Deskripsi Default Kehadiran
ref Menentukan variabel alur yang berisi unit waktu untuk kuota. ref lebih diprioritaskan daripada nilai interval eksplisit. Jika ref tidak di-resolve saat runtime, nilai interval akan digunakan. tidak ada Opsional

<StartTime>

Jika type disetel ke calendar, tentukan tanggal dan waktu saat penghitung kuota mulai berjalan, terlepas dari apakah ada permintaan yang diterima dari aplikasi mana pun.

Nilai Default T/A
Wajib? Opsional (Wajib jika type disetel ke calendar)
Jenis String dalam format tanggal dan waktu ISO 8601
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Contoh:

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

<Distributed>

Menentukan apakah Apigee menggunakan satu atau beberapa node untuk memproses permintaan.

Nilai Default false
Wajib? Opsional
Jenis Boolean
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Tetapkan ke true untuk menentukan bahwa kebijakan harus mempertahankan penghitung pusat dan terus menyinkronkannya di semua node. Node dapat berada di seluruh zona ketersediaan dan/atau region.

Jika Anda menggunakan nilai default false, Anda mungkin melebihi kuota karena jumlah untuk setiap node tidak dibagikan:

<Distributed>false</Distributed>

Untuk menjamin bahwa penghitung disinkronkan, dan diperbarui pada setiap permintaan, tetapkan <Distributed> dan <Synchronous> ke true:

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

<Synchronous>

Menentukan apakah akan mengupdate penghitung kuota terdistribusi secara sinkron.

Nilai Default false
Wajib? Opsional
Jenis Boolean
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Tetapkan ke true untuk memperbarui penghitung kuota terdistribusi secara serentak. Artinya, pembaruan pada penghitung dilakukan bersamaan dengan pemeriksaan kuota pada permintaan ke API. Tetapkan ke true jika Anda benar-benar tidak ingin mengizinkan panggilan API apa pun yang melebihi kuota.

Setel ke false untuk memperbarui penghitung kuota secara asinkron. Artinya, beberapa panggilan API yang melebihi kuota mungkin akan berhasil, bergantung pada kapan penghitung kuota di repositori pusat diperbarui secara asinkron. Namun, Anda tidak akan menghadapi potensi dampak performa yang terkait dengan update sinkron.

Interval update asinkron default adalah 10 detik. Gunakan elemen <AsynchronousConfiguration> untuk mengonfigurasi perilaku asinkron ini.

<Synchronous>false</Synchronous>

<AsynchronousConfiguration>

Mengonfigurasi interval sinkronisasi di antara penghitung kuota terdistribusi saat elemen konfigurasi kebijakan <Synchronous> tidak ada atau ada dan ditetapkan ke false. Apigee mengabaikan elemen ini jika <Synchronous> ditetapkan ke true.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis kompleks
Elemen Induk <LLMTokenQuota>
Elemen Turunan <SyncIntervalInSeconds>
<SyncMessageCount>

Anda dapat menentukan perilaku sinkronisasi menggunakan elemen turunan <SyncIntervalInSeconds> atau <SyncMessageCount>. Gunakan salah satu atau kedua elemen. Misalnya,

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

atau

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>
  • Jika hanya ada <SyncIntervalInSeconds>, kuota akan disinkronkan setiap N detik, dengan N adalah nilai yang ditentukan dalam elemen, terlepas dari jumlah pesan yang telah ditangani.
  • Jika hanya <SyncMessageCount> yang ada, kuota disinkronkan setiap M pesan, dengan M adalah nilai yang ditentukan dalam elemen, atau setiap 10 detik, mana saja yang lebih dulu.
  • Jika kedua elemen ada, kuota akan disinkronkan setiap M pesan atau setiap N detik, mana saja yang lebih dulu tercapai.
  • Jika <AsynchronousConfiguration> tidak ada atau tidak ada elemen turunan, kuota disinkronkan setiap 10 detik, terlepas dari jumlah pesan yang telah ditangani.

<SyncIntervalInSeconds>

Mengganti perilaku default saat update asinkron dilakukan setelah interval 10 detik.

Nilai Default 10 detik
Wajib? Opsional
Jenis Bilangan bulat
Elemen Induk <AsynchronousConfiguration>
Elemen Turunan Tidak ada
 
<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
</AsynchronousConfiguration>

Interval sinkronisasi harus >= 10 detik, seperti yang dijelaskan dalam Batas.

<SyncMessageCount>

Menentukan jumlah permintaan yang akan diproses sebelum menyinkronkan penghitung kuota.

Nilai Default T/A
Wajib? Opsional
Jenis Bilangan bulat
Elemen Induk <AsynchronousConfiguration>
Elemen Turunan Tidak ada
 
<AsynchronousConfiguration>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>

Dengan menggunakan konfigurasi dalam contoh ini, di setiap node, jumlah kuota akan disinkronkan setelah setiap 5 permintaan, atau setiap 10 detik, mana saja yang lebih dulu.

<LLMTokenUsageSource>

Menyediakan sumber penggunaan token dari respons LLM. Nilai ini harus berupa template pesan yang di-resolve ke satu nilai penggunaan token. Jika kebijakan bukan bagian dari alur peristiwa dan tidak dapat mengekstrak jumlah token dari sumber yang ditentukan, kebijakan akan menampilkan error runtime policies.ratelimit.FailedToResolveTokenUsageCount.

Nilai Default {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
Wajib? Opsional
Jenis String
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Contoh berikut menunjukkan cara menentukan sumber penggunaan token:

<LLMTokenUsageSource>{jsonPath('$.usageMetadata.candidatesTokenCount', response.content, true)}</LLMTokenUsageSource>

Jika kebijakan adalah bagian dari pemrosesan alur peristiwa yang memproses aliran Server-Sent Events (SSE), penggunaan token akan diekstrak dari data peristiwa saat ini bukan dari konten respons lengkap. Gunakan response.event.current.data sebagai sumber dan tetapkan argumen ketiga fungsi jsonPath (want-array) ke false sehingga nilai penggunaan token tunggal ditampilkan, bukan array. Untuk mengetahui detail tentang argumen ini, lihat fungsi JSON Path. Contoh berikut menunjukkan konfigurasi SSE:

<LLMTokenUsageSource>{jsonPath('$.usageMetadata.candidatesTokenCount',response.event.current.data,false)}</LLMTokenUsageSource>

<LLMModelSource>

Menyediakan sumber nama model dari respons LLM atau permintaan LLM. Ini harus berupa template pesan yang memberikan satu nilai nama model.

Nilai Default {jsonPath('$.model',request.content,true)}
Wajib? Opsional
Jenis String
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Contoh berikut menunjukkan cara menentukan sumber model dari permintaan:

<LLMModelSource>{jsonPath('$.model', request.content, true)}</LLMModelSource>

Jika kebijakan ini merupakan bagian dari alur peristiwa yang memproses aliran data Server-Sent Events (SSE), nama model akan diekstrak dari data peristiwa saat ini, bukan dari konten respons lengkap. Gunakan response.event.current.data sebagai sumber dan tetapkan argumen ketiga fungsi jsonPath (want-array) ke false sehingga nilai nama model tunggal ditampilkan, bukan array. Untuk mengetahui detail tentang argumen ini, lihat fungsi JSON Path. Contoh berikut menunjukkan konfigurasi SSE:

<LLMModelSource>{jsonPath('$.modelVersion',response.event.current.data,false)}</LLMModelSource>

<Identifier>

Mengonfigurasi kebijakan untuk membuat penghitung unik berdasarkan flow variable.

Nilai Default T/A
Wajib? Opsional
Jenis String
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Melalui elemen Identifier, Anda dapat mengalokasikan jumlah token ke bucket berbeda yang ditentukan oleh nilai dalam variabel alur. Misalnya, Anda dapat menggunakan variabel developer.id, yang diisi setelah kebijakan VerifyAPIKey, untuk menerapkan satu batas kuota ke semua instance dari semua aplikasi yang dibuat oleh setiap developer tertentu, atau Anda dapat menggunakan client_id untuk menerapkan batas kuota untuk setiap aplikasi tertentu. Konfigurasi untuk yang terakhir terlihat seperti ini:

<Identifier ref="client_id"/>

Anda dapat merujuk ke variabel kustom yang mungkin Anda tetapkan dengan kebijakan AssignMessage atau kebijakan JavaScript, atau variabel yang ditetapkan secara implisit, seperti yang ditetapkan oleh kebijakan VerifyAPIKey atau kebijakan VerifyJWT. Untuk mengetahui informasi selengkapnya tentang variabel, lihat Menggunakan Variabel Alur, dan untuk mengetahui daftar variabel terkenal yang ditentukan oleh Apigee, lihat Referensi variabel alur.

Jika Anda tidak menggunakan elemen ini, kebijakan akan mengalokasikan semua jumlah token ke dalam satu penghitung untuk kebijakan LLMTokenQuota tertentu.

Tabel berikut menjelaskan atribut <Identifier>:

Atribut Deskripsi Default Kehadiran
ref

Menentukan variabel alur yang mengidentifikasi penghitung yang akan digunakan untuk permintaan. Variabel dapat merujuk ke header HTTP, parameter kueri, parameter formulir, atau elemen konten pesan, atau, beberapa nilai lain untuk mengidentifikasi cara mengalokasikan jumlah token.

client_id umum digunakan sebagai variabel. client_id juga dikenal sebagai kunci API atau kunci pengguna, dan dibuat untuk aplikasi saat didaftarkan di organisasi di Apigee. Anda dapat menggunakan ID ini jika Anda telah mengaktifkan kebijakan otorisasi OAuth atau kunci API untuk API Anda.

 T/A Opsional

<UseQuotaConfigInAPIProduct>

Menentukan setelan kuota untuk produk API, seperti unit waktu, interval, dan maksimum yang diizinkan.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis kompleks
Elemen Induk <LLMTokenQuota>
Elemen Turunan <DefaultConfig>

Jika Anda menambahkan elemen <UseQuotaConfigInAPIProduct> ke kebijakan LLMTokenQuota, Apigee akan mengabaikan elemen turunan <Allow>, <Interval>, dan <TimeUnit> dari LLMTokenQuotaPolicy.

Elemen <UseQuotaConfigInAPIProduct> hanyalah penampung untuk setelan default yang Anda tentukan menggunakan elemen <DefaultConfig>, seperti yang ditunjukkan dalam contoh berikut:

<UseQuotaConfigInAPIProduct stepName="POLICY_NAME">
  <DefaultConfig>...</DefaultConfig>
</UseQuotaConfigInAPIProduct>

Anda dapat menggunakan atribut stepName untuk mereferensikan kebijakan VerifyAPIKey atau operasi kebijakan ValidateToken dari kebijakan OAuthv2 dalam alur.

Tabel berikut menjelaskan atribut <UseQuotaConfigInAPIProduct>:

Atribut Deskripsi Default Kehadiran
stepName Mengidentifikasi nama kebijakan autentikasi dalam alur. Target dapat berupa kebijakan VerifyAPIKey atau kebijakan OAuthv2. T/A Wajib

Untuk informasi selengkapnya, lihat referensi berikut:

<DefaultConfig>

Berisi nilai default untuk kuota produk API. Saat Anda menentukan <DefaultConfig>, ketiga elemen turunan wajib diisi.

Nilai Default T/A
Wajib? Opsional
Jenis Jenis kompleks
Elemen Induk <UseQuotaConfigInAPIProduct>
Elemen Turunan <Allow>
<Interval>
<TimeUnit>

Nilai ini dapat ditentukan pada operasi produk API (baik dengan UI maupun API products API) dan dalam kebijakan LLMTokenQuota. Namun, jika Anda melakukannya, setelan pada produk API akan lebih diutamakan dan setelan pada kebijakan LLMTokenQuota akan diabaikan.

Sintaksis untuk elemen ini adalah sebagai berikut:

<UseQuotaConfigInAPIProduct stepName="POLICY_NAME">
  <DefaultConfig>
    <Allow>allow_count</Allow>
    <Interval>interval</Interval>
    <TimeUnit>[minute|hour|day|week|month]</TimeUnit>
  </DefaultConfig>
</UseQuotaConfigInAPIProduct>

Contoh berikut menentukan kuota 10.000 setiap minggu:

<DefaultConfig>
  <Allow>10000</Allow>
  <Interval>1</Interval>
  <TimeUnit>week</TimeUnit>
</DefaultConfig>

Untuk informasi selengkapnya, lihat referensi berikut:

<SharedName>

Mengidentifikasi kebijakan LLMTokenQuota ini sebagai bersama. Semua kebijakan LLMTokenQuota di proxy API dengan nilai <SharedName> yang sama akan menggunakan penghitung kuota dasar yang sama.

Untuk mengetahui informasi dan contoh selengkapnya, lihat Mengonfigurasi penghitung kuota bersama.

Nilai Default T/A
Wajib? Opsional
Jenis String
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

<CountOnly>

Tempatkan kebijakan LLMTokenQuota dengan elemen ini ditetapkan ke true dalam langkah di alur respons ProxyEndpoint untuk melacak jumlah token tanpa mengirimkan error kembali ke klien saat batas kuota token terlampaui. Jika elemen ini ada, elemen <SharedName> juga harus ada dan elemen <EnforceOnly> tidak boleh ada.

Untuk mengetahui informasi dan contoh selengkapnya, lihat Mengonfigurasi penghitung kuota bersama.

Nilai Default false
Wajib? Opsional
Jenis Boolean
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

<EnforceOnly>

Tempatkan kebijakan LLMTokenQuota dengan elemen ini yang disetel ke true dalam alur permintaan proxy API untuk menerapkan batas token tanpa menambah penghitung kuota. Jika elemen ini ada, maka <SharedName> juga harus ada dan elemen <CountOnly> tidak boleh ada.

Untuk mengetahui informasi dan contoh selengkapnya, lihat Mengonfigurasi penghitung kuota bersama.

Nilai Default false
Wajib? Opsional
Jenis Boolean
Elemen Induk <LLMTokenQuota>
Elemen Turunan Tidak ada

Variabel alur

Variabel Flow yang telah ditentukan sebelumnya berikut akan otomatis diisi saat kebijakan LLMTokenQuota dijalankan. Untuk mengetahui informasi selengkapnya, lihat Referensi variabel alur.

Variabel Jenis Izin Deskripsi
ratelimit.{policy_name}.allowed.count Long Hanya Baca Menampilkan jumlah kuota yang diizinkan.
ratelimit.{policy_name}.used.count Long Hanya Baca Menampilkan kuota saat ini yang digunakan dalam interval kuota.
ratelimit.{policy_name}.available.count Long Hanya Baca Menampilkan jumlah kuota yang tersedia dalam interval kuota.
ratelimit.{policy_name}.exceed.count Long Hanya Baca Menampilkan 1 setelah kuota terlampaui.
ratelimit.{policy_name}.total.exceed.count Long Hanya Baca Menampilkan 1 setelah kuota terlampaui.
ratelimit.{policy_name}.expiry.time Long Hanya Baca

Menampilkan waktu UTC (dalam milidetik), yang menentukan kapan kuota berakhir dan kapan interval kuota baru dimulai.

Jika jenis kebijakan LLMTokenQuota adalah rollingwindow, nilai ini tidak valid karena interval kuota tidak pernah berakhir.

ratelimit.{policy_name}.identifier String Hanya Baca Menampilkan referensi ID (klien) yang dilampirkan ke kebijakan
ratelimit.{policy_name}.class String Hanya Baca Menampilkan class yang terkait dengan ID klien
ratelimit.{policy_name}.class.allowed.count Long Hanya Baca Menampilkan jumlah kuota yang diizinkan yang ditentukan di class
ratelimit.{policy_name}.class.used.count Long Hanya Baca Menampilkan kuota yang digunakan dalam suatu kelas
ratelimit.{policy_name}.class.available.count Long Hanya Baca Menampilkan jumlah kuota yang tersedia di kelas
ratelimit.{policy_name}.class.exceed.count Long Hanya Baca Menampilkan jumlah token yang melebihi batas di class dalam interval kuota saat ini
ratelimit.{policy_name}.class.total.exceed.count Long Hanya Baca Menampilkan jumlah total token yang melebihi batas di class di semua interval kuota, sehingga merupakan jumlah class.exceed.count untuk semua interval kuota.
ratelimit.{policy_name}.failed Boolean Hanya Baca

Menunjukkan apakah kebijakan gagal atau tidak (benar atau salah).
llmtokenquota.{policy_name}.model String Hanya Baca Menampilkan model yang diekstrak.

Referensi error

Bagian ini menjelaskan kode kesalahan dan pesan error yang ditampilkan serta variabel kesalahan yang ditetapkan oleh Apigee saat kebijakan ini memicu error. 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 Menangani kesalahan.

Error runtime

Error ini dapat terjadi saat kebijakan dijalankan.

Kode kesalahan Status HTTP Penyebab Perbaiki
policies.llmtokenquota.FailedToResolveModelName 400 Nama model tidak dapat diselesaikan. T/A
policies.llmtokenquota.FailedToResolveTokenUsageCount 500 Jumlah penggunaan token tidak dapat diselesaikan. T/A
policies.llmtokenquota.MessageTemplateExtractionFailed 400 Ekstraksi template pesan gagal. T/A
policies.llmtokenquota.LLMTokenQuotaViolation 429 Batas kuota token LLM terlampaui. T/A
policies.ratelimit.FailedToResolveQuotaIntervalReference 500 Terjadi jika elemen <Interval> tidak ditentukan dalam kebijakan LLMTokenQuota. Elemen ini wajib ada dan digunakan untuk menentukan interval waktu yang berlaku untuk kuota token LLM. Interval waktu dapat berupa menit, jam, hari, minggu, atau bulan sebagaimana ditentukan dengan elemen <TimeUnit>.
policies.ratelimit.FailedToResolveQuotaIntervalTimeUnitReference 500 Terjadi jika elemen <TimeUnit> tidak ditentukan dalam kebijakan LLMTokenQuota. Elemen ini wajib ada dan digunakan untuk menentukan unit waktu yang berlaku untuk kuota token LLM. Interval waktu dapat berupa menit, jam, hari, minggu, atau bulan.

Error saat deployment

Nama error Penyebab Perbaiki
policies.llmtokenquota.MessageWeightNotSupported Error saat elemen 'MessageWeight' digunakan, karena tidak didukung. T/A
policies.llmtokenquota.InvalidConfiguration Tepatnya salah satu dari <CountOnly> atau <EnforceOnly> harus disetel ke benar (true). T/A
InvalidQuotaInterval Jika interval kuota token LLM yang ditentukan dalam elemen <Interval> bukan bilangan bulat, deployment proxy API akan gagal. Misalnya, jika interval kuota yang ditentukan adalah 0,1 dalam elemen <Interval>, maka deployment proxy API akan gagal.
InvalidQuotaTimeUnit Jika unit waktu yang ditentukan dalam elemen <TimeUnit> tidak didukung, maka deployment proxy API akan gagal. Unit waktu yang didukung adalah minute, hour, day, week, dan month.
InvalidQuotaType Jika jenis kuota token LLM yang ditentukan oleh atribut type dalam elemen <LLMTokenQuota> tidak valid, deployment proxy API akan gagal. Jenis kuota yang didukung adalah default, calendar, flexi, dan rollingwindow.
InvalidStartTime Jika format waktu yang ditentukan dalam elemen <StartTime> tidak valid, maka deployment proxy API akan gagal. Format yang valid adalah yyyy-MM-dd HH:mm:ss, yang merupakan format tanggal dan waktu ISO 8601. Misalnya, jika waktu yang ditentukan dalam elemen <StartTime> adalah 7-16-2017 12:00:00, maka deployment proxy API akan gagal.
StartTimeNotSupported Jika elemen <StartTime> yang jenis kuotanya bukan jenis calendar ditentukan, deployment proxy API akan gagal. Elemen <StartTime> hanya didukung untuk jenis kuota calendar. Misalnya, jika atribut type ditetapkan ke flexi atau rolling window dalam elemen <LLMTokenQuota>, maka deployment proxy API akan gagal.
InvalidSynchronizeIntervalForAsyncConfiguration Jika nilai yang ditentukan untuk elemen <SyncIntervalInSeconds> dalam elemen <AsynchronousConfiguration> dalam kebijakan LLMTokenQuota kurang dari nol, maka deployment proxy API akan gagal.
InvalidAsynchronizeConfigurationForSynchronousQuota Jika nilai elemen <AsynchronousConfiguration> ditetapkan ke true dalam kebijakan LLMTokenQuota, yang juga memiliki konfigurasi asinkron yang ditentukan menggunakan elemen <AsynchronousConfiguration>, maka deployment proxy API akan gagal.

Variabel kesalahan

Variabel ini ditetapkan saat kebijakan ini memicu error. Untuk mengetahui 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 "LLMTokenQuotaViolation"
ratelimit.policy_name.failed policy_name adalah nama kebijakan yang ditentukan pengguna yang menyebabkan kesalahan. ratelimit.QT-LLMTokenQuotaPolicy.failed = true

Contoh respons error

{  
   "fault":{  
      "detail":{  
         "errorcode":"policies.llmtokenquota.LLMTokenQuotaViolation"
      },
      "faultstring":"Rate limit LLM Token quota violation. Quota limit exceeded.

 Identifier : _default"
   }
}

Contoh aturan kesalahan

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

Skema

Topik terkait

Kebijakan PromptTokenLimit