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

HTTP 429 és exponenciális visszalépés

3. lecke 14 közül Frissítve 2026. július 29. Haladó
Ezen az oldalon
  1. A korlátok túllépésének kezelése
  2. Mit ne tegyél
  3. Exponenciális visszalépés
  4. Skálázás: Szabályozz, mielőtt hibáznál
  5. Kezeld a 429-et metrikaként
  6. Főbb megállapítások

A korlátok túllépésének kezelése

Amint az alkalmazásod eléri az RPM- vagy TPM-korlátait, a Grok API egy HTTP 429 státuszkóddal (Too Many Requests) válaszol. Értsd meg ezt a kódot pontosan arra, ami: nem leállás, hanem forgalomszabályozási jelzés. Az API azt mondja: „lassíts“, nem azt, hogy „elromlott“. A robusztus és a törékeny integráció közötti különbség éppen abban rejlik, hogyan értelmezi a kódod ezt a megkülönböztetést. A rosszul kezelt 429-es hiba sosem marad izolált: végiggyűrűzik a soron, majd a hívó szolgáltatásokon, és végül az végfelhasználó számára is látható incidenssé válik.

Mit ne tegyél

Az ösztönös reakció egy sikertelen kérés esetén az azonnali újrapróbálkozás. Ez pontosan a rossz lépés. Már így is túllépted a kvótádat; az azonnali újrapróbálkozással csak elégetsz egy további hívást, ami szintén sikertelen lesz, és ahelyett, hogy lerövidítenéd, meghosszabbítod a letiltási időszakot. A végtelen újrapróbálkozás csak ront a helyzeten, mert feleslegesen leköt szálakat. Ezzel szemben, ha a 429-et végleges hibának kezeled és feladod, megfosztod a felhasználót egy olyan eredménytől, ami néhány másodperccel később megérkezett volna. A helyes megközelítés a kettő között van: próbáld újra, de várj, és minden alkalommal egyre tovább.

Exponenciális visszalépés

Az elv az, hogy minden sikertelen kísérlet után megduplázod a várakozási időt, és hozzáadsz egy véletlenszerű ingadozást, amit jitternek nevezünk.

import time
import random

def call_with_retry(request, max_retries=5):
    for attempt in range(max_retries):
        response = send_request(request)

        if response.status_code != 429:
            return response

        base_delay = 2 ** attempt  # 1, 2, 4, 8, 16 seconds
        jitter = random.uniform(0, base_delay * 0.5)
        delay = base_delay + jitter

        time.sleep(delay)

    raise Exception("Retry limit reached")

A jitter külön figyelmet érdemel, mert ez az a sor, amit leggyakrabban törölnek abból a feltételezésből, hogy feleslegesen bonyolítja a kódot. Képzeld el, hogy a szolgáltatásod harminc példánya egyszerre kap egy 429-es választ ugyanabban a másodpercben. Jitter nélkül mind ugyanazt a késleltetést számítják ki, és pontosan ugyanabban a pillanatban próbálkoznak újra: így pontosan ugyanúgy reprodukálod a terhelési csúcsot, egy másodperccel később, majd kettővel, majd négygyel. Ezt nevezzük thundering herd (megrémült csorda) jelenségnek. A randomizálás időben szétoszlatja a kísérleteket, és megtöri ezt az akaratlan szinkronizációt. Jegyezd meg azt is, hogy az alap késleltetés egy másodpercnél kezdődik: soha ne menj ez alá az első újrapróbálkozásnál.

Skálázás: Szabályozz, mielőtt hibáznál

Nagy forgalmú alkalmazásoknál már nem elég reagálni a 429-es hibákra; jobb, ha elkerülöd őket. Egy kliens oldali sebességkorlátozó (rate limiter) korlátozza az egyidejű hívások számát, és betartat egy minimális időközt a küldések között, így a kimenő terhelés a plafon alatt marad, ahelyett, hogy folyamatosan feszegetné azt.

import asyncio
from asyncio import Semaphore

# Limit to 25 requests/second (margin under the allowed 30 req/s)
semaphore = Semaphore(25)

async def limited_request(payload):
    async with semaphore:
        response = await send_request_async(payload)
        await asyncio.sleep(1.0 / 25)  # minimum spacing
        return response

Figyeld meg a szándékos tartalékot: másodpercenként 25 kérés a megengedett 30 helyett. Ez a tartalék elnyeli a hálózati ingadozásokat és a forgalmi csúcsokat anélkül, hogy valaha is elérnéd a plafont.

Az áramkör megszakító (circuit breaker) teszi teljessé a beállítást azáltal, hogy leállítja a hívásokat, ha a hibák felszaporodnak. Zárt állapotban a kérések normálisan haladnak át. Egy meghatározott számú egymást követő hiba után nyílt állapotba vált, és egy konfigurált időtartamra helyben elutasít minden kérést: így abbahagyod az API ostromlását, amely visszautasít téged, és a szálaid elérhetőek maradnak az alkalmazás többi része számára. Amikor a késleltetés lejár, fél-nyílt (half-open) állapotba kerül, és engedélyez egy egyetlen tesztelőkérést; ha ez sikerül, a normál forgalom folytatódik, ellenkező esetben a számláló visszaáll. Ez a mechanizmus ugyanúgy védi a szolgáltatásodat, mint a másik oldalon lévő API-t.

Kezeld a 429-et metrikaként

Egy utolsó reflex, ami gyakran hiányzik az integrációkból: mérd a 429-es hibák arányát. Ez a szám nem a visszalépési kódod minőségét méri; hanem azt, hogy mennyire illik össze a csomagod a tényleges forgalmaddal. Egy hétről hétre emelkedő görbe jóval azelőtt jelzi a méretezés hiányosságait, mielőtt a felhasználók panaszkodni kezdenének, és időt ad arra, hogy nyugodtan cselekedj – terheld szét a forgalmat, tervezd meg a csomagváltást –, ahelyett, hogy péntek este rögtönöznéd a megoldást.

Főbb megállapítások

  • A HTTP 429 kód az RPM vagy TPM korlát túllépését jelzi
  • A jitterrel kiegészített exponenciális visszalépés az xAI által ajánlott stratégia
  • Éles környezetben egészítsd ki a visszalépést egy kliens oldali sebességkorlátozóval és egy áramkör megszakítóval
  • Soha ne próbáld meg azonnal újra: várj legalább 1 másodpercet az első újrapróbálkozás előtt
  • Figyeld a 429-es hibák arányát a metrikáidban a méretezés hiányosságának indikátoraként