Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kiirusepiirangud, kvoodid ja tasemed

Õppetund 13 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Kiirusepiirangud, kvoodid ja tasemed
  2. Tasemesüsteem
  3. Kiirusepiirangute tüübid
  4. Kiirusepiirangu päiste lugemine
  5. Kliendipoolne kiirusepiirang
  6. Suurte mahtude strateegiad
  7. Peamised punktid

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