Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Obmedzovanie rýchlosti a prevencia zneužívania

Lekcia 8 z 14 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Prečo obmedzovať požiadavky?
  2. Dva spôsoby počítania
  3. Rozpoznanie bota
  4. Odstupňované sankcie
  5. Na poradí kontrol záleží
  6. Kľúčové poznatky

Prečo obmedzovať požiadavky?

Aplikácie umelej inteligencie sú hlavným terčom zneužívania z dôvodu, ktorý pri tradičných aplikáciách neexistoval: každé volanie modelu stojí peniaze. Tradičné REST API vystavené záplave požiadaviek sa spomalí a nakoniec spadne, ale nevyprázdni ti bankový účet. Aplikácia LLM však naďalej dokonale odpovedá, zatiaľ čo faktúra raketovo stúpa. Bez obmedzovania rýchlosti môže útočník počas niekoľkých minút zničiť tvoj rozpočet na API, spustiť automatizované útoky vstrekovaním promptov alebo využiť tvoju infraštruktúru na generovanie spamu na tvoje náklady.

Dva spôsoby počítania

Posuvné okno je základným mechanizmom. Zaznamenáva časovú pečiatku každej požiadavky, zahodí tie, ktoré vypadli z okna, a zvyšok porovná so stropom. Jeho nadradenosť oproti pevnému okne spočíva v detaile, ktorý má v praxi význam: pri pevnom okne, ktoré sa resetuje každú minútu, môže útočník umiestniť svoju kvótu na koniec jednej minúty a znova na začiatok nasledujúcej, čím efektívne zdvojnásobí povolenú priepustnosť počas niekoľkých sekúnd. Posuvné okno takúto medzeru nezanecháva.

Funkcia navyše nevracia jednoduchú boolean hodnotu; vracia slovník ukazujúci zostávajúce požiadavky a čas do resetu. Tieto hodnoty vypĺňajú hlavičky odpovede, ktoré tvoji legitímni klienti využijú na samoreguláciu – dobre navrhnutá integrácia radšej počká, než aby bombardovala koncový bod.

import time
from collections import defaultdict

class RateLimiter:
    """Sliding window rate limiter."""

    def __init__(self, max_requetes: int, fenetre_secondes: int):
        self.max_requetes = max_requetes
        self.fenetre = fenetre_secondes
        self.requetes: dict[str, list[float]] = defaultdict(list)

    def autoriser(self, identifiant: str) -> tuple[bool, dict]:
        """Checks if a request is allowed for this identifier."""
        maintenant = time.time()
        seuil = maintenant - self.fenetre

        # Clean up old requests
        self.requetes[identifiant] = [
            t for t in self.requetes[identifiant] if t > seuil
        ]

        nb_requetes = len(self.requetes[identifiant])

        if nb_requetes >= self.max_requetes:
            prochain_slot = self.requetes[identifiant][0] + self.fenetre
            return False, {
                "restantes": 0,
                "reset_dans": round(prochain_slot - maintenant, 1),
            }

        self.requetes[identifiant].append(maintenant)
        return True, {
            "restantes": self.max_requetes - nb_requetes - 1,
            "reset_dans": round(self.fenetre - (maintenant - self.requetes[identifiant][0]), 1),
        }

# Configuration by role
limiteurs = {
    "gratuit": RateLimiter(max_requetes=10, fenetre_secondes=60),
    "premium": RateLimiter(max_requetes=60, fenetre_secondes=60),
    "api": RateLimiter(max_requetes=200, fenetre_secondes=60),
}

Samotné počítanie požiadaviek však nestačí, pretože nie všetky požiadavky sú rovnaké. Desať krátkych otázok stojí zlomok toho, čo stojí jedna jediná požiadavka sprevádzaná päťdesiatstranovým dokumentom. Obmedzovač na báze požiadaviek by pustil tú druhú a zablokoval tie prvé, čo je presný opak toho, čo diktuje ekonomika služieb. Rozpočet tokenov obnovuje proporčnosť s denným resetom a zaznamenávaním skutočného využitia až dodatočne, keďže odhad urobený pred volaním nepozná dĺžku odpovede.

