mkdir rate-limiting-aula
cd rate-limiting-aula
npm init -y
npm install express winston ip

📋 Copiar

// app.js

const express = require('express');
const winston = require('winston'); // Para logging profissional
const ip = require('ip'); // Para obter o IP do cliente de forma confiável
const app = express();
const PORT = process.env.PORT || 3000;
// --- Configuração de Logging com Winston (Melhores práticas enterprise) ---
const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
        winston.format.printf(info =>${info.timestamp} ${info.level}: ${info.message})
    ),
    transports: [
        new winston.transports.Console(),
        // Para ambientes de produção, adicione um transporte para arquivo ou serviço de log
        // new winston.transports.File({ filename: 'error.log', level: 'error' }),
        // new winston.transports.File({ filename: 'combined.log' })
    ],
});
// --- Armazenamento em memória para Rate Limiting (Para demonstração e HostGator Plano M) ---
// EM AMBIENTES DE PRODUÇÃO E DISTRIBUÍDOS, SUBSTITUA POR REDIS OU OUTRO STORE DISTRIBUÍDO.
const slidingWindowLogs = new Map(); // Armazena timestamps de requisições por IP
const tokenBuckets = new Map(); // Armazena estado do balde de tokens por IP
// --- Middleware: Sliding Window Log Rate Limiter ---
/* Middleware para aplicar Rate Limiting usando o algoritmo Sliding Window Log.
  Mantém um registro exato de cada requisição e remove as que estão fora da janela.
  @param {number} limit O número máximo de requisições permitidas.
  @param {number} windowMs O tamanho da janela de tempo em milissegundos.
  @returns {Function} O middleware do Express.
 /
const slidingWindowRateLimiter = (limit, windowMs) => (req, res, next) => {
    // Obtém o IP do cliente. req.ip é uma boa heurística, mas proxies podem exigir req.headers['x-forwarded-for']
    const clientIp = req.ip || ip.address(); // ip.address() é fallback para localhost

    // Garante que existe um array de logs para este IP
    if (!slidingWindowLogs.has(clientIp)) {
        slidingWindowLogs.set(clientIp, []);
    }
    const logs = slidingWindowLogs.get(clientIp);
    const now = Date.now();
    // Remove logs antigos que estão fora da janela de tempo
    // O filter cria um novo array, mas para performance em muitos logs, poderia ser um loop com splice
    const activeLogs = logs.filter(timestamp => timestamp > now - windowMs);
    slidingWindowLogs.set(clientIp, activeLogs); // Atualiza os logs para o IP
    // Verifica se o número de requisições ativas excede o limite
    if (activeLogs.length >= limit) {
        logger.warn(Requisição REJEITADA (Sliding Window) para IP: ${clientIp}. Limite: ${limit}/${windowMs}ms.);
        // Melhores práticas: Usar cabeçalhos padronizados para informar o cliente
        res.setHeader('X-RateLimit-Limit', limit);
        res.setHeader('X-RateLimit-Remaining', 0);
        res.setHeader('X-RateLimit-Reset', Math.ceil((activeLogs[0] + windowMs - now) / 1000)); // Tempo para resetar em segundos
        return res.status(429).send('Muitas requisições. Tente novamente mais tarde.');
    }
    // Se a requisição for permitida, adiciona o timestamp atual
    activeLogs.push(now);
    slidingWindowLogs.set(clientIp, activeLogs); // Atualiza novamente
    logger.info(Requisição PERMITIDA (Sliding Window) para IP: ${clientIp}. Restantes: ${limit - activeLogs.length}/${limit});
    // Informa o cliente sobre o status do rate limit
    res.setHeader('X-RateLimit-Limit', limit);
    res.setHeader('X-RateLimit-Remaining', limit - activeLogs.length);
    res.setHeader('X-RateLimit-Reset', Math.ceil((now + windowMs - now) / 1000)); // Reset para o final da janela atual
    next(); // Passa o controle para o próximo middleware ou rota
};
// --- Middleware: Token Bucket Rate Limiter ---
/ Middleware para aplicar Rate Limiting usando o algoritmo Token Bucket.
  Permite rajadas de requisições até a capacidade do balde, com uma taxa de recarga constante.
  @param {number} capacity A capacidade máxima do balde de tokens (permite rajadas).
  @param {number} refillRate O número de tokens adicionados por segundo (taxa de recarga).
  @returns {Function} O middleware do Express.
 /
const tokenBucketRateLimiter = (capacity, refillRate) => (req, res, next) => {
    const clientIp = req.ip || ip.address();

    // Inicializa o balde de tokens se ainda não existir para este IP
    if (!tokenBuckets.has(clientIp)) {
        tokenBuckets.set(clientIp, {
            tokens: capacity, // Começa com o balde cheio
            lastRefill: Date.now(),
        });
    }
    const bucket = tokenBuckets.get(clientIp);
    const now = Date.now();
    const timeElapsed = now - bucket.lastRefill; // Tempo em ms desde a última recarga
    // Calcula quantos tokens devem ser adicionados com base no tempo decorrido e na taxa de recarga
    const tokensToAdd = (timeElapsed / 1000)  refillRate;
    bucket.tokens = Math.min(capacity, bucket.tokens + tokensToAdd); // Adiciona tokens, sem exceder a capacidade
    bucket.lastRefill = now; // Atualiza o tempo da última recarga
    // Verifica se há tokens disponíveis
    if (bucket.tokens >= 1) { // Pelo menos 1 token é necessário para uma requisição
        bucket.tokens -= 1; // Consome um token
        tokenBuckets.set(clientIp, bucket); // Atualiza o estado do balde
        logger.info(Requisição PERMITIDA (Token Bucket) para IP: ${clientIp}. Tokens restantes: ${bucket.tokens.toFixed(2)}/${capacity});
        res.setHeader('X-RateLimit-Limit', capacity);
        res.setHeader('X-RateLimit-Remaining', Math.floor(bucket.tokens));
        res.setHeader('X-RateLimit-Reset', Math.ceil((capacity - bucket.tokens) / refillRate)); // Tempo estimado para recarregar um token em segundos
        next();
    } else {
        logger.warn(Requisição REJEITADA (Token Bucket) para IP: ${clientIp}. Balde vazio.);
        res.setHeader('X-RateLimit-Limit', capacity);
        res.setHeader('X-RateLimit-Remaining', 0);
        res.setHeader('X-RateLimit-Reset', Math.ceil((1 - bucket.tokens) / refillRate)); // Tempo estimado para o próximo token em segundos
        return res.status(429).send('Muitas requisições. Balde de tokens vazio.');
    }
};
// --- Rotas de Exemplo com Rate Limiting ---
// Rota protegida por Sliding Window: 5 requisições a cada 10 segundos
app.get('/api/sliding-window', slidingWindowRateLimiter(5, 10  1000), (req, res) => {
    res.status(200).json({ message: 'Dados da API (Sliding Window) - Acesso permitido!' });
});

// Rota protegida por Token Bucket: Balde com 10 tokens, recarga de 1 token/segundo
app.get('/api/token-bucket', tokenBucketRateLimiter(10, 1), (req, res) => {
    res.status(200).json({ message: 'Dados da API (Token Bucket) - Acesso permitido!' });
});
// Rota sem rate limiting para comparação
app.get('/api/publico', (req, res) => {
    res.status(200).json({ message: 'Esta é uma rota pública, sem restrições de taxa.' });
});
// --- Tratamento de Erros Excepcional (Melhores práticas enterprise) ---
// Middleware de tratamento de erros final
app.use((err, req, res, next) => {
    logger.error(Ocorreu um erro: ${err.message}, { stack: err.stack });
    res.status(500).send('Ocorreu um erro interno no servidor.');
});
// Tratamento de rotas não encontradas (404)
app.use((req, res) => {
    res.status(404).send('Rota não encontrada.');
});
// --- Inicialização do Servidor ---
app.listen(PORT, () => {
    logger.info(Servidor Express rodando na porta ${PORT});
    logger.info(Acesse http://localhost:${PORT}/api/sliding-window);
    logger.info(Acesse http://localhost:${PORT}/api/token-bucket);
    logger.info(Acesse http://localhost:${PORT}/api/publico);
});

// ... (código anterior do app.js, incluindo as importações e logger) ...

// --- Armazenamento em memória para Rate Limiting (in-memory) ---
// EM AMBIENTES DE PRODUÇÃO E DISTRIBUÍDOS, SUBSTITUA POR REDIS OU OUTRO STORE DISTRIBUÍDO.
const slidingWindowLogs = new Map();
const tokenBuckets = new Map();
// O middleware slidingWindowRateLimiter permanece o mesmo, utilizando IP
// ...
// --- Middleware: Token Bucket Rate Limiter (Modificado para API Key) ---
/ Middleware para aplicar Rate Limiting usando o algoritmo Token Bucket,
  com limite baseado em uma chave de API no cabeçalho 'x-api-key'.
  @param {number} capacity A capacidade máxima do balde de tokens.
  @param {number} refillRate O número de tokens adicionados por segundo.
  @returns {Function} O middleware do Express.
 /
const tokenBucketApiKeyRateLimiter = (capacity, refillRate) => (req, res, next) => {
    // 1. Extrair a chave de API do cabeçalho
    const apiKey = req.headers['x-api-key'];

    // 2. Validar a presença da chave
    if (!apiKey) {
        logger.warn(Requisição REJEITADA: Chave de API ausente.);
        return res.status(401).send('Chave de API ausente. Acesso não autorizado.');
    }
    // Agora, usamos a apiKey como identificador único para o rate limit
    const identifier = apiKey; // O identificador agora é a chave de API
    // Inicializa o balde de tokens se ainda não existir para esta chave de API
    if (!tokenBuckets.has(identifier)) {
        tokenBuckets.set(identifier, {
            tokens: capacity,
            lastRefill: Date.now(),
        });
    }
    const bucket = tokenBuckets.get(identifier);
    const now = Date.now();
    const timeElapsed = now - bucket.lastRefill;
    const tokensToAdd = (timeElapsed / 1000)  refillRate;
    bucket.tokens = Math.min(capacity, bucket.tokens + tokensToAdd);
    bucket.lastRefill = now;
    if (bucket.tokens >= 1) {
        bucket.tokens -= 1;
        tokenBuckets.set(identifier, bucket);
        logger.info(Requisição PERMITIDA (Token Bucket por API Key) para Chave: ${identifier}. Tokens restantes: ${bucket.tokens.toFixed(2)}/${capacity});
        res.setHeader('X-RateLimit-Limit', capacity);
        res.setHeader('X-RateLimit-Remaining', Math.floor(bucket.tokens));
        res.setHeader('X-RateLimit-Reset', Math.ceil((capacity - bucket.tokens) / refillRate));
        next();
    } else {
        logger.warn(Requisição REJEITADA (Token Bucket por API Key) para Chave: ${identifier}. Balde vazio.);
        res.setHeader('X-RateLimit-Limit', capacity);
        res.setHeader('X-RateLimit-Remaining', 0);
        res.setHeader('X-RateLimit-Reset', Math.ceil((1 - bucket.tokens) / refillRate));
        return res.status(429).send('Muitas requisições. Balde de tokens vazio para sua chave de API.');
    }
};
// --- Rotas de Exemplo com Rate Limiting (Atualizadas) ---
// Rota protegida por Sliding Window (permanece por IP)
app.get('/api/sliding-window', slidingWindowRateLimiter(5, 10  1000), (req, res) => {
    res.status(200).json({ message: 'Dados da API (Sliding Window por IP) - Acesso permitido!' });
});

// Nova rota protegida por Token Bucket, agora por API Key
app.get('/api/token-bucket-apikey', tokenBucketApiKeyRateLimiter(5, 0.5), (req, res) => {
    // Usaremos uma chave de API de exemplo "meuchave123"
    res.status(200).json({ message: Dados da API (Token Bucket por API Key) para ${req.headers['x-api-key']} - Acesso permitido! });
});
// Rota sem rate limiting para comparação
app.get('/api/publico', (req, res) => {
    res.status(200).json({ message: 'Esta é uma rota pública, sem restrições de taxa.' });
});
// ... (Restante do código, incluindo tratamento de erros e inicialização do servidor) ...

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas