PricingLoginStart free
AI-agenter · leksjon

Begrensning av forespørselsfrekvens og kvotehåndtering

Bruk kvoter per bruker, organisasjon og endepunkt, slik at én leietaker ikke kan bruke opp OpenAI-budsjettet ditt.

Leksjon 3 av 415 trinn

Begrensning av forespørselsfrekvens og kvotehåndtering er en gratis leksjon i AI-agenter på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-agenter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Deler av denne leksjonen er ennå ikke oversatt og vises på engelsk.

Hvorfor begrensninger?

Uten begrensninger kan én misbrukende klient:

  • bruke opp OpenAI-budsjettet
  • fortrenge andre brukere
  • utsette tjenesten for et DDoS-angrep

Hastighetsgrenser og kvoter beskytter kostnader, svartid og rettferdighet.

Hastighetsgrense kontra kvote

  • Hastighetsgrense — antall forespørsler per sekund/minutt (kort sikt)
  • Kvote — totalt budsjett per dag/måned (lang sikt)

Begge deler er nødvendig.

Token-bøtte-algoritmen

Den klassiske algoritmen: Hver bruker har en «bøtte» som fylles på med en fast hastighet. Hver forespørsel bruker ett token. Ingen tokens betyr ingen tjeneste.

Redis Token Bucket Example

def allow(user_id, rate=10, capacity=30):
    key = f'rate:{user_id}'
    now = time.time()
    pipe = redis.pipeline()
    pipe.hgetall(key)
    state, _ = pipe.execute()
    tokens = float(state.get('tokens', capacity))
    last = float(state.get('last', now))
    tokens = min(capacity, tokens + (now - last) * rate)
    if tokens < 1:
        return False
    tokens -= 1
    redis.hset(key, mapping={'tokens': tokens, 'last': now})
    redis.expire(key, 60)
    return True

FastAPI Integration with slowapi

# pip install slowapi
from slowapi import Limiter
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter

@app.post('/agents/qa')
@limiter.limit('10/minute')
def qa(req: AgentRequest):
    ...

Different Limits Per Tier

class User:
    def __init__(self, is_pro):
        self.is_pro = is_pro

class State:
    def __init__(self, is_pro):
        self.user = User(is_pro)

class Req:
    def __init__(self, is_pro):
        self.state = State(is_pro)

def limit_for(req):
    return '100/minute' if req.state.user.is_pro else '10/minute'

def qa(req):
    limit = limit_for(req)
    print(f'user is_pro={req.state.user.is_pro} -> rate limit {limit}')
    return limit

qa(Req(is_pro=True))
qa(Req(is_pro=False))

Kostnadsbaserte kvoter

Begrens beløp, ikke bare antall forespørsler:

def check_budget(user_id, predicted_cost):
    key = f'cost:{user_id}:{date.today()}'
    spent = float(redis.get(key) or 0)
    if spent + predicted_cost > daily_budget(user_id):
        raise HTTPException(429, 'Daily budget exceeded')

# After the call:
redis.incrbyfloat(key, actual_cost)
redis.expireat(key, midnight_tomorrow_ts)

Grenser for samtidige forespørsler

Begrens også antallet forespørsler per bruker som er under behandling:

key = f'inflight:{user_id}'
redis.sadd(key, request_id)
if redis.scard(key) > 3:
    raise HTTPException(429, 'Too many concurrent requests')
# Remove from set when the request finishes.

Global hastighetsgrense

Beskytt underliggende LLM-API-er mot deres egen tjeneste:

global_key = 'rate:global:llm'
if redis.incr(global_key) > 60:   # 60 calls per second
    raise HTTPException(503, 'Service overloaded')
redis.expire(global_key, 1)

Return Useful Errors

headers = {
    'X-RateLimit-Limit': '60',
    'X-RateLimit-Remaining': '0',
    'X-RateLimit-Reset': str(reset_time),
    'Retry-After': '30'
}
return JSONResponse({'error': 'rate-limited'}, status_code=429, headers=headers)

Distribuerte hastighetsgrenser

Hvis flere API-servere kjøres, må hastighetsgrensene deles mellom dem. Redis er standardbackend, mens Cloudflare og Kong har administrerte alternativer.

Tillatte trafikkøkninger

Reell bruk kommer i rykk og napp. Tillat en liten trafikkøkning (for eksempel 30 forespørsler samtidig hvis hastigheten er 10 per sekund). Implementasjoner av token-bøtter håndterer dette naturlig med en høyere `capacity`.

Varsling

Send et varsel når:

  • treff på den globale hastighetsgrensen utløses mer enn X ganger per minutt
  • en bruker konsekvent ligger på grensen (brukeren trenger sannsynligvis en oppgradering, eller det finnes en feil)
  • dagsbudsjettet nærmer seg 80 %

Beskyttelse i to lag

Hvorfor ha BÅDE hastighetsgrenser OG kvoter?

Besvar den i den interaktive leksjonen

Oppsummering

Bruk token-bøtter for hastighetsgrenser, kostnadstellere for kvoter, grenser for samtidighet per bruker, en global kretsbryter og nyttige 429-svar med Retry-After.

Gratis å komme i gang

Lær deg AI-agenter med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
60
Leksjoner
239
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Begrensning av forespørselsfrekvens og kvotehåndtering» gratis?

Ja – hele teksten i «Begrensning av forespørselsfrekvens og kvotehåndtering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI-agenter-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Begrensning av forespørselsfrekvens og kvotehåndtering»?

Bruk kvoter per bruker, organisasjon og endepunkt, slik at én leietaker ikke kan bruke opp OpenAI-budsjettet ditt. Du øver på AI-agenter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI-agenter?

Ingen tidligere erfaring er nødvendig. AI-agenter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Begrensning av forespørselsfrekvens og kvotehåndtering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI-agenter-leksjonen?

Ja. Alle AI-agenter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Eksponere agenter bak et API
  2. Asynkrone arbeidsflyter og bakgrunnsjobber
  3. Begrensning av forespørselsfrekvens og kvotehåndtering
  4. Blue-green- og canary-distribusjoner for agenter
← Tilbake til AI-agenter