Especialista em Limitação de Taxa e Aceleração de API

O que Especialista em Limitação de Taxa e Aceleração de API faz?

Implemente limitação de taxa justa e eficiente usando balde de fichas, janela deslizante e algoritmos de janela fixa com contadores distribuídos apoiados por Redis.

Gatilhos de Ativação

Ativar em: "limitação de taxa", "aceleração", "balde de fichas", "janela deslizante", "abuso de API", "proteção DDoS", "gerenciamento de cota", "429 Muitas Requisições", "limites de requisição"

NÃO para: configuração de gateway de API → api-gateway-reverse-proxy-expert | Estratégias de cache → cache-strategy-invalidation-expert | Regras de WAF/firewall → skill de segurança relevante

Início Rápido

1. Defina limites — requisições/minuto por chave de API, IP ou nível de usuário
2. Escolha o algoritmo — janela deslizante (precisa), balde de fichas (para picos), janela fixa (simples)
3. Use Redis — operações atômicas com MULTI/EXEC ou scripts Lua para limitação distribuída
4. Retorne cabeçalhos apropriados — X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After
5. Diferencie níveis — gratuito/pro/empresarial obtêm limites diferentes

Capacidades Principais

Domínio	Tecnologias
Algoritmos	Balde de fichas, janela deslizante (log), contador de janela deslizante, janela fixa
Armazenamento	Redis 7.4+, Valkey, DragonflyDB, em memória (nó único)
Bibliotecas	rate-limiter-flexible, @upstash/ratelimit, express-rate-limit
Plugins de Gateway	Kong rate-limiting, Nginx limit_req, Traefik ratelimit
Padrões	RFC 6585 (429), Cabeçalhos RateLimit (draft-ietf-httpapi-ratelimit)

Padrões de Arquitetura

Contador de Janela Deslizante (Redis Lua)

-- Script Lua Redis: limitador de janela deslizante
-- KEYS[1] = chave do limite de taxa
-- ARGV[1] = tamanho da janela (segundos)
-- ARGV[2] = máximo de requisições
-- ARGV[3] = timestamp atual

local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

-- Remove entradas expiradas
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- Conta a janela atual
local count = redis.call('ZCARD', key)

if count < limit then
  redis.call('ZADD', key, now, now .. '-' .. math.random(1000000))
  redis.call('EXPIRE', key, window)
  return {1, limit - count - 1}  -- permitido, restantes
else
  return {0, 0}  -- negado, 0 restantes
end

Limitação de Taxa Multi-Nível

Requisição → Limitação por IP (100/min)
              │ passou
              ↓
         Verificação de Autenticação → Limitação por Chave de API (por nível)
              │           Gratuito:  60/min
              │           Pro:   600/min
              │           Empresarial: 6000/min
              ↓ passou
         Limitação por Endpoint (por rota)
              │   POST /upload: 10/min
              │   GET /search:  120/min
              ↓ passou
         Processar Requisição

Cabeçalhos de Resposta (Padrão IETF Draft)

// Middleware: anexar cabeçalhos de limite de taxa
function rateLimitHeaders(limit: number, remaining: number, resetAt: number) {
  return {
    'RateLimit-Limit': limit.toString(),
    'RateLimit-Remaining': Math.max(0, remaining).toString(),
    'RateLimit-Reset': Math.ceil((resetAt - Date.now()) / 1000).toString(),
  };
}

// Na resposta 429:
res.status(429).set({
  ...rateLimitHeaders(limit, 0, resetAt),
  'Retry-After': Math.ceil((resetAt - Date.now()) / 1000).toString(),
}).json({ error: 'Muitas Requisições', retryAfter: resetAt });

Anti-Padrões

1. Contadores em memória em sistemas distribuídos — os limites de taxa devem ser compartilhados entre instâncias; use Redis ou equivalente
2. Falta do cabeçalho Retry-After — respostas 429 sem Retry-After forçam os clientes a adivinhar, levando a uma tempestade de requisições
3. Limitação apenas por IP — limites por IP não detectam abuso autenticado e penalizam IPs compartilhados (NAT, VPN); combine com limites por chave de API
4. Corte abrupto sem pico — balde de fichas permite pequenos picos enquanto mantém a taxa média; janela fixa pura é muito rígida
5. Sem limite de taxa em APIs internas — um serviço interno mal comportado pode causar falhas em cascata no seu banco de dados; sempre limite

Lista de Verificação de Qualidade

• Os limites de taxa usam armazenamento distribuído (Redis/Valkey), não em memória
• Cabeçalhos RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset em cada resposta
• Cabeçalho Retry-After em respostas 429
• Limites diferentes por nível de autenticação (gratuito/pro/empresarial)
• Limites por endpoint para operações caras (uploads, pesquisa)
• Script Lua ou pipeline atômico para incremento do contador (sem condições de corrida)
• Chaves de limite de taxa incluem identidade (chave de API) e escopo (endpoint)
• Painel de monitoramento mostra acertos de limite, negações e maiores consumidores
• Degradação graciosa: enfileirar ou desacelerar em vez de rejeitar abruptamente, quando possível