Kiirusepiirangud, kvoodid ja tasemed
Sellel lehel
Kiirusepiirangud, kvoodid ja tasemed
Kiirusepiirangud määravad, mitu päringut saad API-le minutis saata. Nende piirangute mõistmine ja haldamine on tootmises teenusekatkestuste vältimiseks kriitilise tähtsusega. Õudusstseenario on alati sama: arenduses laitmatult töötanud integratsioon, kus saatsid kolm päringut minutis, läheb live’i ja hakkab äkki töötlema mitme tuhande dokumendi järjekorda. 429 vead sajab nagu oavarrest ja pool töötlemisest läheb kaduma, sest läbilaskevõimet ei osatud ette näha.
Tasemesüsteem
OpenAI liigitab piirangud tasemeteks (astmeteks) vastavalt sinu arveldusajaloole. Sa ei vali oma taset ise; sa avad selle, kogudes kulutusi ja oodates teatud ajaakna möödumist. Sellel progresseerumisel on oluline praktiline tagajärg: ainult kliendi demo jaoks loodud kontol ei ole sama võimsust kui sinu tootmiskontol, isegi kui kood on identne.
# Tasemed määravad sinu piirangud
# Tase 1: Pärast esimest edukat makset
# Tase 2: Pärast 50 $ kumulatiivset kulutust + 7 päeva
# Tase 3: Pärast 100 $ kumulatiivset kulutust + 7 päeva
# Tase 4: Pärast 250 $ kumulatiivset kulutust + 14 päeva
# Tase 5: Pärast 1000 $ kumulatiivset kulutust + 30 päeva
# Piirangud kasvavad iga tasemega märkimisväärselt
Kiirusepiirangute tüübid
Korraga kehtib kolm loendurit ja esimene, mille piiri ületad, blokeerib sind. Lühikeste tekstide töötlemine küllastab RPM-i (päringuid minutis) ammu enne TPM-i (tokeneid minutis); vastupidi, pikkade dokumentide analüüsimine ammendab TPM-i, isegi kui oled saatnud vaid paar tosinat päringut. Enne paralleelsuse planeerimist kontrolli alati oma vihjete suurusjärku.
# 1. RPM — Päringuid minutis (Requests Per Minute)
# 2. TPM — Tookeneid minutis (Tokens Per Minute)
# 3. RPD — Päringuid päevas (Requests Per Day)
# Suurusjärk tasemele 3 (kontrolli oma tegelikke piiranguid
# aadressil platform.openai.com > Settings > Limits):
# RPM: 5000 päringut/minutis
# TPM: 2 000 000 tokenit/minutis
# RPD: 10 000 päringut/päevas
Kiirusepiirangu päiste lugemine
Sa ei pea oma tarbimist arvama: iga vastus kannab seda oma HTTP-päistes. SDK peidab need vaikimisi, et tagastada ainult parsitud objekt, kuid with_raw_response annab sulle juurdepääsu toorele vastusele ja parse() taastab tavapärase objekti. Nendel väärtustel põhinev armatuurlaud hoiatab sind, kui lähened laele, selle asemel et laseks sul seda vea kaudu avastada.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Juurdepääs päistele toore HTTP-vastuse kaudu
# Kasutades with_raw_response režiimi
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM piirang: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM järelejäänud: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM piirang: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM järelejäänud: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Lähtestamine: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Vastus: {response.output_text}")
Kliendipoolne kiirusepiirang
Parem on ise tempot maha võtta kui tagasi lükatud saada. Kaks rakendust katavad enamiku vajadusi.
Läbilaskevõime piiramine semaforiga
Esimene meetod ühendab semafori, mis piirab samaaegsete kõnede arvu, viivitusega, mis arvutatakse sihtläbilaskevõime põhjal. Näites käivitatakse korraga viiskümmend kokkuvõtet, kuid ainult viis toimub paralleelselt, jaotatuna viivitusega, mis vastab 100 päringule minutis. Kutsev kood jääb lihtsaks asyncio.gather-iks: kogu distsipliin on kapseldatud klassi.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Piirab samaaegsete päringute arvu."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Viivitus iga päringu vahel
async def call(self, prompt: str) -> str:
async with self.semaphore:
await asyncio.sleep(self.delay)
response = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
async def batch_processing():
limiter = RateLimiter(max_concurrent=5, rpm=100)
prompts = [f"Võta kokku kontseptsioon {i}" for i in range(50)]
tasks = [limiter.call(p) for p in prompts]
results = await asyncio.gather(*tasks)
for i, r in enumerate(results):
print(f"Tulemus {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Lihtne tokenite ämber
Tokenite ämber on paindlikum, kuna võimaldab purseid. Ämber täitub konstantsel kiirusel ja tühjeneb iga kõnega: kui sinu rakendus on olnud minut aega jõude, saab see viiskümmend päringut täiskiirusega taaskäivitada ja seejärel loomulikult naasta täitmiskiirusele. See on täpselt see käitumine, mida soovid teenuse jaoks, mis vaheldub tippude ja mõõnade vahel, ning see toimib tänu lukule mitmelõngelistes keskkondades.
import time
import threading
class TokenBucket:
"""Kiirusepiiraja, mis põhineb tokenite ämbri algoritmil."""
def __init__(self, tokens_per_second: float, max_capacity: int):
self.tokens_per_second = tokens_per_second
self.max_capacity = max_capacity
self.tokens = max_capacity
self.last_refill = time.monotonic()
self.lock = threading.Lock()
def wait(self, tokens_needed: int = 1):
"""Ootab, kuni piisavalt tookeneid on saadaval."""
while True:
with self.lock:
now = time.monotonic()
elapsed = now - self.last_refill
self.tokens = min(
self.max_capacity,
self.tokens + elapsed * self.tokens_per_second
)
self.last_refill = now
if self.tokens >= tokens_needed:
self.tokens -= tokens_needed
return
time.sleep(0.1)
# Kasutus: maksimaalselt 50 päringut minutis
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)
def limited_call(prompt: str) -> str:
bucket.wait(1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
Suurte mahtude strateegiad
1. Jaotamine mitme projekti vahel
Igal projektil on oma kiirusepiirangud. Kui jõuad laeni juba kõrgel tasemel olles, siis kõnede jaotamine mitme projekti vahel korrutab mehhaaniliselt saadaolevat võimsust. Allpool olev round-robin illustreerib põhimõtet; tootmises vii tsükkel funktsioonist välja, et see püsiks kõnede vahel.
from openai import OpenAI
# Igal projektil on oma kiirusepiirangud
clients = [
OpenAI(project="proj-aaaa"), # Projekt 1
OpenAI(project="proj-bbbb"), # Projekt 2
OpenAI(project="proj-cccc"), # Projekt 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Jaotab kõned mitme projekti vahel."""
import itertools
client_cycle = itertools.cycle(clients)
client = next(client_cycle)
return client.responses.create(
model="gpt-5.6-terra",
input=prompt
).output_text
2. Õige mudeli kasutamine õige mahu jaoks
Mudeli valik on samuti võimsuse otsus, mitte ainult kvaliteedi oma. Raskemate mudelite reserveerimine kriitiliste ülesannete jaoks ja mahu suunamine suuremate piirangutega mudelile vabastab läbilaskevõimet seal, kus seda tegelikult vajad.
# Ökonoomsed mudelid (gpt-5.6-luna) on kõrgeimate piirangutega
# Kasuta neid suure mahuga ülesannete jaoks
# Lipulaevastiku mudel (gpt-5.6-sol) on madalaimate piirangutega
# Reserveeri see kriitiliste ülesannete jaoks
3. Järjekord
Lõpuks eraldab järjekord päringute genereerimise tarbimisest. Üks lõng tühjendab järjekorda fikseeritud tempos, samal ajal kui ülejäänud rakendus esitab päringuid vabalt; helistaja blokeerub sündmusel, kuni tema tulemus saabub. See muster neelab tippe, ületamata kunagi konfigureeritud läbilaskevõimet.
import queue
import threading
class APIQueue:
"""Järjekord API kõnede jaoks."""
def __init__(self, rpm: int = 100):
self.queue = queue.Queue()
self.delay = 60.0 / rpm
self.running = True
self.worker = threading.Thread(target=self._process, daemon=True)
self.worker.start()
def _process(self):
while self.running:
try:
prompt, future = self.queue.get(timeout=1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
future["result"] = response.output_text
future["event"].set()
time.sleep(self.delay)
except queue.Empty:
continue
def submit(self, prompt: str) -> str:
future = {"result": None, "event": threading.Event()}
self.queue.put((prompt, future))
future["event"].wait()
return future["result"]
Peamised punktid
- Kiirusepiirangud kehtivad samaaegselt RPM-i, TPM-i ja RPD-i osas
- Sinu tase määrab sinu piirangud – see kasvab koos sinu kumulatiivsete kulutustega
- Loegi päiseid
x-ratelimit-*, et teada oma tarbimist reaalajas - Rakenda kliendipoolne kiirusepiiraja 429 vigade vältimiseks
- Jaota koormus suuremate mahtude korral projektide vahel
- Luna pakub suurimate mahtude töötlemiseks kõrgeimaid kiirusepiiranguid