Rate Limiting

🚦 Política de Rate Limiting

Limites por Endpoint

Endpoint	Limite	Janela
POST /api/v1/payments	100 requests	1 hora
GET /api/v1/payments	500 requests	1 hora
POST /api/v1/auth/login	10 requests	15 minutos
GET /api/monitoring/*	1000 requests	1 hora
Geral	1000 requests	1 hora

Identificação do Cliente

• IP Address: Para requests não autenticados

• API Key: Para requests com API key

• User ID: Para requests autenticados com JWT

📊 Headers de Rate Limit

Headers Retornados

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1640999999
X-RateLimit-Window: 3600

Header	Descrição
X-RateLimit-Limit	Limite máximo para a janela
X-RateLimit-Remaining	Requests restantes
X-RateLimit-Reset	Timestamp de reset (Unix)
X-RateLimit-Window	Tamanho da janela (segundos)

⚠️ Resposta de Rate Limit

HTTP 429 - Too Many Requests

{
  "success": false,
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Too many requests",
    "details": "Rate limit of 1000 requests per hour exceeded",
    "retry_after": 3600
  }
}

Headers Adicionais

HTTP/1.1 429 Too Many Requests
Retry-After: 3600
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1640999999

🛡️ Estratégias de Rate Limiting

1. Fixed Window

• Janela fixa (ex: 1 hora)

• Reset no início da próxima janela

• Simples de implementar

2. Sliding Window

• Janela deslizante

• Mais suave na distribuição

• Usado para endpoints críticos

3. Token Bucket

• Balde de tokens que se repõe

• Permite rajadas controladas

• Usado para pagamentos

🔧 Configuração

Variáveis de Ambiente

# Rate limit geral
RATE_LIMIT_WINDOW_MS=3600000
RATE_LIMIT_MAX_REQUESTS=1000

# Rate limit para pagamentos
PAYMENT_RATE_LIMIT_WINDOW_MS=3600000
PAYMENT_RATE_LIMIT_MAX_REQUESTS=100

# Rate limit para login
AUTH_RATE_LIMIT_WINDOW_MS=900000
AUTH_RATE_LIMIT_MAX_REQUESTS=10

Configuração Redis

const redis = require('redis');
const client = redis.createClient(process.env.REDIS_URL);

const rateLimiter = {
  windowMs: 60 * 60 * 1000, // 1 hora
  max: 1000, // máximo de requests
  standardHeaders: true,
  legacyHeaders: false,
  store: new RedisStore({
    client: client,
    prefix: 'rl:'
  })
};

📈 Rate Limiting Avançado

Por Tier de Cliente

Tier	Limite por Hora	Burst Limit
Free	100	10
Basic	1,000	50
Premium	10,000	200
Enterprise	100,000	1,000

Por Tipo de Operação

const limits = {
  'payment:create': { max: 100, windowMs: 3600000 },
  'payment:read': { max: 500, windowMs: 3600000 },
  'payment:refund': { max: 50, windowMs: 3600000 },
  'auth:login': { max: 10, windowMs: 900000 },
  'webhook:receive': { max: 10000, windowMs: 3600000 }
};

🔍 Monitoramento

Métricas Coletadas

• Requests por endpoint

• Rate limit hits por cliente

• Distribuição temporal de requests

• Clientes mais ativos

Alertas

- alert: HighRateLimitHits
  expr: rate(rate_limit_hits_total[5m]) > 10
  for: 2m
  labels:
    severity: warning
  annotations:
    summary: High rate limit violations detected

Dashboard

// Métricas em tempo real
const rateLimitMetrics = {
  totalRequests: 50432,
  rateLimitHits: 245,
  hitRate: 0.48, // %
  topClients: [
    { client: 'api_key_123', hits: 50 },
    { client: '192.168.1.100', hits: 30 }
  ]
};

🔄 Bypass e Whitelist

Whitelist de IPs

RATE_LIMIT_WHITELIST_IPS=192.168.1.0/24,10.0.0.0/8

Bypass para Admins

app.use('/api', (req, res, next) => {
  if (req.user && req.user.role === 'admin') {
    return next(); // Bypass rate limit para admins
  }
  return rateLimiter(req, res, next);
});

📱 Implementação no Cliente

Handling Rate Limits

async function makeApiCall(endpoint, data) {
  try {
    const response = await fetch(endpoint, {
      method: 'POST',
      body: JSON.stringify(data),
      headers: { 'Content-Type': 'application/json' }
    });

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      await sleep(retryAfter * 1000);
      return makeApiCall(endpoint, data); // Retry
    }

    return response.json();
  } catch (error) {
    console.error('API call failed:', error);
    throw error;
  }
}

Exponential Backoff

async function callWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await sleep(delay);
        continue;
      }
      throw error;
    }
  }
}

🛠️ Configuração por Ambiente

Desenvolvimento

const devLimits = {
  windowMs: 15 * 60 * 1000, // 15 minutos
  max: 100, // Menor limite para testes
  skip: (req) => req.ip === '127.0.0.1' // Skip localhost
};

Produção

const prodLimits = {
  windowMs: 60 * 60 * 1000, // 1 hora
  max: 1000,
  standardHeaders: true,
  store: redisStore, // Usar Redis em produção
  keyGenerator: (req) => {
    return req.apiKey || req.ip; // Usar API key quando disponível
  }
};

---

Documentação atualizada: December 2024