Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Nopeusrajoitukset, kiintiöt ja tasot

Oppitunti 13 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Nopeusrajoitukset, kiintiöt ja tasot
  2. Tasojärjestelmä
  3. Nopeusrajoitustyypit
  4. Nopeusrajoitusotsakkeiden lukeminen
  5. Asiakaspuolen nopeusrajoitus
  6. Strategiat suurille volyymeille
  7. Keskeiset asiat

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