Back-end9 min de leitura

Rate Limiting em APIs Node.js: Algoritmos, Redis e Estratégias por Rota

Fixed Window vs Sliding Window vs Token Bucket. Implementação com rate-limiter-flexible no Redis (compartilhado entre múltiplas instâncias). Limites diferentes por rota (login mais restrito), bloqueio progressivo por IP e headers de resposta corretos.

12 de agosto de 2026

Uma API sem Rate Limiting é um convite para ataques de força bruta no endpoint de login, enumeração de usuários via reset de senha, e DoS via requisições excessivas. Mais importante: em ambientes com múltiplas instâncias do Node.js (PM2 cluster ou múltiplos containers), o rate limiting em memória local é inútil — cada instância conta separado, e o atacante distribui requisições entre elas.

A solução é centralizar a contagem no Redis: compartilhado entre todas as instâncias, atômico (sem race condition) e extremamente rápido. A biblioteca rate-limiter-flexible implementa vários algoritmos de forma eficiente.

Os Três Algoritmos Principais

Fixed Window — conta requisições em janelas fixas (ex: 100 req/minuto a partir de 09:00). Problema: permite burst no final/início de janelas — 100 req às 09:59 + 100 req às 10:00 = 200 req em 2 segundos.
Sliding Window — janela que desliza com o tempo. Mais preciso, sem o problema de burst. Custo de memória ligeiramente maior.
Token Bucket — cada requisição consome um token. Tokens são reabastecidos a uma taxa constante. Permite bursts controlados — ideal para APIs que precisam de flexibilidade mas com limite de throughput.

bash

1npm install rate-limiter-flexible ioredis
npm install rate-limiter-flexible ioredis

Configuração Base com Redis

O ponto crítico é definir limites diferentes por rota. Um endpoint de listagem de produtos pode ter 200 req/min sem problema. Um endpoint de login não deveria ultrapassar 5 tentativas em 15 minutos por IP — qualquer número maior já é sinal de ataque de força bruta. O blockDuration agrava o bloqueio progressivamente: ao exceder o limite de login, o IP fica bloqueado por 30 minutos, desincentivando tentativas futuras.

RateLimiters.ts

1import { RateLimiterRedis } from 'rate-limiter-flexible';
import { RateLimiterRedis } from 'rate-limiter-flexible';
2import { redisClient } from '../redis/RedisClient';
import { redisClient } from '../redis/RedisClient';
3

4// Rate Limiter global: protege toda a API
// Rate Limiter global: protege toda a API
5export const globalRateLimiter = new RateLimiterRedis({
export const globalRateLimiter = new RateLimiterRedis({
6  storeClient: redisClient,
  storeClient: redisClient,
7  keyPrefix: 'rl:global',
  keyPrefix: 'rl:global',
8  points: 100,          // 100 requisições
  points: 100,          // 100 requisições
9  duration: 60,         // por minuto
  duration: 60,         // por minuto
10  blockDuration: 60,    // Bloqueia por 1min ao exceder (retorna 429)
  blockDuration: 60,    // Bloqueia por 1min ao exceder (retorna 429)
11});
});
12

13// Rate Limiter de login: proteção contra brute force
// Rate Limiter de login: proteção contra brute force
14// Mais restritivo — atacantes testam senhas no endpoint de login
// Mais restritivo — atacantes testam senhas no endpoint de login
15export const loginRateLimiter = new RateLimiterRedis({
export const loginRateLimiter = new RateLimiterRedis({
16  storeClient: redisClient,
  storeClient: redisClient,
17  keyPrefix: 'rl:login',
  keyPrefix: 'rl:login',
18  points: 5,            // 5 tentativas
  points: 5,            // 5 tentativas
19  duration: 15 * 60,    // em 15 minutos
  duration: 15 * 60,    // em 15 minutos
20  blockDuration: 30 * 60, // Bloqueia por 30min ao exceder
  blockDuration: 30 * 60, // Bloqueia por 30min ao exceder
21});
});
22

