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

Eksponentiaalinen viive HTTP 429 -virheen yhteydessä

Oppitunti 6 / 12 Päivitetty 30. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. 429-virheen ymmärtäminen
  2. Miten eksponentiaalinen viive toimii
  3. Manuaalinen toteutus
  4. tenacity-kirjaston käyttö
  5. Viiveen ja semaforin yhdistäminen
  6. Viiveen sovittaminen virhetyypin mukaan
  7. Keskeiset asiat

429-virheen ymmärtäminen

HTTP 429 -virhe tarkoittaa, että olet ylittänyt rajapinnan nopeusrajoitukset. xAI-palvelin kieltäytyy väliaikaisesti pyynnöistäsi suojellakseen infrastruktuuria. Tämä virhe on normaali eräajotilanteissa: se kertoo yksinkertaisesti, että lähetät pyyntöjä liian nopeasti.

Oikea reaktio ei ole luovuttaa, vaan odottaa ennen uudelleenyritystä. Eksponentiaalinen viive (exponential backoff) on standardistrategia tämän tilanteen hallintaan.

Miten eksponentiaalinen viive toimii

Uudelleenyrityksen sijaan heti (mikä laukaisisi uuden 429-virheen), odotat kasvavaa aikaa kunkin yrityksen välillä:

    1. epäonnistuminen: odota 1 sekunti
    1. epäonnistuminen: odota 2 sekuntia
    1. epäonnistuminen: odota 4 sekuntia
    1. epäonnistuminen: odota 8 sekuntia
    1. epäonnistuminen: luovuta

Viive kaksinkertaistuu jokaisella yrityksellä, mistä termi “eksponentiaalinen” juontaa juurensa. Tämä antaa palvelimelle aikaa palauttaa kapasiteettia.

Manuaalinen toteutus

import asyncio
import random
from openai import RateLimitError

async def request_with_backoff(
    prompt: str,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> str:
    for attempt in range(max_retries):
        try:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

        except RateLimitError:
            if attempt == max_retries - 1:
                raise  # last attempt, propagate the error

            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            wait_time = delay + jitter

            print(f"Rate limit hit, attempt {attempt + 1}/{max_retries}. "
                  f"Waiting {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

jitter (satunnaisvaihtelu) on tärkeä. Jos useat korutiinit saavat 429-virheen samaan aikaan, ilman jitteriä ne yrittäisivät kaikki uudelleen täsmälleen samalla hetkellä, mikä laukaisisi uuden 429-virheen. Jitteri desynkronoi yritykset.

tenacity-kirjaston käyttö

Tuotantokäytössä tenacity-kirjasto yksinkertaistaa toteutusta:

from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type
)
from openai import RateLimitError

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="grok-4.5",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

@retry-dekoraattori sieppaa RateLimitError-virheen, odottaa eksponentiaalista viivettä (1–60 sekunnin välillä) ja yrittää uudelleen enintään 5 kertaa. Funktion koodi pysyy siistinä ja luettavana.

Viiveen ja semaforin yhdistäminen

Käytännössä yhdistät viiveen semaforiin saadaksesi täyden hallinnan:

async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            return await request_with_backoff(prompt)

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Semafori estää rajapinnan ylikuormittumisen, ja viive käsittelee jäljelle jääneet 429-virheet. Tämä kaksoissuojaus on suositeltu konfiguraatio tuotantoympäristöön.

Viiveen sovittaminen virhetyypin mukaan

Kaikki virheet eivät perustele uudelleenyritystä. Tässä on luokittelu:

from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError

async def smart_retry(prompt: str, max_retries: int = 5) -> str:
    for attempt in range(max_retries):
        try:
            return await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
        except RateLimitError:
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except (APITimeoutError, APIConnectionError):
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except BadRequestError:
            raise  # error in prompt, retry useless

429-virheet (nopeusrajoitus), aikakatkaisut ja yhteysvirheet ansaitsevat uudelleenyrityksen. Sen sijaan BadRequestError (virheellinen kehote) ei ratkea uudelleenyrityksellä.

Keskeiset asiat

  • 429-virhe on normaali ja odotettu ilmiö eräajon aikana
  • Eksponentiaalinen viive kaksinkertaistaa odotusajan jokaisen yrityksen välillä (1 s, 2 s, 4 s, 8 s…)
  • Jitteri desynkronoi uudet yritykset yhteentörmäysten välttämiseksi
  • tenacity-kirjasto yksinkertaistaa toteutusta tuotannossa
  • Yhdistä aina semafori ja eksponentiaalinen viive maksimaalisen kestävyyden saavuttamiseksi
  • Älä yritä uudelleen virheellisiä pyyntöjä (BadRequestError)