Ograniczanie częstotliwości i zarządzanie limitami
Ustalaj limity dla użytkownika, organizacji i endpointu, aby jeden klient nie wykorzystał całego budżetu OpenAI.
Ograniczanie częstotliwości i zarządzanie limitami to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Po co limity?
Bez limitów pojedynczy nadużywający klient może:
- Wydać cały budżet OpenAI
- Zablokować dostęp innym użytkownikom
- Przeprowadzić DDoS na Twoją usługę
Limity szybkości i limity budżetowe chronią koszty, opóźnienia i sprawiedliwy dostęp.
Limit szybkości a limit budżetowy
- Limit szybkości — liczba żądań na sekundę/minutę (krótki okres)
- Limit budżetowy — łączny budżet na dzień/miesiąc (długi okres)
Potrzebne są oba.
Algorytm token bucket
Klasyczny algorytm: każdy użytkownik ma „wiadro”, które uzupełnia się ze stałą szybkością. Każde żądanie zużywa jeden token. Brak tokenów oznacza brak obsługi.
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 TrueFastAPI 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))
Limity budżetowe oparte na kosztach
Należy ograniczać wydatki, a nie tylko liczbę żądań:
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)Limity współbieżności
Należy również ograniczyć liczbę żądań będących w toku dla każdego użytkownika:
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.Globalny limit szybkości
Należy chronić podrzędne API LLM przed własną usługą:
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)Rozproszone limity szybkości
Jeśli działa wiele serwerów API, limity szybkości muszą być współdzielone. Redis jest standardowym backendem; Cloudflare i Kong oferują zarządzane alternatywy.
Zezwalanie na nagłe wzrosty ruchu
Rzeczywiste użycie ma charakter skokowy. Należy zezwolić na niewielki nagły wzrost (np. 30 żądań naraz przy szybkości 10/s). Implementacje token bucket obsługują to naturalnie dzięki większej wartości `capacity`.
Alerty
Alert należy wysłać, gdy:
- Globalny limit szybkości zostanie przekroczony ponad X razy na minutę
- Dowolny użytkownik stale osiąga swój limit (prawdopodobnie potrzebuje wyższego planu albo wystąpił błąd)
- Dzienny budżet zbliża się do 80%
Dwuwarstwowa ochrona
Dlaczego potrzebne są ZARÓWNO limity szybkości, JAK I limity budżetowe?
Podsumowanie
Token bucket do limitów szybkości, liczniki kosztów do limitów budżetowych, limity współbieżności na użytkownika, globalny circuit breaker oraz pomocne odpowiedzi 429 z nagłówkiem Retry-After.
Ucz się AI Agents dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 60
- Lekcje
- 239
Często zadawane pytania
Czy lekcja „Ograniczanie częstotliwości i zarządzanie limitami” jest bezpłatna?
Tak — pełny tekst „Ograniczanie częstotliwości i zarządzanie limitami” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.
Co nauczysz się w „Ograniczanie częstotliwości i zarządzanie limitami”?
Ustalaj limity dla użytkownika, organizacji i endpointu, aby jeden klient nie wykorzystał całego budżetu OpenAI. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć AI Agents?
Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Ograniczanie częstotliwości i zarządzanie limitami”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?
Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Udostępnianie agentów za API
- Asynchroniczne przepływy pracy i zadania w tle
- Ograniczanie częstotliwości i zarządzanie limitami
- Wdrożenia blue-green i canary dla agentów