23// Rate Limiter de reset de senha: mitigação de enumeração de usuários
// Rate Limiter de reset de senha: mitigação de enumeração de usuários
24export const passwordResetRateLimiter = new RateLimiterRedis({
export const passwordResetRateLimiter = new RateLimiterRedis({
25  storeClient: redisClient,
  storeClient: redisClient,
26  keyPrefix: 'rl:pwd-reset',
  keyPrefix: 'rl:pwd-reset',
27  points: 3,
  points: 3,
28  duration: 60 * 60,    // 3 tentativas por hora
  duration: 60 * 60,    // 3 tentativas por hora
29  blockDuration: 60 * 60,
  blockDuration: 60 * 60,
30});
});
31

32// Rate Limiter de API pública: para rotas sem autenticação
// Rate Limiter de API pública: para rotas sem autenticação
33export const publicApiRateLimiter = new RateLimiterRedis({
export const publicApiRateLimiter = new RateLimiterRedis({
34  storeClient: redisClient,
  storeClient: redisClient,
35  keyPrefix: 'rl:public',
  keyPrefix: 'rl:public',
36  points: 30,
  points: 30,
37  duration: 60,
  duration: 60,
38  blockDuration: 5 * 60,
  blockDuration: 5 * 60,
39});
});

Middleware com Headers de Resposta Corretos

Os headers X-RateLimit-* são um padrão de facto que os clientes da API usam para saber quantas requisições ainda têm disponíveis e quando o limite reseta. Sem esses headers, um cliente bem-comportado não tem como saber se deve fazer throttling próprio. Ao retornar 429, o header Retry-After instrui o cliente sobre quando pode tentar novamente — evitando que ele reenvie imediatamente e esgote o limite mais rápido.

O padrão fail-open no bloco catch é uma decisão deliberada de resiliência: se o Redis estiver temporariamente indisponível, a requisição passa mesmo sem verificação de rate limit. A alternativa (fail-closed) bloquearia todos os usuários legítimos enquanto o Redis estiver fora. Para APIs críticas, o fail-open é preferível — o risco de alguns abusos durante uma janela curta de indisponibilidade do Redis é menor que bloquear todos os usuários legítimos.

rateLimitMiddleware.ts

1import type { Request, Response, NextFunction } from 'express';
import type { Request, Response, NextFunction } from 'express';
2import type { RateLimiterRedis } from 'rate-limiter-flexible';
import type { RateLimiterRedis } from 'rate-limiter-flexible';
3

4// Factory: retorna um middleware para o limiter específico
// Factory: retorna um middleware para o limiter específico
5export function createRateLimitMiddleware(
export function createRateLimitMiddleware(
6  limiter: RateLimiterRedis,
  limiter: RateLimiterRedis,
7  // Chave para identificar a entidade: IP, userId ou email
  // Chave para identificar a entidade: IP, userId ou email
8  keyExtractor: (req: Request) => string = (req) => req.ip as string
  keyExtractor: (req: Request) => string = (req) => req.ip as string
9) {
) {
10  return async function rateLimitMiddleware(
  return async function rateLimitMiddleware(
11    req: Request,
    req: Request,
12    res: Response,
    res: Response,
13    next: NextFunction
    next: NextFunction
14  ): Promise<void> {
  ): Promise<void> {
15    try {
    try {
16      const key = keyExtractor(req);
      const key = keyExtractor(req);
17      const result = await limiter.consume(key);
      const result = await limiter.consume(key);
18

19      // Headers padrão de Rate Limiting (RFC 6585)
      // Headers padrão de Rate Limiting (RFC 6585)
20      res.setHeader('X-RateLimit-Limit', limiter.points);
      res.setHeader('X-RateLimit-Limit', limiter.points);
21      res.setHeader('X-RateLimit-Remaining', result.remainingPoints);
      res.setHeader('X-RateLimit-Remaining', result.remainingPoints);
22      res.setHeader(
      res.setHeader(
23        'X-RateLimit-Reset',
        'X-RateLimit-Reset',
24        new Date(Date.now() + result.msBeforeNext).toISOString()
        new Date(Date.now() + result.msBeforeNext).toISOString()
25      );
      );
26

27      next();
      next();
28    } catch (err: unknown) {
    } catch (err: unknown) {
29      // RateLimiterRes: erro ao exceder o limite
      // RateLimiterRes: erro ao exceder o limite
30      if (err && typeof err === 'object' && 'msBeforeNext' in err) {
      if (err && typeof err === 'object' && 'msBeforeNext' in err) {
31        const retryAfterSecs = Math.ceil((err as { msBeforeNext: number }).msBeforeNext / 1000);
        const retryAfterSecs = Math.ceil((err as { msBeforeNext: number }).msBeforeNext / 1000);
32

33        res.setHeader('Retry-After', retryAfterSecs);
        res.setHeader('Retry-After', retryAfterSecs);
34        res.setHeader('X-RateLimit-Remaining', 0);
        res.setHeader('X-RateLimit-Remaining', 0);
35        res.status(429).json({
        res.status(429).json({
36          error: 'Muitas requisições. Tente novamente em alguns instantes.',
          error: 'Muitas requisições. Tente novamente em alguns instantes.',
37          retryAfterSeconds: retryAfterSecs,
          retryAfterSeconds: retryAfterSecs,
38        });
        });
39        return;
        return;
40      }
      }
41

42      // Erro desconhecido — deixa passar (fail open) para não bloquear
      // Erro desconhecido — deixa passar (fail open) para não bloquear
43      // usuários legítimos quando o Redis estiver fora
      // usuários legítimos quando o Redis estiver fora
44      next();
      next();
45    }
    }
46  };
  };
47}
}

