Nos aplicativos de internet atuais com alta concorrência e grande volume de tráfego, a limitação de taxa em um único sistema já não atende às necessidades dos sistemas distribuídos. Imagine um cenário como este: sua plataforma de comércio eletrônico está passando pela grande promoção do Double 11, com dezenas de milhares de pedidos por segundo entrando. Sem um mecanismo eficaz de limitação de taxa distribuída, isso poderia levar a:

• Esgotamento do pool de conexões do banco de dados
• Colapso do cache Redis
• Efeito cascata de falhas nos serviços
• Perdas econômicas diretas

A solução de limitação de taxa distribuída implementada pelo JCSprout usando Redis foi exatamente para resolver esses problemas.

Princípios Fundamentais da Limitação de Taxa Distribuída

Algoritmo de Contador Baseado em Redis

O JCSprout utiliza o algoritmo de contador de janela de tempo, cujo conceito central é o seguinte:

Implementação de Operações Atômicas com Script Lua

-- lua começa com índice 1
-- chave de limitação
local chave = KEYS[1]
-- tamanho da limitação
local limite = tonumber(ARGV[1])

-- obter o tamanho atual do tráfego
local atual = tonumber(redis.call('get', chave) or "0")

if atual + 1 > limite then
    -- atingiu o limite de taxa, retorna
    return 0;
else
    -- não atingiu o limite, valor + 1
    redis.call("INCRBY", chave, 1)
    redis.call("EXPIRE", chave, 2)
    return atual + 1
end

Design da Arquitetura dos Componentes Principais

Padrão Construtor para RedisLimit

O JCSprout utiliza o padrão Builder para criar objetos de limitação, garantindo clareza da API e segurança de thread:

public class ControleFluxo {
    private ComandosJedis jedis;
    private int limite = 200;
    private static final int CODIGO_FALHA = 0;
    private String script;

    private ControleFluxo(Construtor construtor) {
        this.limite = construtor.limite;
        this.jedis = construtor.jedis;
        construirScript();
    }

    public static class Construtor<t comandosjedis="" extends=""> {
        private T jedis = null;
        private int limite = 200;

        public Construtor(T jedis) {
            this.jedis = jedis;
        }

        public Construtor limite(int limite) {
            this.limite = limite;
            return this;
        }

        public ControleFluxo construir() {
            return new ControleFluxo(this);
        }
    }
}
</t>

Exemplo de Utilização

// construir o limitador
ControleFluxo controleFluxo = new ControleFluxo.Construtor<>(agrupamentoJedis)
        .limite(100)  // 100 requisições por segundo
        .construir();

// verificação de limitação
boolean permitido = controleFluxo.verificarLimite();
if (!permitido) {
    throw new ExcecaoLimiteTaxa("Requisição muito frequente");
}

Implementação de Limitação Baseada em Anotações

Anotação @ControladorLimite

Interceptação de limitação para requisições web:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ControladorLimite {
}

// implementação do interceptor
@Component
public class InterceptadorWeb extends WebMvcConfigurerAdapter {
    
    @Autowired
    private ControleFluxo controleFluxo;

    @Override
    public boolean preHandle(ServletRequest requisicao, 
                           ServletResposta resposta, Object manipulador) {
        if (manipulador instanceof ManipuladorMetodo) {
            ManipuladorMetodo metodo = (ManipuladorMetodo) manipulador;
            ControladorLimite anotacao = metodo.getMetodoAnotacao(ControladorLimite.class);
            if (anotacao != null) {
                boolean limitado = controleFluxo.verificarLimite();
                if (!limitado) {
                    resposta.enviarErro(500, "limite de requisição");
                    return false;
                }
            }
        }
        return true;
    }
}

Anotação @LimiteComum

Controle de limitação para métodos comuns:

@Aspect
@Component
public class AspectoComum {
    
    @Autowired
    private ControleFluxo controleFluxo;

    @Pointcut("@annotation(com.crossoverjie.distributed.anotacao.LimiteComum)")
    private void verificar() {}

    @Before("verificar()")
    public void antes(PontoJuncao pontoJuncao) {
        boolean limitado = controleFluxo.verificarLimite();
        if (!limitado) {
            throw new RuntimeException("requisição foi limitada");
        }
    }
}

Estratégias de Otimização de Desempenho

1. Garantia de Atomicidade com Script Lua

2. Otimização de Janela de Tempo

// geração de chave de tempo otimizada
String chave = String.valueOf(System.currentTimeMillis() / 1000);

// suporte a janelas de tempo com diferentes granularidades
public String gerarChaveTempo(int janelaTempoSegundos) {
    long tempoAtual = System.currentTimeMillis();
    long janela = janelaTempoSegundos * 1000L;
    return String.valueOf(tempoAtual / janela);
}