class TokenBudgetLimiter:
    """Limits token spending per user."""

    def __init__(self, budget_tokens_jour: int, cout_par_1k_input: float, cout_par_1k_output: float):
        self.budget_jour = budget_tokens_jour
        self.cout_input = cout_par_1k_input
        self.cout_output = cout_par_1k_output
        self.usage: dict[str, dict] = defaultdict(lambda: {"tokens_in": 0, "tokens_out": 0, "date": ""})

    def verifier_budget(self, user_id: str, tokens_estimes: int) -> tuple[bool, dict]:
        """Checks if the user still has budget."""
        from datetime import date
        aujourd_hui = str(date.today())

        # Daily reset
        if self.usage[user_id]["date"] != aujourd_hui:
            self.usage[user_id] = {"tokens_in": 0, "tokens_out": 0, "date": aujourd_hui}

        total_utilise = self.usage[user_id]["tokens_in"] + self.usage[user_id]["tokens_out"]
        restant = self.budget_jour - total_utilise

        if tokens_estimes > restant:
            return False, {"restant": restant, "demande": tokens_estimes}

        return True, {"restant": restant - tokens_estimes}

    def enregistrer_usage(self, user_id: str, tokens_in: int, tokens_out: int):
        """Records actual usage after a call."""
        self.usage[user_id]["tokens_in"] += tokens_in
        self.usage[user_id]["tokens_out"] += tokens_out

# Example: 100K tokens/day for free users
budget = TokenBudgetLimiter(
    budget_tokens_jour=100_000,
    cout_par_1k_input=0.005,
    cout_par_1k_output=0.015,
)

Rozpoznanie bota

Metodický útočník zostáva pod tvojimi stropmi: stačí, ak spomalí. Detekcia zneužívania si preto vyžaduje pozerať sa skôr na tvar premávky než na jej objem. Štyri nižšie implementované signály sa navzájom dobre dopĺňajú. Identická repetícia prezrádza skript zaseknutý v slučke. Prudký nárast požiadaviek počas niekoľkých sekúnd naznačuje tempo, ktoré žiadny človek pri klávesnici neudrží. Správa dlhá desaťtisíce znakov signalizuje pokus o objemové vstrekovanie. Štvrtý signál je najzaujímavejší: rigorózne identické dĺžky správ počas desiatich po sebe idúcich požiadaviek odhaľujú fuzzer, ktorý mení obsah pri zachovaní konštantnej štruktúry, zatiaľ čo skutočný používateľ píše vety nepravidelných dĺžok.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ProfilUtilisateur:
    user_id: str
    requetes_recentes: list[dict] = field(default_factory=list)
    alertes: list[str] = field(default_factory=list)

class DetecteurAbus:
    """Detects automated abuse patterns."""

    def __init__(self):
        self.profils: dict[str, ProfilUtilisateur] = {}

    def analyser(self, user_id: str, message: str) -> list[str]:
        """Analyzes a message to detect abuse patterns."""
        if user_id not in self.profils:
            self.profils[user_id] = ProfilUtilisateur(user_id=user_id)

        profil = self.profils[user_id]
        alertes = []

        # Pattern 1: repeated identical messages
        if profil.requetes_recentes:
            derniers_messages = [r["message"] for r in profil.requetes_recentes[-5:]]
            if derniers_messages.count(message) >= 3:
                alertes.append("SPAM: identical message repeated 3+ times")

        # Pattern 2: abnormal frequency
        maintenant = datetime.now()
        recentes = [
            r for r in profil.requetes_recentes
            if (maintenant - r["timestamp"]).seconds < 10
        ]
        if len(recentes) > 5:
            alertes.append("FLOOD: 5+ requests in 10 seconds")

        # Pattern 3: very long messages (volumetric injection attempt)
        if len(message) > 10000:
            alertes.append(f"VOLUME: message of {len(message)} characters")

        # Pattern 4: systematic variation (automated fuzzing)
        if len(profil.requetes_recentes) >= 10:
            longueurs = [len(r["message"]) for r in profil.requetes_recentes[-10:]]
            if max(longueurs) - min(longueurs) < 5 and len(set(longueurs)) == 1:
                alertes.append("FUZZING: identical message length (bot)")

        # Record
        profil.requetes_recentes.append({
            "message": message,
            "timestamp": maintenant,
            "alertes": alertes,
        })

        return alertes

detecteur = DetecteurAbus()

Odstupňované sankcie

