Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Sebességkorlátok, kvóták és szintek

13. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Sebességkorlátok, kvóták és szintek
  2. A szintrendszer
  3. A sebességkorlátok típusai
  4. Sebességkorlát-fejlécek olvasása
  5. Kliensoldali sebességkorlátozás
  6. Stratégiák nagy volumenhez
  7. Főbb megállapítások

Sebességkorlátok, kvóták és szintek

A sebességkorlátok határozzák meg, hány kérést küldhetsz az API-nak percenként. Ezen korlátok megértése és kezelése elengedhetetlen a szolgáltatás megszakadásának elkerüléséhez éles környezetben. A rémálom forgatókönyv mindig ugyanaz: egy integráció, amely hibátlanul működött fejlesztés közben, ahol percenként csak három kérést küldtél, élesbe kerül, és hirtelen több ezer dokumentumot tartalmazó sort kell feldolgoznia. A 429-es hibák özönlenek, és a feldolgozás fele elveszik, mert nem számoltál a szükséges átviteli sebességgel.

A szintrendszer

Az OpenAI a számlázási előzményeid alapján szintekre (szintekre) osztja a korlátokat. Nem te választod ki a szintedet; azt a felhalmozott költés és egy időablak kivárása után oldod fel. Ennek a fejlődésnek fontos gyakorlati következménye van: egy csak ügyféldemóhoz létrehozott fiók kapacitása nem lesz ugyanakkora, mint az éles környezeti fiókodé, még akkor sem, ha a kód azonos.

# A szintek határozzák meg a korlátaidat
# 1. szint: Az első sikeres fizetés után
# 2. szint: 50 $ kumulatív költés + 7 nap után
# 3. szint: 100 $ kumulatív költés + 7 nap után
# 4. szint: 250 $ kumulatív költés + 14 nap után
# 5. szint: 1000 $ kumulatív költés + 30 nap után

# A korlátok minden szinttel jelentősen nőnek

A sebességkorlátok típusai

Három számláló fut egyszerre, és az első, amelyet elérsz, letilt. A rövid szövegek feldolgozása sokkal hamarabb telíti az RPM-et (kérés/perc), mint a TPM-et (token/perc); ezzel szemben a hosszú dokumentumok elemzése kimeríti a TPM-et akkor is, ha csak néhány tucat kérést küldtél. A párhuzamosítás méretezése előtt mindig ellenőrizd a promptjaid nagyságrendjét.

# 1. RPM — Kérések percenként (Requests Per Minute)
# 2. TPM — Tokenek percenként (Tokens Per Minute)
# 3. RPD — Kérések naponta (Requests Per Day)

# Nagyságrend a 3. szinthez (a tényleges korlátokat
# a platform.openai.com > Settings > Limits oldalon ellenőrizd):
# RPM: 5000 kérés/perc
# TPM: 2 000 000 token/perc
# RPD: 10 000 kérés/nap

Sebességkorlát-fejlécek olvasása

Nem kell találgatnod a fogyasztásodat: minden válasz tartalmazza ezt a HTTP-fejléceiben. Az SDK alapértelmezetten elrejti ezeket, hogy csak a parszolt objektumot adja vissza, de a with_raw_response hozzáférést biztosít a nyers válaszhoz, a parse() pedig újjáépíti a szokásos objektumot. Egy ezeken az értékeken alapuló irányítópult figyelmeztet, ahogy közeledsz a plafonhoz, ahelyett, hogy hagyna egy hiba révén szembesülni vele.

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

# Hozzáférés a fejlécekhez a nyers HTTP-válaszon keresztül
# A with_raw_response mód használata
raw = client.responses.with_raw_response.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

print(f"RPM korlát: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM maradék: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM korlát: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM maradék: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Visszaállítás: {raw.headers.get('x-ratelimit-reset-requests')}")

response = raw.parse()
print(f"Válasz: {response.output_text}")

Kliensoldali sebességkorlátozás

Jobb, ha te lassítasz, mint hogy elutasítsanak. Két megvalósítás lefedi a legtöbb igényt.

Átviteli sebesség korlátozása szemaforral