Aplicação nas Rotas

A dupla proteção por IP e por email no endpoint de login é uma técnica importante: limitar apenas por IP é facilmente contornável com IPs rotativos, e limitar apenas por email pode causar bloqueio legítimo do usuário por um atacante que tente propositalmente o login do alvo. Com ambos os limitadores aplicados em sequência, o atacante precisa contornar os dois — o que é muito mais difícil na prática.

sessions.routes.ts

1import { Router } from 'express';
import { Router } from 'express';
2import { createRateLimitMiddleware } from '../../rateLimiting/rateLimitMiddleware';
import { createRateLimitMiddleware } from '../../rateLimiting/rateLimitMiddleware';
3import { loginRateLimiter, passwordResetRateLimiter } from '../../rateLimiting/RateLimiters';
import { loginRateLimiter, passwordResetRateLimiter } from '../../rateLimiting/RateLimiters';
4

5const sessionsRouter = Router();
const sessionsRouter = Router();
6

7// Login: rate limit por IP, mas também por email (evita distribuir por IP)
// Login: rate limit por IP, mas também por email (evita distribuir por IP)
8const loginByIp = createRateLimitMiddleware(loginRateLimiter);
const loginByIp = createRateLimitMiddleware(loginRateLimiter);
9const loginByEmail = createRateLimitMiddleware(
const loginByEmail = createRateLimitMiddleware(
10  loginRateLimiter,
  loginRateLimiter,
11  (req) => `email:${String(req.body.email).toLowerCase()}` // Chave por email
  (req) => `email:${String(req.body.email).toLowerCase()}` // Chave por email
12);
);
13

14sessionsRouter.post(
sessionsRouter.post(
15  '/sessions',
  '/sessions',
16  loginByIp,    // Limita por IP
  loginByIp,    // Limita por IP
17  loginByEmail, // E por email (dupla proteção)
  loginByEmail, // E por email (dupla proteção)
18  sessionsController.create
  sessionsController.create
19);
);
20

21// Reset de senha: por IP
// Reset de senha: por IP
22sessionsRouter.post(
sessionsRouter.post(
23  '/forgot-password',
  '/forgot-password',
24  createRateLimitMiddleware(passwordResetRateLimiter),
  createRateLimitMiddleware(passwordResetRateLimiter),
25  forgotPasswordController.execute
  forgotPasswordController.execute
26);
);
27

28export { sessionsRouter };
export { sessionsRouter };

Bloqueio por IP em proxies e load balancers: quando a API está atrás de um Nginx ou CloudFront, req.ip pode retornar o IP do proxy, não do usuário. Configure o Express com app.set('trust proxy', 1) e certifique-se que o proxy envia o header X-Forwarded-For correto. Sem isso, todos os usuários compartilham o mesmo IP (o do proxy) e o rate limiting não funciona.

Conclusão

Rate Limiting com Redis é obrigatório para qualquer API em produção. O limite global protege contra DoS. O limite por rota sensível (login, reset) protege contra brute force e enumeração. A chave composta (IP + email) elimina o bypass por IP distribuído. E o fail-open no Redis offline garante que uma indisponibilidade do Redis não derrube toda a API.