Como configurar proxy reverso para API de CPF em ambientes corporativos

[App 1] ─────┐
             │
[App 2] ─────┼──→ [Proxy Reverso] ──→ [api.cpfhub.io]
             │ (cache, auth,
[App 3] ─────┘  rate limit, log)

upstream cpfhub_api {
    server api.cpfhub.io:443;
    keepalive 10;
}

server {
    listen 8080;
    server_name cpf-proxy.interno.empresa.com;

    # Acesso restrito à rede interna
    allow 10.0.0.0/8;
    allow 172.16.0.0/12;
    allow 192.168.0.0/16;
    deny all;

    # Logs detalhados
    access_log /var/log/nginx/cpf_proxy_access.log;
    error_log /var/log/nginx/cpf_proxy_error.log;

    location /cpf/ {
    # Rate limit interno: 10 req/seg por IP
    limit_req zone=cpf_limit burst=5 nodelay;

    proxy_pass https://api.cpfhub.io/cpf/;
    proxy_ssl_server_name on;

    # Adicionar API key (centralizada no proxy)
    proxy_set_header x-api-key "SUA_CHAVE_DE_API";
    proxy_set_header Accept "application/json";
    proxy_set_header Host api.cpfhub.io;

    # Remover headers que não devem vazar
    proxy_hide_header x-api-key;

    # Timeouts
    proxy_connect_timeout 10s;
    proxy_read_timeout 20s;
    proxy_send_timeout 10s;

    # Cache de respostas
    proxy_cache cpf_cache;
    proxy_cache_valid 200 30m;
    proxy_cache_valid 404 5m;
    proxy_cache_key $uri;
    }
}

# Zona de rate limit
limit_req_zone $binary_remote_addr zone=cpf_limit:10m rate=10r/s;

# Configuração de cache
proxy_cache_path /var/cache/nginx/cpf levels=1:2 keys_zone=cpf_cache:10m
    max_size=100m inactive=30m use_temp_path=off;

# As aplicações chamam o proxy interno (sem API key)
curl -X GET http://cpf-proxy.interno.empresa.com:8080/cpf/12345678900 \
    -H "Accept: application/json" \
    --max-time 15

const express = require('express');
const app = express();

const API_KEY = process.env.CPFHUB_API_KEY;

// Middleware de autenticação interna
function autenticarCliente(req, res, next) {
    const token = req.headers['x-internal-token'];
    const tokensValidos = process.env.INTERNAL_TOKENS?.split(',') || [];

    if (!tokensValidos.includes(token)) {
    return res.status(403).json({ error: 'Acesso negado' });
    }

    next();
}

// Middleware de logging
function logConsulta(req, res, next) {
    const inicio = performance.now();

    res.on('finish', () => {
    const duracao = performance.now() - inicio;
    console.log(JSON.stringify({
    timestamp: new Date().toISOString(),
    ip: req.ip,
    cpf: req.params.cpf,
    status: res.statusCode,
    duracao_ms: Math.round(duracao),
    cliente: req.headers['x-client-name'] || 'desconhecido'
    }));
    });

    next();
}

// Cache simples em memória
const cache = new Map();
const CACHE_TTL = 30 * 60 * 1000; // 30 minutos

app.get('/cpf/:cpf', autenticarCliente, logConsulta, async (req, res) => {
    const { cpf } = req.params;

    // Verificar cache
    const cached = cache.get(cpf);
    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return res.json({ ...cached.data, _cache: true });
    }

    try {
    const response = await fetch(`https://api.cpfhub.io/cpf/${cpf}`, {
    method: 'GET',
    headers: {
    'x-api-key': API_KEY,
    'Accept': 'application/json'
    },
    signal: AbortSignal.timeout(15000)
    });

    const data = await response.json();

    // Cachear respostas de sucesso
    if (response.ok) {
    cache.set(cpf, { data, timestamp: Date.now() });
    }

    res.status(response.status).json(data);

    } catch (error) {
    res.status(502).json({
    error: 'Erro ao consultar API externa',
    detalhes: error.message
    });
    }
});

app.listen(8080, () => {
    console.log('Proxy CPF rodando na porta 8080');
});

const cotas = {
    'equipe-onboarding': { limite: 500, consumido: 0 },
    'equipe-credito': { limite: 300, consumido: 0 },
    'equipe-compliance': { limite: 200, consumido: 0 }
};

function verificarCota(req, res, next) {
    const equipe = req.headers['x-client-name'];

    if (!cotas[equipe]) {
    return res.status(403).json({ error: 'Equipe não cadastrada' });
    }

    if (cotas[equipe].consumido >= cotas[equipe].limite) {
    return res.status(429).json({
    error: 'Cota da equipe esgotada',
    consumido: cotas[equipe].consumido,
    limite: cotas[equipe].limite
    });
    }

    cotas[equipe].consumido++;
    next();
}

// Resetar cotas no início de cada mês
const cron = require('node-cron');
cron.schedule('0 0 1 * *', () => {
    for (const equipe of Object.keys(cotas)) {
    cotas[equipe].consumido = 0;
    }
    console.log('Cotas resetadas');
});

function mascararCPF(cpf) {
    return cpf.substring(0, 3) + '.***.***-' + cpf.substring(9);
}

// No log: 123.***.***-00 em vez do CPF completo