3. Suporte a Modo Cluster

public boolean verificarLimite() {
    String chave = String.valueOf(System.currentTimeMillis() / 1000);
    Object resultado = null;
    
    if (jedis instanceof Jedis) {
        resultado = ((Jedis) this.jedis).eval(script, 
                Collections.singletonList(chave), 
                Collections.singletonList(String.valueOf(limite)));
    } else if (jedis instanceof JedisCluster) {
        resultado = ((JedisCluster) this.jedis).eval(script, 
                Collections.singletonList(chave), 
                Collections.singletonList(String.valueOf(limite)));
    }
    
    return CODIGO_FALHA != (Long) resultado;
}

Cenários de Aplicação Prática

Cenário 1: Limitação no Gateway de API

Cenário 2: Limitação entre Chamadas de Microserviços

@Service
public class ServicoPedido {
    
    @Autowired
    private ControleFluxo controleFluxo;

    @LimiteComum
    public Pedido criarPedido(RequisicaoPedido requisicao) {
        // lógica de negócio
        if (!controleFluxo.verificarLimite()) {
            throw new ExcecaoNegocio("Sistema ocupado, tente novamente mais tarde");
        }
        return repositorioPedido.salvar(converterParaPedido(requisicao));
    }
}

Cenário 3: Agendamento de Tarefas Distribuídas

@Agendado(taxaFixa = 1000)
public void tarefaAgendada() {
    if (controleFluxo.verificarLimite()) {
        // executar tarefa
        processarTarefa();
    } else {
        // pular esta execução
        log.warn("Frequência de execução da tarefa limitada, pulando esta execução");
    }
}

Recursos Avançados e Extensões

Configuração Dinâmica de Limitação

public class ControleFluxoRedisDinamico extends ControleFluxo {
    private volatile int limiteAtual;
    
    public void atualizarLimite(int novoLimite) {
        this.limiteAtual = novoLimite;
        // pode combinar com centro de configuração para atualização dinâmica
    }
    
    @Override
    public boolean verificarLimite() {
        // usar valor de limitação configurado dinamicamente
        return super.verificarLimiteComLimitePersonalizado(limiteAtual);
    }
}

Limitação Multidimensional

public class LimitacaoMultiDimensional {
    private Map<string controlefluxo=""> limitadores = new ConcurrentHashMap<>();
    
    public boolean limitar(String dimensao, String chave) {
        ControleFluxo limitador = limitadores.computeIfAbsent(dimensao, 
            k -> criarLimitadorParaDimensao(k));
        return limitador.verificarLimite();
    }
    
    // suporte a limitação multidimensional por ID de usuário, IP, interface, etc.
}
</string>

Integração de Monitoramento e Alerta

Métricas de Monitoramento Prometheus

public class ControleFluxoMonitorado extends ControleFluxo {
    private final Counter totalRequisicoes;
    private final Counter requisicoesLimitadas;
    
    public ControleFluxoMonitorado(ComandosJedis jedis, int limite) {
        super(jedis, limite);
        this.totalRequisicoes = Counter.build()
                .name("controle_fluxo_requisicoes_totais")
                .help("Total de requisições de limitação")
                .register();
        this.requisicoesLimitadas = Counter.build()
                .name("controle_fluxo_requisicoes_limitadas_totais")
                .help("Total de requisições limitadas")
                .register();
    }
    
    @Override
    public boolean verificarLimite() {
        totalRequisicoes.inc();
        boolean resultado = super.verificarLimite();
        if (!resultado) {
            requisicoesLimitadas.inc();
        }
        return resultado;
    }
}

Análise Comparativa de Desempenho

Recomendações de Melhores Práticas

1. Otimização de Configuração

redis:
  limitacao:
    padrao: 1000    # valor de limitação padrão
    api:
      pedido: 500     # interface de pedido
      usuario: 2000     # interface de usuário
    janela-tempo: 1   # janela de tempo (segundos)

2. Estratégia de Degradação

public class LimitadorQuebraCircuito {
    private final ControleFluxo controleFluxo;
    private final RateLimiter limitadorAlternativo;
    
    public boolean verificarLimite() {
        try {
            return controleFluxo.verificarLimite();
        } catch (Exception e) {
            // degradar para limitação local quando Redis falha
            return limitadorAlternativo.tentarObter();
        }
    }
}

3. Considerações de Implantação em Cluster

Ao implantar em ambiente de cluster, considere:

• Configurar replicação Redis para alta disponibilidade
• Usar sentinela Redis para detecção de falhas
• Implementar estratégias de fallback quando o Redis estiver inacessível