Zákaz pri prvom upozornení by bola nákladná chyba, pretože žiadny z týchto signálov nie je neomylný: používateľ, ktorý nervózne obnovuje stránku, spustí detektor prudkého nárastu, hoci nie je zlomyseľný. Progresívny zákaz akumuluje skóre a spúšťa proporčné reakcie – upozornenie, potom obmedzenie rýchlosti, následne dočasná hodinová blokáda a nakoniec dvadsaťštyri hodín. Každá úroveň dáva legitímnemu používateľovi šancu dostať sa z tejto trajektórie, zatiaľ čo automatizovaný skript ju nasleduje až do konca.

class GestionBannissement:
    """Progressive banning: warning, throttling, blocking."""

    def __init__(self):
        self.compteurs: dict[str, int] = defaultdict(int)
        self.bans: dict[str, float] = {}

    def signaler(self, user_id: str, severite: int = 1) -> str:
        """Reports abuse and applies the appropriate sanction."""
        self.compteurs[user_id] += severite
        score = self.compteurs[user_id]

        if score >= 10:
            self.bans[user_id] = time.time() + 86400  # Ban 24h
            return "BAN_24H"
        elif score >= 5:
            self.bans[user_id] = time.time() + 3600  # Ban 1h
            return "BAN_1H"
        elif score >= 3:
            return "RALENTIR"  # Reduced rate limit
        else:
            return "AVERTIR"

    def est_banni(self, user_id: str) -> bool:
        """Checks if a user is currently banned."""
        if user_id in self.bans:
            if time.time() < self.bans[user_id]:
                return True
            del self.bans[user_id]
        return False

Na poradí kontrol záleží

Záverečná zostava reťazí štyri mechanizmy pred zavolaním modelu a toto poradie sa riadi jednoduchým pravidlom: od najmenej nákladného po najnákladnejšie. Kontrola zákazu je vyhľadávaniem v slovníku, obmedzovanie rýchlosti skenuje krátky zoznam, detekcia zneužívania analyzuje históriu a kontrola rozpočtu prichádza tesne pred fakturované volanie. Obrátenie tejto postupnosti by znamenalo platiť za behaviorálnu analýzu pre používateľa, ktorý je už zakázaný. Posledným krokom, na ktorý sa najčastejšie zabúda, je zaznamenanie skutočného využitia z poľa usage v odpovedi, bez ktorého by sa tvoj rozpočet odklonil od odhadu urobeného pred volaním.

from openai import OpenAI

class APISecurisee:
    """API with integrated rate limiting and abuse detection."""

    def __init__(self):
        self.client = OpenAI()
        self.rate_limiter = RateLimiter(max_requetes=20, fenetre_secondes=60)
        self.budget = TokenBudgetLimiter(100_000, 0.005, 0.015)
        self.detecteur = DetecteurAbus()
        self.bans = GestionBannissement()

    def traiter(self, user_id: str, message: str) -> str:
        # Step 1: check ban status
        if self.bans.est_banni(user_id):
            return "Your access is temporarily suspended."

        # Step 2: rate limiting
        autorise, info = self.rate_limiter.autoriser(user_id)
        if not autorise:
            return f"Too many requests. Try again in {info['reset_dans']}s."

        # Step 3: abuse detection
        alertes = self.detecteur.analyser(user_id, message)
        if alertes:
            action = self.bans.signaler(user_id, severite=len(alertes))
            if action.startswith("BAN"):
                return "Abusive behavior detected. Access suspended."

        # Step 4: check token budget
        tokens_estimes = len(message) // 4 + 500
        ok, budget_info = self.budget.verifier_budget(user_id, tokens_estimes)
        if not ok:
            return "Daily token budget exhausted."

        # Step 5: call the model
        response = self.client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[{"role": "user", "content": message}],
        )

        # Record actual usage
        usage = response.usage
        self.budget.enregistrer_usage(user_id, usage.prompt_tokens, usage.completion_tokens)

        return response.choices[0].message.content

Kľúčové poznatky

  • Obmedzovanie rýchlosti chráni tvoj rozpočet na API a predchádza automatizovaným útokom
  • Kombinuj obmedzenia na požiadavku (posuvné okno) a obmedzenia na náklady (tokeny)
  • Detekcia zneužívania identifikuje vzorce: spam, záplava, fuzzing, objem
  • Progresívny zákaz (upozorniť, spomaliť, zablokovať) predchádza trvalým falošným poplachom
  • Každá odpoveď by mala obsahovať hlavičky obmedzenia rýchlosti, aby informovali používateľa