Az első egy szemafort kombinál, amely korlátozza az egyidejű hívások számát, egy, a célzott átviteli sebességből számított késleltetéssel. A példában ötven összefoglaló indul egyszerre, de csak öt fut párhuzamosan, eltolva azzal a késleltetéssel, amely 100 kérés/percnek felel meg. A hívó kód egy egyszerű asyncio.gather marad: minden fegyelem az osztályba van kapszulázva.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

class RateLimiter:
    """Korlátozza az egyidejű kérések számát."""

    def __init__(self, max_concurrent: int = 10, rpm: int = 500):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.rpm = rpm
        self.delay = 60.0 / rpm  # Késleltetés minden kérés között

    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"Result {i}: {r[:50]}...")

# asyncio.run(batch_processing())

Egyszerű token-vödör

A token-vödör rugalmasabb, mert lehetővé teszi a kitöréseket (burst). A vödör konstans sebességgel telik, és minden hívással ürül: ha az alkalmazásod egy percig tétlen volt, újraindulhat teljes sebességgel ötven kérés erejéig, majd természetesen visszaáll a töltési sebességre. Pontosan ez a viselkedés kell egy olyan szolgáltatáshoz, amely csúcsok és hullámvölgyek között váltakozik, és a zárnak köszönhetően több szálas környezetekben is működik.

import time
import threading

class TokenBucket:
    "Sebességkorlátozó a token-vödör algoritmus alapján."

    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):
        """Várakozás, amíg elegendő token rendelkezésre áll."""
        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)

# Használat: maximum 50 kérés percenként
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

Stratégiák nagy volumenhez

1. Elosztás több projekt között

Minden projektnek megvannak a saját sebességkorlátai. Ha eléred a plafont, miközben már magas szinten vagy, a hívások több projekt közötti elosztása mechanikusan megszorozza a rendelkezésre álló kapacitást. Az alábbi round-robin illusztrálja az elvet; éles környezetben vidd ki a ciklust a függvényből, hogy a hívások között is megmaradjon.

from openai import OpenAI

# Minden projektnek megvannak a saját sebességkorlátai
clients = [
    OpenAI(project="proj-aaaa"),  # 1. projekt
    OpenAI(project="proj-bbbb"),  # 2. projekt
    OpenAI(project="proj-cccc"),  # 3. projekt
]

def round_robin_call(prompt: str, clients: list) -> str:
    """Elosztja a hívásokat több projekt között."""
    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. A megfelelő modell használata a megfelelő volumenhez

A modellválasztás nemcsak minőségi, hanem kapacitásbeli döntés is. A legnehezebb modellek fenntartása kritikus feladatokra, és a nagy volumenű forgalom irányítása egy magasabb korlátokkal rendelkező modellre, felszabadítja az átviteli sebességet ott, ahol valóban szükséged van rá.

# A gazdaságos modellek (gpt-5.6-luna) rendelkeznek a legmagasabb korlátokkal
# Használd őket nagy volumenű feladatokhoz

# A zászlóshajó modell (gpt-5.6-sol) rendelkezik a legalacsonyabb korlátokkal
# Tartogasd kritikus feladatokra

3. Sorba állítás (Queuing)

Végül a sorba állítás szétválasztja a kérések előállítását és fogyasztását. Egyetlen szál egy fix ütemben veszi ki a elemeket a sorból, míg az alkalmazás többi része szabadon küldhet; a hívó blokkol egy eseményen, amíg az eredmény meg nem érkezik. Ez a minta elnyeli a csúcsokat anélkül, hogy valaha is túllépné a konfigurált átviteli sebességet.

import queue
import threading

class APIQueue:
    """Sor az API-hívásokhoz."""

    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"]

Főbb megállapítások

  • A sebességkorlátok egyszerre vonatkoznak az RPM-re, TPM-re és RPD-re
  • A szinted határozza meg a korlátaidat – ez a kumulatív költéssel nő
  • Olvasd be az x-ratelimit-* fejléceket, hogy valós időben tudd a fogyasztásodat
  • Implementálj kliensoldali sebességkorlátozót a 429-es hibák elkerülésére
  • Nagy volumen esetén oszd el a terhelést a projektek között
  • A Luna biztosítja a legmagasabb sebességkorlátokat a tömeges feldolgozáshoz