API de CPF para plataformas SaaS: como implementar multi-tenancy

import requests
import redis
import json
from flask import Flask, request, jsonify
from datetime import datetime

app = Flask(__name__)

redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

CPFHUB_API_KEY = 'SUA_CHAVE_DE_API'

# Configuracao de limites por tenant (em producao, vem do banco de dados)
TENANT_LIMITES = {
    'tenant_001': {'limite_mensal': 500, 'plano': 'basico'},
    'tenant_002': {'limite_mensal': 2000, 'plano': 'premium'},
    'tenant_003': {'limite_mensal': 100, 'plano': 'trial'}
}

def obter_consumo_mensal(tenant_id: str) -> int:
    mes_atual = datetime.now().strftime('%Y-%m')
    chave = f'cpfhub:consumo:{tenant_id}:{mes_atual}'
    consumo = redis_client.get(chave)
    return int(consumo) if consumo else 0

def incrementar_consumo(tenant_id: str):
    mes_atual = datetime.now().strftime('%Y-%m')
    chave = f'cpfhub:consumo:{tenant_id}:{mes_atual}'
    redis_client.incr(chave)
    # Expirar no final do mes seguinte
    redis_client.expire(chave, 60 * 60 * 24 * 35)

def verificar_limite(tenant_id: str) -> bool:
    config = TENANT_LIMITES.get(tenant_id)
    if not config:
    return False
    consumo = obter_consumo_mensal(tenant_id)
    return consumo < config['limite_mensal']

@app.route('/api/cpf/<cpf>')
def consultar_cpf(cpf):
    # 1. Identificar tenant
    tenant_id = request.headers.get('X-Tenant-ID')
    if not tenant_id:
    return jsonify({'error': 'Header X-Tenant-ID obrigatorio'}), 400

    if tenant_id not in TENANT_LIMITES:
    return jsonify({'error': 'Tenant nao encontrado'}), 404

    # 2. Verificar limite
    if not verificar_limite(tenant_id):
    return jsonify({
    'error': 'Limite de consultas excedido',
    'consumo': obter_consumo_mensal(tenant_id),
    'limite': TENANT_LIMITES[tenant_id]['limite_mensal']
    }), 429

    # 3. Verificar cache (isolado por tenant)
    chave_cache = f'cpfhub:cache:{tenant_id}:{cpf}'
    cacheado = redis_client.get(chave_cache)
    if cacheado:
    return jsonify(json.loads(cacheado))

    # 4. Consultar API
    url = f'https://api.cpfhub.io/cpf/{cpf}'
    headers = {
    'x-api-key': CPFHUB_API_KEY,
    'Accept': 'application/json'
    }

    try:
    response = requests.get(url, headers=headers, timeout=10)
    resultado = response.json()

    if resultado.get('success'):
    # Cachear por 1 hora
    redis_client.setex(chave_cache, 3600, json.dumps(resultado))

    # Incrementar consumo
    incrementar_consumo(tenant_id)

    return jsonify(resultado)

    except requests.exceptions.Timeout:
    return jsonify({'error': 'Timeout na consulta'}), 504
    except Exception as e:
    return jsonify({'error': str(e)}), 500

@app.route('/api/consumo')
def obter_consumo():
    tenant_id = request.headers.get('X-Tenant-ID')
    if not tenant_id:
    return jsonify({'error': 'Header X-Tenant-ID obrigatorio'}), 400

    config = TENANT_LIMITES.get(tenant_id, {})
    consumo = obter_consumo_mensal(tenant_id)

    return jsonify({
    'tenant_id': tenant_id,
    'consumo_atual': consumo,
    'limite_mensal': config.get('limite_mensal', 0),
    'restante': max(0, config.get('limite_mensal', 0) - consumo),
    'plano': config.get('plano', 'desconhecido')
    })

if __name__ == '__main__':
    app.run(port=5000)

const express = require('express');
const Redis = require('ioredis');

const app = express();
const redis = new Redis();

const CPFHUB_API_KEY = 'SUA_CHAVE_DE_API';

async function verificarLimite(tenantId, limiteMensal) {
    const mesAtual = new Date().toISOString().slice(0, 7);
    const chave = `cpfhub:consumo:${tenantId}:${mesAtual}`;
    const consumo = parseInt(await redis.get(chave) || '0');
    return consumo < limiteMensal;
}

async function incrementarConsumo(tenantId) {
    const mesAtual = new Date().toISOString().slice(0, 7);
    const chave = `cpfhub:consumo:${tenantId}:${mesAtual}`;
    await redis.incr(chave);
    await redis.expire(chave, 60 * 60 * 24 * 35);
}

app.get('/api/cpf/:cpf', async (req, res) => {
    const tenantId = req.headers['x-tenant-id'];
    if (!tenantId) {
    return res.status(400).json({ error: 'Header X-Tenant-ID obrigatorio' });
    }

    const podeContinuar = await verificarLimite(tenantId, 500);
    if (!podeContinuar) {
    return res.status(429).json({ error: 'Limite de consultas excedido' });
    }

    const { cpf } = req.params;

    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    try {
    const response = await fetch(
    `https://api.cpfhub.io/cpf/${cpf}`,
    {
    headers: {
    'x-api-key': CPFHUB_API_KEY,
    'Accept': 'application/json'
    },
    signal: controller.signal
    }
    );

    clearTimeout(timeoutId);
    const resultado = await response.json();
    await incrementarConsumo(tenantId);

    return res.json(resultado);
    } catch (error) {
    clearTimeout(timeoutId);
    return res.status(500).json({ error: 'Erro na consulta' });
    }
});

app.listen(3000);