Limitação de taxa e gerenciamento de cotas
Defina cotas por usuário, organização e endpoint para que um único locatário não consuma todo o seu orçamento da OpenAI.
Limitação de taxa e gerenciamento de cotas é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Por que Usar Limites?
Sem limites, um único cliente abusivo pode:
- Esgotar seu orçamento da OpenAI
- Ocupar os recursos de outros usuários
- Sobrecarregar seu serviço com um ataque DDoS
Limites de taxa e cotas protegem custos, latência e equidade.
Limite de Taxa vs Cota
- Limite de taxa — requisições por segundo/minuto (curto prazo)
- Cota — orçamento total por dia/mês (longo prazo)
Você precisa de ambos.
Algoritmo do Balde de Tokens
O algoritmo clássico: cada usuário tem um “balde” que é reabastecido a uma taxa fixa. Cada requisição consome um token. Sem tokens, não há serviço.
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))
Cotas Baseadas em Custos
Limite valores em dinheiro, não apenas requisições:
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)Limites de Concorrência
Limite também as requisições em andamento por usuário:
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.Limite de Taxa Global
Proteja as APIs de LLM externas contra o seu próprio serviço:
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)Limites de Taxa Distribuídos
Se você executar vários servidores de API, os limites de taxa precisarão ser compartilhados. Redis é a infraestrutura de back-end padrão; Cloudflare e Kong oferecem alternativas gerenciadas.
Permissões para Picos
O uso real ocorre em picos. Permita um pequeno pico (por exemplo, 30 requisições de uma vez se a taxa for 10/s). As implementações de balde de tokens lidam com isso naturalmente usando uma `capacity` maior.
Alertas
Gere um alerta quando:
- Os acionamentos do limite global de taxa excederem X por minuto
- Qualquer usuário estiver constantemente no limite (provavelmente precisa de um upgrade ou tem um erro)
- O orçamento diário se aproximar de 80%
Proteção em Duas Camadas
Por que ter BOTH limites de taxa AND cotas?
Recapitulação
Balde de tokens para limites de taxa, contadores de custos para cotas, limites de concorrência por usuário, disjuntor global e respostas 429 úteis com Retry-After.
Aprenda AI Agents com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 60
- Aulas
- 239
Perguntas Frequentes
A aula “Limitação de taxa e gerenciamento de cotas” é grátis?
Sim — o texto completo de “Limitação de taxa e gerenciamento de cotas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.
O que vou aprender em “Limitação de taxa e gerenciamento de cotas”?
Defina cotas por usuário, organização e endpoint para que um único locatário não consuma todo o seu orçamento da OpenAI. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Agents?
Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Limitação de taxa e gerenciamento de cotas”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Agents?
Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Disponibilizando agentes por trás de uma API
- Fluxos de trabalho assíncronos e tarefas em segundo plano
- Limitação de taxa e gerenciamento de cotas
- Implantações blue-green e canário para agentes