Nopeusrajoitukset, kiintiöt ja tasot
Tällä sivulla
Nopeusrajoitukset, kiintiöt ja tasot
Nopeusrajoitukset määrittävät, kuinka monta pyyntöä voit lähettää rajapinnalle minuutissa. Näiden rajoitusten ymmärtäminen ja hallinta on kriittisen tärkeää palvelukatkojen välttämiseksi tuotantoympäristössä. Pahin mahdollinen skenaario on aina sama: integraatio, joka toimi moitteettomasti kehitysvaiheessa lähettäen kolme pyyntöä minuutissa, otetaan käyttöön ja alkaa yhtäkkiä käsitellä useiden tuhansien dokumenttien jonoa. 429-virheet tulvivat sisään, ja puolet käsittelystä menetetään, koska läpimenoa ei ollut ennakoitu.
Tasojärjestelmä
OpenAI jakaa rajoitukset tasoille laskutushistoriasi perusteella. Et valitse tasoa itse; avaat sen kerryttämällä kustannuksia ja odottamalla määritetyn aikajakson. Tällä etenemisellä on tärkeä käytännön seuraus: vain asiakasesittelyä varten luodulla tilillä ei ole samaa kapasiteettia kuin tuotantotililläsi, vaikka koodi olisi identtinen.
# Tasot määrittävät rajasi
# Taso 1: Ensimmäisen onnistuneen maksun jälkeen
# Taso 2: 50 $ kumulatiivisen kulutuksen + 7 päivän jälkeen
# Taso 3: 100 $ kumulatiivisen kulutuksen + 7 päivän jälkeen
# Taso 4: 250 $ kumulatiivisen kulutuksen + 14 päivän jälkeen
# Taso 5: 1000 $ kumulatiivisen kulutuksen + 30 päivän jälkeen
# Rajat kasvavat merkittävästi jokaisella tasolla
Nopeusrajoitustyypit
Kolme laskuria toimivat samanaikaisesti, ja ensimmäinen täyttyvä rajoite estää toimintasi. Lyhyiden tekstien käsittely kyllästää RPM:n (pyynnöt minuutissa) kauan ennen TPM:tä (tokenit minuutissa); päinvastoin pitkien dokumenttien analysointi kuluttaa TPM:n loppuun, vaikka olisit lähettänyt vain muutaman kymmenen pyyntöä. Tarkista aina kehotteidesi suuruusluokka ennen rinnakkaisuuden mitoittamista.
# 1. RPM — Requests Per Minute (pyynnöt minuutissa)
# 2. TPM — Tokens Per Minute (tokenit minuutissa)
# 3. RPD — Requests Per Day (pyynnöt päivässä)
# Suuruusluokka tasolle 3 (tarkista todelliset rajasi
# osoitteessa platform.openai.com > Settings > Limits):
# RPM: 5 000 pyyntöä/minuutti
# TPM: 2 000 000 tokenia/minuutti
# RPD: 10 000 pyyntöä/päivä
Nopeusrajoitusotsakkeiden lukeminen
Sinun ei tarvitse arvata kulutustasi: jokainen vastaus sisältää sen HTTP-otsakkeissaan. SDK piilottaa ne oletuksena palauttaakseen vain jäsennetyn objektin, mutta with_raw_response antaa pääsyn raakaan vastaukseen, ja parse() rakentaa tavallisen objektin uudelleen. Näihin arvoihin perustuva kojelauta varoittaa sinua lähestyessäsi kattoa sen sijaan, että huomaisit sen virheen kautta.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Käytä otsakkeita raakan HTTP-vastauksen kautta
# Käyttäen with_raw_response-tilaa
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM-raja: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM jäljellä: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM-raja: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM jäljellä: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Nollautuu: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Vastaus: {response.output_text}")
Asiakaspuolen nopeusrajoitus
On parempi hidastaa itseään kuin tulla torjutuksi. Kaksi toteutustapaa kattaa useimmat tarpeet.
Läpimenon rajoittaminen semaforilla
Ensimmäinen yhdistää semaforin, joka rajoittaa samanaikaisten kutsujen määrän, ja viiveen, joka lasketaan tavoiteläpimenon perusteella. Esimerkissä viisikymmentä yhteenvetoa käynnistetään kerralla, mutta vain viisi etenee rinnakkain, viivästettynä 100 pyynnön minuuttivauhtia vastaavalla viiveellä. Kutsuva koodi pysyy yksinkertaisena asyncio.gather-kutsuna: koko kurinalaisuus on koteloitu luokkaan.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Rajoittaa samanaikaisten pyyntöjen määrää."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Viive jokaisen pyynnön välillä
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"Summarize concept {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"Tulos {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Yksinkertainen tokenämpäri
Tokenämpäri on joustavampi, koska se sallii piikit. Ämpäri täyttyy vakionopeudella ja tyhjenee jokaisella kutsulla: jos sovelluksesi on ollut toimettomana minuutin, se voi käynnistyä uudelleen täydellä nopeudella viidenkymmenen pyynnön ajaksi ja palautua sitten luonnollisesti täyttönopeuteen. Tämä on täsmälleen se käyttäytyminen, jota haluat palvelulta, joka vuorottelee piikkien ja hiljaiseloa jaksojen välillä, ja se toimii monisäikeisissä ympäristöissä lukon ansiosta.
import time
import threading
class TokenBucket:
"Nopeusrajoitin, joka perustuu tokenämpärialgoritmiin."
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):
"""Odottaa, kunnes tarpeeksi tokeneita on saatavilla."""
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)
# Käyttö: enintään 50 pyyntöä minuutissa
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
Strategiat suurille volyymeille
1. Jakaminen useisiin projekteihin
Jokaisella projektilla on omat nopeusrajoituksensa. Jos osut kattoosi ollessasi jo korkealla tasolla, kutsujen jakaminen useisiin projekteihin kertoo käytettävissä olevan kapasiteetin mekaanisesti. Alla oleva round-robin-esimerkki havainnollistaa periaatetta; tuotannossa siirrä sykli funktion ulkopuolelle, jotta se säilyy kutsujen välillä.
from openai import OpenAI
# Jokaisella projektilla on omat nopeusrajoituksensa
clients = [
OpenAI(project="proj-aaaa"), # Projekti 1
OpenAI(project="proj-bbbb"), # Projekti 2
OpenAI(project="proj-cccc"), # Projekti 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Jakaa kutsut useiden projektien kesken."""
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. Oikean mallin käyttäminen oikeaan volyymiin
Mallin valinta on myös kapasiteettipäätös, ei vain laatuun liittyvä päätös. Raskaimpien mallien varaaminen kriittisiin tehtäviin ja volyymin ohjaaminen malliin, jolla on korkeammat rajoitukset, vapauttaa läpimenoa sinne, missä sitä todella tarvitaan.
# Taloudellisilla malleilla (gpt-5.6-luna) on korkeimmat rajoitukset
# Käytä niitä suurvolyymin tehtäviin
# Lippulaivamallilla (gpt-5.6-sol) on alhaisimmat rajoitukset
# Varaa se kriittisiin tehtäviin
3. Jonotus
Lopuksi jonotus erottaa pyyntöjen tuottamisen kulutuksesta. Yksi säie purkaa jonoa kiinteällä tahdilla, kun taas muu sovellus lähettää pyyntöjä vapaasti; kutsuja estyy tapahtumassa, kunnes sen tulos saapuu. Tämä malli absorboi piikit ylittämättä koskaan määritettyä läpimenoa.
import queue
import threading
class APIQueue:
"""Jono API-kutsuille."""
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"]
Keskeiset asiat
- Nopeusrajoitukset koskevat samanaikaisesti RPM:ää, TPM:ää ja RPD:tä
- Tasosi määrittää rajasi – ne kasvavat kumulatiivisen kulutuksen myötä
- Lue
x-ratelimit-*-otsakkeet tietääksesi kulutuksesi reaaliajassa - Toteuta asiakaspuolen nopeusrajoitin välttääksesi 429-virheitä
- Jaa kuormitus projektien kesken suurissa volyymeissä
- Luna tarjoaa korkeimmat nopeusrajoitukset massakäsittelyyn