Limitação de banda e shaping em proxy: como medir o teto e escrever código para saturação
Sumário do artigo
- Introdução: por que a banda no proxy decide mais do que parece
- Fundamentos: vocabulário sem o qual não se avança
- Imersão profunda: o que acontece no momento da saturação
- Método 1: medição correta do teto de banda
- Método 2: determinação do tipo de limitador e seus parâmetros
- Método 3: escrevendo um cliente que se harmoniza com o limitador
- Método 4: orçamento de tráfego e arquitetura de carga
- Erros típicos: o que definitivamente não fazer
- Ferramentas e recursos
- Casos e resultados
- Faq: perguntas difíceis sobre banda e shaping
- Conclusão: de suposições a banda gerenciável
Introdução: por que a banda no proxy decide mais do que parece
A maioria das conversas sobre proxies gira em torno de anonimato, geolocalização e "será que vou levar ban". A largura de banda, nesse meio-tempo, fica na sombra. E é justamente ela que determina em quantas horas seu parser vai terminar, quantas contas um único canal aguenta e por que um script que funcionava perfeitamente no ambiente de teste começou a disparar timeouts a cada dez minutos em produção.
Vamos destrinchar um tema sobre o qual raramente se escreve de forma sistemática: como funciona a limitação de banda em proxies, o que são shaping e policing, como é o teto do canal em números reais e, principalmente, como seu código cliente se comporta quando toca esse teto. De propósito, não vamos repassar metodologias de avaliação de qualidade de proxy como um todo. Aqui falamos apenas de banda, seu limite e o que acontece com a aplicação no momento da saturação.
Por que isso é relevante justamente agora? Em 2026, o tamanho médio de uma página web com recursos passou de três megabytes, as APIs entregam respostas JSON cada vez mais pesadas, e os canais móveis, sobre os quais os proxies móveis são construídos, dividem fisicamente o recurso de rádio da célula com assinantes comuns. Ao mesmo tempo, operadoras e provedores de proxy aplicam shaping com mais frequência no nível da sessão, para que um cliente não "devore" o canal dos outros. O desenvolvedor que não entende a mecânica do limitador está condenado a escrever código por tentativa e erro.
Neste guia você vai aprender: como diferenciar shaper de policer pela forma do gráfico, como medir corretamente o teto de um único fluxo e do agregado, como estimar o tamanho do "balde" e a profundidade da fila, por que a latência cresce sob saturação e a eficiência cai, como escrever um cliente com backpressure e paralelismo adaptativo, e como planejar o orçamento de tráfego em vez do número de requisições. No final, você encontra checklists, ferramentas, três casos analisados com números e um FAQ com as perguntas mais capciosas.
Fundamentos: vocabulário sem o qual não se avança
Banda, largura de banda e velocidade útil
Os termos são frequentemente confundidos, mas a diferença é fundamental. Largura de banda (bandwidth) é o teto nominal do canal, quantos bits por segundo ele consegue passar no ideal. Vazão (throughput) é quantos bits realmente passaram por unidade de tempo, considerando todas as despesas indiretas: cabeçalhos TCP e IP, retransmissões, criptografia. Velocidade útil (goodput) são apenas os bytes que chegaram à sua aplicação e foram usados por ela. Se um arquivo de 100 megabytes foi baixado em 20 segundos, seu goodput é 5 megabytes por segundo, embora o canal pudesse ter passado de 8 a 12 por cento mais por causa de informações de serviço.
Para a prática, é importante memorizar: os limitadores no proxy quase sempre contam throughput no nível de pacotes, e você vê goodput. Entre eles sempre haverá uma diferença.
Teto do canal e níveis de limitação
Teto é a velocidade máxima que o limitador permite em um dado nível de agregação. Os níveis costumam ser vários e se sobrepõem como bonecas russas:
- por conexão TCP — cada fluxo individual não pode ultrapassar, digamos, 2 megabits por segundo, mas dez fluxos darão vinte;
- por sessão ou porta de proxy — todas as conexões através de uma porta dividem um limite comum;
- por conta — soma de todas as portas do cliente;
- por nó — limite físico do modem, servidor, uplink;
- por canal da operadora — o que a célula oferece naquele momento específico, considerando a carga da rede de rádio.
O teto real é o mínimo de todos os níveis. E esse mínimo oscila ao longo do dia, porque o nível inferior, o canal de rádio, depende da quantidade de assinantes próximos ao modem.
Token bucket: a mecânica de quase todo limitador
Imagine um balde no qual fichas caem a uma velocidade constante. Cada byte que passa pelo limitador retira uma ficha. Se o balde está vazio, o byte ou espera (shaping) ou é descartado (policing). A velocidade de gotejamento é o rate, a velocidade alvo. O volume do balde é o burst, o pico permitido. Enquanto o balde está cheio, você pode enviar um lote de dados mais rápido que o nominal. Depois a velocidade se equaliza ao rate.
Esse modelo explica surpreendentemente muita coisa. Por que os primeiros dois segundos de download são mais rápidos que o resto? O balde estava cheio. Por que requisições curtas quase nunca batem no limite? Elas cabem no volume do balde. Por que um download longo de repente "cai" exatamente para um número? O balde esvaziou, está funcionando o rate puro.
Shaping versus policing
O shaper coloca os pacotes excedentes numa fila e os libera a uma velocidade definida. O tráfego é suavizado, há poucas perdas, mas a latência aumenta: o pacote espera sua vez. O policer não mantém fila, simplesmente descarta tudo o que excede o limite. A latência não cresce, mas o TCP vê perdas, reduz drasticamente a janela, depois acelera de novo, e o gráfico de velocidade vira um serrote.
Analogia: o shaper é um semáforo com duração de verde regulável, todos passam, mas mais devagar. O policer é um guincho que remove cada carro acima da cota. O fluxo de carros, com isso, fica aos solavancos. Para o seu código, a diferença é enorme, e vamos voltar a ela.
Especificidades dos canais móveis
Um proxy móvel fica num canal de operadora celular. Aqui o teto é definido não só pelas configurações do servidor, mas pela física: categoria do modem, faixa de frequência, número de assinantes na célula, qualidade do sinal. Além disso, a própria operadora aplica priorização de tráfego no nível de classes de serviço. Resultado: a banda do canal móvel é uma ordem de magnitude menos estável que a do servidor, e qualquer metodologia de medição precisa considerar o fator temporal.
Imersão profunda: o que acontece no momento da saturação
O momento da verdade: a fila cresce
Enquanto seu tráfego está abaixo do teto, o limitador é praticamente invisível. Os problemas começam quando a soma dos fluxos excede o rate. No shaper, a fila começa a crescer. Cada pacote, antes de seguir adiante, espera no buffer. Se o buffer é profundo, e esses buffers são muito comuns em equipamentos de rede baratos e em limitadores de software com configurações generosas, a latência pode subir de 60 milissegundos para um segundo e meio. Esse fenômeno se chama bufferbloat: um buffer inflado transforma um canal rápido em lento e pegajoso.
Para a aplicação, isso aparece assim: a velocidade de download parece normal, mas cada nova requisição começa com uma latência monstruosa. Chamadas de API pequenas, que antes levavam 100 milissegundos, agora levam um segundo. Os timeouts configurados "com folga" começam a disparar. E o mais traiçoeiro: você não vê perda de pacotes, tudo simplesmente fica lento.
Reação do TCP: por que o algoritmo de controle de congestionamento importa
O TCP tenta por conta própria encontrar o teto do canal. O algoritmo clássico CUBIC acelera a janela de transmissão até ver uma perda, depois reduz a velocidade e volta a acelerar. Com um policer, o CUBIC trabalha mal: as perdas são frequentes e abruptas, a velocidade média pode ficar 30 a 40 por cento abaixo do teto. Com um shaper, o CUBIC enche a fila até o limite, porque perdas demoram a aparecer, e é justamente ele que se torna o principal culpado pelo bufferbloat.
O algoritmo BBR, cada vez mais usado em servidores, se comporta de outra forma: ele estima a largura de banda e o RTT mínimo e tenta não transbordar a fila. Através de um shaper, o BBR entrega velocidade uniforme e latência moderada. Mas lembre-se: o algoritmo do lado do seu cliente controla apenas o fluxo de saída. O fluxo de entrada, do proxy para você, é determinado pelas configurações do servidor proxy e do site destino, e você não tem influência sobre eles.
Um túnel, muitos fluxos: head-of-line blocking
Quando você trabalha através de um proxy HTTP pelo método CONNECT ou via SOCKS5, cada conexão TCP sua ao site destino é envelopada numa conexão separada com o proxy. Se você usa HTTP/2 para o site destino dentro de um único túnel, todas as requisições são multiplexadas num único fluxo TCP. Sob saturação, isso cria head-of-line blocking: uma resposta pesada ocupa a janela, e as requisições leves esperam atrás dela. Através de um limitador por conexão, isso é especialmente doloroso: todo o multiplex divide um único limite.
A conclusão prática, que muitos tiram tarde demais: o paralelismo através de proxy deve ser construído sobre várias conexões TCP, não sobre multiplexação dentro de uma só. Vamos levar isso em conta na seção sobre código.
Justiça entre fluxos
Como o limitador divide a banda entre suas dez conexões? Se o limite é comum e a fila é única, a banda é capturada mais agressivamente pelos fluxos que têm mais dados em voo. Requisições pequenas perdem sistematicamente para as grandes. Se no limitador há uma fila justa, cada fluxo recebe aproximadamente a mesma fatia. Descobrir qual é o caso exige experimentação, e disso depende se vale a pena separar downloads pesados e chamadas de API leves em conexões diferentes ou até portas diferentes.
Slow start e requisições curtas
O TCP começa com janela pequena e a dobra a cada RTT. Através de um canal móvel com RTT de cerca de 80 milissegundos, acelerar até, digamos, 20 megabits leva algumas centenas de milissegundos. Uma requisição de 50 kilobytes termina antes que o TCP consiga acelerar. Por isso requisições curtas nunca batem no teto de banda, mas são extremamente sensíveis à latência. Isso divide seu tráfego em duas classes com regras diferentes: fluxos pesados, onde o rate importa, e leves, onde o RTT importa. Uma única limitação sufoca os primeiros, e o bufferbloat dos primeiros mata os segundos.
Assinaturas no gráfico
Se você plotar a velocidade por segundo, os limitadores se entregam pela forma:
- platô uniforme com saída suave e RTT crescente — shaper com fila profunda;
- platô com corcova no início — shaper ou policer com balde de burst perceptível;
- serrote com quedas de 30 a 50 por cento, RTT estável, há retransmissões — policer;
- oscilações caóticas sem platô claro — você bateu não no limitador, mas no canal de rádio ou num nó congestionado.
Saber ler essas assinaturas economiza horas de depuração. A seguir, como obtê-las corretamente.
Método 1: medição correta do teto de banda
Por que é preciso metodologia, e não um único teste
Iniciar um download de arquivo e olhar o número qualquer um consegue. O problema é que um número só não significa nada: ele depende da hora do dia, da fonte, do seu próprio canal, da fase de slow start. Precisamos de um protocolo reproduzível, cujos resultados possam ser comparados entre canais e entre dias.
Preparação da fonte de referência
Primeira regra: medir banda contra uma fonte que seja comprovadamente mais rápida que qualquer proxy. Caso contrário, você mede a fonte, não o proxy. O ideal é um servidor próprio numa localidade com uplink gigabit garantido, contendo arquivos de teste de 20, 100 e 500 megabytes gerados a partir de dados aleatórios. Dados aleatórios são importantes: um arquivo compressível pode ser comprimido em algum ponto do caminho, e você obtém um número inflado.
Arquivos de teste públicos de CDNs populares podem ser usados, mas com uma ressalva: a CDN entrega do nó mais próximo do proxy, e você está medindo na prática a banda "proxy — CDN", não "proxy — site qualquer". Para estimar o teto isso é aceitável; para estimar o goodput real em relação aos seus recursos destino, não.
Eliminação do seu próprio gargalo
A máquina de onde você mede deve ter um canal no mínimo três vezes mais largo que o teto esperado do proxy. Verifique isso com um download separado do mesmo arquivo, diretamente. Desligue downloads em segundo plano, sincronização de nuvem, atualizações. Se você roda as medições num contêiner ou máquina virtual, garanta que a rede virtual não está cortando a banda por conta própria.
Protocolo de fluxo único
- Você inicia o download de um arquivo de 100 megabytes através do proxy, com uma única conexão, registrando a velocidade a cada segundo. Com curl isso se faz com chaves de progresso; mais prático é escrever um pequeno script que lê o corpo em streaming e grava os bytes por segundo.
- Descarta os primeiros três segundos — é o slow start e o esvaziamento do balde.
- Interrompe a medição após 40 a 60 segundos ou ao terminar o arquivo. Menos de 20 segundos não basta para ver o regime estável.
- Calcula, sobre os segundos restantes, a mediana, o décimo e o nonagésimo percentil, e o coeficiente de variação (desvio padrão dividido pela média).
- Repete três vezes com pausa de um minuto.
A mediana é seu teto estável de um único fluxo. A distância entre o décimo e o nonagésimo percentil indica a estabilidade. Coeficiente de variação abaixo de 0,15 é canal uniforme; acima de 0,4 é ou policer, ou rede de rádio sobrecarregada.
Protocolo do agregado
Agora o mesmo, mas com 2, 4, 8 e 16 conexões paralelas para o mesmo arquivo ou para vários arquivos. Some as velocidades por segundo. Você obtém a dependência da velocidade agregada em relação ao número de fluxos. Ela pode ser de três tipos:
- crescimento linear até um platô — limite por conexão, teto do agregado é mais alto; o platô mostra o próximo nível de limitação;
- platô desde o primeiro fluxo — limite comum por sessão, fluxos adicionais não ajudam em nada, só aumentam a latência;
- crescimento e depois queda — com muitos fluxos crescem as perdas e as despesas indiretas, o canal degrada. O ótimo está onde o crescimento parou.
Um curl único para orientação rápida é assim: curl -x http://user:pass@host:port -o /dev/null -w "%{speed_download} %{time_total}" https://your-server/100mb.bin. Ele dá a velocidade média de todo o arquivo, o que para uma avaliação inicial basta, mas para assinaturas é preciso registro por segundo.
Varredura temporal
Para canal móvel, é obrigatório medir em quatro janelas do dia: noite, manhã, tarde, fim de tarde. O teto à noite numa área residencial pode ser metade do noturno. Se você planeja carga 24 horas por dia, seu código terá que viver com o teto da noite, não com o da madrugada.
Checklist de medição do teto
- Fonte de referência comprovadamente mais rápida que o proxy, arquivos de dados aleatórios.
- Seu próprio canal verificado separadamente e no mínimo três vezes mais largo.
- Registro de bytes por segundo, primeiros três segundos descartados.
- Duração do regime estável de no mínimo 20 segundos.
- Três repetições, mediana e percentis, coeficiente de variação.
- Série por número de fluxos: 1, 2, 4, 8, 16.
- Quatro janelas horárias do dia para canais móveis.
- Resultados registrados num formato único, com hora, porta, fonte.
Método 2: determinação do tipo de limitador e seus parâmetros
Por que saber o que está à frente
Um mesmo teto de 10 megabits exige código diferente dependendo de ser shaper ou policer, de haver balde de burst e de qual tamanho, de a latência crescer ou não sob carga. Esse método transforma o gráfico de velocidade num conjunto de parâmetros, que depois vão para a configuração do seu cliente.
Teste de burst: medindo o balde
- Deixe o canal descansar 30 segundos sem tráfego, para o balde encher.
- Inicie o download e registre a velocidade com resolução de 100 a 200 milissegundos nos primeiros cinco segundos.
- Encontre o momento em que a velocidade cai para o valor estável do Método 1.
- Estime o volume do balde como o total de bytes transmitidos até esse momento, menos o que teria passado no mesmo tempo na velocidade estável.
Exemplo: os primeiros 1,5 segundos vão a 40 megabits, depois exatamente 10. O balde é aproximadamente 40 menos 10, vezes 1,5 segundo, dividido por 8 — cerca de 5,6 megabytes. Isso significa que requisições de até 5 megabytes, espaçadas por pausas, vão passar na velocidade "rápida". Excelente ferramenta de planejamento, se sua carga é composta de respostas médias.
Se não há burst e a velocidade vai direto para o platô com aceleração suave, o balde é pequeno ou inexistente, e o limitador provavelmente é um shaper com rate rígido.
Teste de latência sob carga
Esse é o teste principal para distinguir shaper de policer. Em paralelo a um download longo, você dispara uma série de requisições leves pela mesma porta de proxy: por exemplo, HEAD ao seu servidor a cada 500 milissegundos. Registra o tempo de resposta antes da carga, durante e depois.
- A latência cresceu várias vezes, até centenas de milissegundos ou segundos, mantendo a velocidade uniforme — shaper com fila profunda. Anote a profundidade: o aumento de latência multiplicado pelo rate dá o tamanho aproximado do buffer em bytes.
- A latência quase não mudou, mas há retransmissões na estatística da conexão, e a velocidade é serrilhada — policer.
- A latência cresceu moderadamente, de 50 a 150 milissegundos, velocidade uniforme — shaper com fila gerenciada, a variante mais confortável.
A estatística de retransmissões no Linux pode ser vista com o comando ss -ti na conexão desejada: há contadores de retransmissão e o RTT atual. É uma forma gratuita e precisa de ver se há perda de pacotes.
Teste de agregação: por conexão ou por sessão
Você já obteve a curva no Método 1. Refine-a: inicie uma conexão a plena carga e uma segunda com limitação do lado do cliente em 10 por cento do teto. Se a primeira quase não desacelerou — os limites são separados por conexão. Se a primeira perdeu exatamente o que a segunda consumiu — o limite é comum. Esse teste é mais barato que a série de 16 fluxos e dá resposta inequívoca.
Separação entre limitador e canal de rádio
Como entender que o platô é uma configuração e não a física da célula? Três sinais de configuração: o platô se mantém com precisão de poucos por cento em horários diferentes, o número é "redondo" (5, 10, 20, 50 megabits), e a forma de chegada ao platô é igual em cada repetição. O canal de rádio dá valores "não redondos" e flutuantes, dependentes do horário. Adicionalmente, meça a segunda porta do mesmo nó no mesmo instante: se duas portas somadas entregam mais que uma, o limite está na porta, não no modem.
Framework de classificação
Reúna os resultados numa ficha do canal:
- Teto de um fluxo: mediana, coeficiente de variação.
- Teto do agregado: valor e número de fluxos em que foi atingido.
- Nível do limite: conexão, sessão, nó.
- Tipo: shaper ou policer.
- Balde: volume em megabytes ou "não".
- Profundidade da fila: aumento da latência sob carga.
- Perfil diário: tetos nas quatro janelas.
Uma ficha assim é entrada direta para a configuração do cliente. Sem ela, você vai ajustar parâmetros no tato.
Método 3: escrevendo um cliente que se harmoniza com o limitador
Filosofia: não lutar, negociar
O principal insight que chega depois de dez sistemas depurados: não é possível "furar" o limitador com muitos fluxos. Só se pode encher sua fila e ganhar bufferbloat, ou provocar o policer para perdas massivas. Um cliente eficiente mantém ele mesmo a velocidade um pouco abaixo do teto, para que a fila do limitador fique quase vazia e a latência, baixa. Um paradoxo que surpreende os novatos: reduzindo a velocidade em 10 por cento, você frequentemente aumenta o goodput, porque timeouts e repetições desaparecem.
Componente 1: token bucket no cliente
Implemente no seu lado um balde igual ao do limitador, mas com rate de 85 a 90 por cento do teto estável medido e volume de balde não maior que metade do balde medido do proxy. O limitador se aplica à leitura do corpo da resposta: antes de ler cada bloco, você pede ao balde tantas fichas quantos bytes pretende ler, e espera se não houver. A lógica passo a passo:
- Mantenha dois números: o estoque atual de fichas e o horário da última reposição.
- Ao pedir N fichas, primeiro reponha o estoque:
tokens = min(burst, tokens + (now - last) * rate). - Se houver fichas suficientes, subtraia e continue. Se não, calcule o tempo de espera
(N - tokens) / ratee durma de forma assíncrona. - Um balde por porta de proxy, comum a todas as conexões por essa porta, se o limite for por sessão. Se o limite for por conexão — um balde por conexão mais um comum por nó.
Por que limitar a leitura, e não as requisições? Porque é a leitura que determina a que velocidade os dados são puxados da fila do limitador. Se você lê mais devagar do que o proxy entrega, o próprio TCP avisa ao remetente para reduzir a janela, e os dados param de se acumular em buffers intermediários. Isso é backpressure em estado puro.
Componente 2: semáforo de paralelismo
Limite o número de conexões simultâneas por porta com um semáforo. O valor inicial vem da curva de agregação do Método 1: o número de fluxos em que o crescimento parou, menos um. Para um canal móvel típico, isso é 4 a 8. Mais que isso — só a latência cresce.
Componente 3: leitura em streaming e timeout de progresso
Nunca defina um timeout único para toda a requisição. Um arquivo de 50 megabytes a um teto de 5 megabits vai baixar em 80 segundos honestos, e um timeout de 30 segundos o matará na metade, desperdiçando metade da banda. A abordagem correta: timeout de conexão (5 a 10 segundos), timeout do primeiro byte (10 a 20 segundos, considerando possível bufferbloat) e timeout de progresso — o intervalo máximo entre dois blocos lidos com sucesso, geralmente de 15 a 30 segundos. Você lê o corpo em blocos de 32 a 64 kilobytes, atualizando a marca de progresso a cada bloco.
Componente 4: paralelismo adaptativo pelo esquema AIMD
O teto do canal móvel oscila, e um semáforo estático não o acompanha. A solução é gerenciar o paralelismo dinamicamente pelo princípio de aumento aditivo e diminuição multiplicativa, exatamente como o TCP faz:
- A cada 10 segundos, calcule o goodput da janela e a latência mediana do primeiro byte.
- Se a latência estiver abaixo de uma vez e meia a basal e não houver erros — aumente o limite do semáforo em uma unidade, até o limite superior.
- Se a latência subiu mais que o dobro da basal ou surgiram timeouts de progresso — reduza o limite pela metade, mas não abaixo de um.
- A latência basal é medida no início do trabalho com uma conexão e recalculada a cada hora.
Esse controlador encontra em poucos minutos o ponto confortável e se mantém perto dele, comprimindo-se automaticamente à noite e expandindo-se de madrugada. Vimos casos em que ele elevou o goodput diário em 20 a 35 por cento sem nenhuma mudança no teto.
Componente 5: tentativas com atraso exponencial e jitter
Timeout é um sinal de congestionamento, não um convite para repetir imediatamente. Repetir na hora agrava a fila. Regra: primeira repetição após 1 a 2 segundos, cada seguinte o dobro, no máximo 5 tentativas, com jitter aleatório de até 50 por cento adicionado a cada atraso, para que dez fluxos não acordem ao mesmo tempo. Em timeout de progresso num arquivo grande, vale a pena continuar do ponto de interrupção com uma requisição com cabeçalho Range, se o servidor suportar: a banda gasta na primeira metade não se perde.
Componente 6: filas de prioridade
Divida as tarefas em classes: interativas (chamadas de API leves, onde a latência importa) e de fundo (downloads pesados). As de fundo recebem uma fatia do balde, digamos 70 por cento; as interativas, uma reserva garantida. Se o limite for por conexão, e não por sessão, separe as classes em conexões diferentes. Se possível — em portas de proxy diferentes. Assim um arquivo pesado não bloqueia cem requisições pequenas.
Componente 7: contabilizar bytes, não requisições
Conte cada byte lido por porta, por classe e por domínio destino. Exporte para métricas. São esses números que mostram para onde vai a banda e permitem planejar o orçamento, tema do próximo método.
Mini-esqueleto em Python
O esquema de implementação com asyncio e qualquer cliente HTTP assíncrono fica assim:
- Classe
TokenBucketcom métodoasync def take(n)pela lógica do Componente 1. - Classe
Channel: endereço do proxy, balde, semáforo, contadores, controlador AIMD. - Função
async def fetch(channel, url): sob o semáforo abre a requisição pelo proxy, espera os cabeçalhos com timeout do primeiro byte, e então em laço lêchunk = await resp.content.read(65536), antes disso chamandoawait channel.bucket.take(len(chunk)), atualiza a marca de progresso e os contadores de bytes. - Tarefa de fundo
async def tune(channel): a cada 10 segundos lê as métricas e ajusta o tamanho do semáforo. - Wrapper de tentativas com atraso exponencial e suporte a Range.
Detalhe importante para Python: os clientes padrão, por default, bufferizam a resposta inteira em memória. Garanta que você esteja no modo streaming, caso contrário não haverá backpressure e o limitador na leitura será inútil. Em Go, o equivalente se constrói sobre io.Reader com um wrapper limitador e golang.org/x/time/rate; em Node.js — com pausa e retomada do stream de resposta.
Checklist do cliente
- Balde no cliente com rate de 85 a 90 por cento do teto.
- Leitura em streaming por blocos, limitador na leitura.
- Três timeouts separados: conexão, primeiro byte, progresso.
- Semáforo com gestão adaptativa por latência.
- Tentativas com atraso exponencial, jitter e Range.
- Separação entre tarefas interativas e de fundo.
- Paralelismo sobre várias conexões TCP, não sobre multiplex dentro de um túnel.
- Contabilização de bytes por porta, classe e domínio.
Método 4: orçamento de tráfego e arquitetura de carga
Pense em bytes
A maioria dos sistemas planeja carga em requisições por segundo. Mas o limitador de banda conta bytes. Uma requisição a uma API de 4 kilobytes e o download de uma página de 3 megabytes diferem em 750 vezes. O primeiro passo do método é converter seu plano em bytes: quantas respostas de que tamanho você recebe por hora, e se o perfil diário de teto da ficha do canal cobre isso.
Fórmula simples: a capacidade diária do canal em bytes é a soma, pelas quatro janelas, do produto do teto pela duração da janela, multiplicada por um coeficiente de 0,8 para despesas indiretas e folga. Para um canal com teto noturno de 20 megabits e fim de tarde de 8 megabits, a capacidade diária fica em torno de 120 a 130 gigabytes. Se seu plano exige 300, nenhuma otimização de código ajuda, são necessários mais canais.
Reduzindo o volume por requisição
- Compressão: envie sempre o cabeçalho Accept-Encoding com gzip e br. Respostas de texto comprimem de 4 a 8 vezes. Se seu cliente não descomprime respostas automaticamente, ative isso.
- Descarte de recursos desnecessários: ao trabalhar com automação de navegador, bloqueie o download de imagens, fontes e mídia, se não forem necessários à tarefa. Isso economiza 60 a 80 por cento do tráfego da página.
- Requisições condicionais: guarde ETag e Last-Modified, envie If-None-Match. Uma resposta 304 pesa centenas de bytes em vez de megabytes.
- HEAD antes de GET: se precisa verificar existência ou tamanho do recurso, não o baixe.
- Requisições Range: quando só uma parte do arquivo é necessária, por exemplo metadados no início, peça o intervalo.
- Campos de API: muitas APIs suportam escolha de campos da resposta. Peça apenas os necessários.
Distribuição entre canais
Se houver vários canais, não divida as tarefas em partes iguais. Divida proporcionalmente ao teto atual, que você mede em tempo real pelo goodput de cada canal. O agendador mantém uma fila de tarefas e entrega a próxima ao canal com balde mais folgado e latência menor. Um canal degradado automaticamente recebe menos trabalho, sem intervenção manual.
Planejamento no tempo
Mova tarefas volumosas de fundo para janelas noturnas, quando o teto é maior. Tarefas interativas e urgentes — distribua uniformemente, mas com reserva de banda. Soa banal, mas na prática poucos constroem um agendador que considera o perfil diário do canal. A diferença no goodput diário com esse planejamento chega a 40 por cento no mesmo conjunto de canais.
Disjuntor de proteção
Inclua no cliente um disjuntor rígido: se o goodput do canal nos últimos dois minutos cair abaixo de 20 por cento da mediana da ficha, e a latência subir mais que quatro vezes, o canal é temporariamente retirado da rotação por 5 minutos. Isso protege da situação em que uma célula congestionada ou um nó problemático arrasta todo o sistema para repetições infinitas.
Checklist do orçamento
- Plano convertido em bytes por classe de tarefa.
- Capacidade diária dos canais calculada pelo perfil com folga de 20 por cento.
- Compressão, bloqueio de recursos desnecessários, requisições condicionais, Range aplicados.
- Agendador distribui pelo goodput atual, não em partes iguais.
- Tarefas volumosas deslocadas para janelas de teto alto.
- Disjuntor por goodput e latência configurado.
Erros típicos: o que definitivamente não fazer
Adicionar fluxos até ficar mais rápido
O erro mais comum. Com limite comum por sessão, fluxos adicionais só alongam a fila do shaper. A velocidade não cresce, a latência cresce, os timeouts pipocam. Com policer — crescem as perdas, e o agregado pode até cair. O aumento de paralelismo só se justifica até o ponto em que a curva de agregação atingiu o platô.
Um timeout único para toda a requisição
Mata downloads grandes que vão honestamente no meio e desperdiça banda. Use timeout de progresso.
Repetições instantâneas
Sob congestionamento, repetir sem pausa dobra a carga na fila. Dez fluxos repetindo ao mesmo tempo armam uma pequena tempestade. Atraso exponencial e jitter são obrigatórios.
Medir o teto com uma única medição
Um número às 14h de terça não diz nada sobre o comportamento do canal às 20h de sexta. Sem perfil diário, você ou subutiliza o canal, ou constrói o sistema sobre uma banda que não existe.
Medir contra uma fonte lenta
Um servidor público com uplink carregado vai mostrar o seu próprio teto, não o teto do proxy. Verifique a fonte diretamente.
Bufferizar a resposta inteira
Sem leitura em streaming não há backpressure. O cliente "engole" tudo que o proxy entrega, e o limitador no cliente não funciona. Além disso, memória para respostas grandes.
Multiplexar tudo num único túnel
HTTP/2 dentro de um único CONNECT, com limite por conexão, divide a banda entre todas as requisições e cria head-of-line blocking. Várias conexões TCP quase sempre são mais eficientes através de proxy.
Ignorar a compressão
Accept-Encoding desativado significa que você paga banda por texto não comprimido. Uma diferença de cinco vezes sem motivo.
Confundir banda com latência
Um canal de 50 megabits com RTT de 400 milissegundos, para cem chamadas de API pequenas, é mais lento que um canal de 10 megabits com RTT de 60 milissegundos. Avalie os dois parâmetros para o seu perfil de tráfego.
Contar requisições, não bytes
Planejar em requisições por segundo não considera o tamanho das respostas e leva a um encontro inesperado com o teto.
Ferramentas e recursos
Para medições
- curl — ferramenta universal para medições rápidas via proxy. A chave de variáveis de tempo dá a velocidade média, o tempo até o primeiro byte, o tempo de conexão. Para registro por segundo, é mais simples escrever dez linhas em Python.
- iperf3 — para medir banda pura entre sua máquina e seu servidor diretamente, para excluir seu próprio gargalo. Através de proxy HTTP ele não funciona, mas como controle de fonte é insubstituível.
- ss com a chave -ti — estatística de conexões TCP no Linux: RTT, janela de congestionamento, retransmissões, algoritmo de controle de congestionamento. O principal detector gratuito de policer.
- tcpdump e Wireshark — quando é preciso ver o que exatamente acontece no nível de pacotes: padrões de perda, atrasos de confirmação, comportamento da janela.
- mtr — traceroute com perdas por nó, ajuda a entender onde exatamente surgem as perdas no caminho até o proxy.
Para emulação local
Antes de testar o código num proxy real, monte um ambiente. No Linux, o utilitário tc com as disciplinas tbf (token bucket filter) e netem permite emular shaper com rate e burst definidos, policer, latência e perdas. Você pode reproduzir a ficha do canal localmente e rodar o cliente contra ela o quanto quiser, sem gastar tráfego e sem depender do horário. Desenvolvedores que montam esse ambiente depuram o cliente muito mais rápido.
Para código
- Python: asyncio, aiohttp ou httpx em modo streaming, token bucket próprio em 20 linhas. Há bibliotecas prontas de limitadores, mas a maioria limita requisições, não bytes, por isso a implementação própria é mais confiável.
- Go: pacote rate da biblioteca estendida, wrapper sobre io.Reader para limitar a leitura, contexto com deadlines para timeouts.
- Node.js: resposta em streaming com controle manual de pausa e retomada, bibliotecas para semáforos e repetições.
Para observabilidade
Exporte métricas de goodput, latência do primeiro byte, número de conexões ativas, timeouts e repetições por porta de proxy para um sistema de coleta de métricas e monte painéis. As assinaturas do limitador ficam visíveis nos gráficos em um minuto, e as anomalias do canal — muito antes de derrubarem a tarefa. Sem observabilidade, o controlador adaptativo não pode ser configurado nem verificado.
O que ler
As especificações RFC sobre controle de congestionamento TCP e sobre algoritmos de gerenciamento ativo de filas dão compreensão profunda de por que os shapers se comportam assim. A documentação do Linux sobre disciplinas de fila do tc é um guia prático de emulação. Artigos sobre bufferbloat explicam por que buffers profundos prejudicam e como isso é combatido no nível do equipamento de rede.
Casos e resultados
Caso 1: parser de catálogo de marketplace que "morria" à noite
Tarefa: varredura diária do catálogo, cerca de 400 mil páginas, através de oito canais móveis. Sintomas: à noite o sistema terminava em cinco horas; no fim da tarde — timeouts em cada terceira requisição, o plano diário não se cumpria.
A medição pelo Método 1 mostrou: teto noturno do canal em torno de 18 megabits, no fim da tarde — 6 a 7. Método 2: shaper com fila profunda, latência sob carga subia de 90 para 1400 milissegundos, limite comum por sessão. O cliente usava 32 fluxos por canal e um timeout único de 20 segundos.
O que foi feito: introduzimos balde no cliente a 85 por cento do teto atual, reduzimos a paralelismo inicial para 6 com controlador adaptativo, substituímos o timeout por um de três níveis, ativamos compressão e bloqueio de imagens (as páginas ficaram com 180 kilobytes em vez de 1,4 megabyte). Resultado: o percentual de timeouts no fim da tarde caiu de 33 para 0,4, o goodput diário cresceu 41 por cento com o mesmo conjunto de canais, e a varredura passou a caber em 7 horas em qualquer horário. O mais revelador: reduzir o paralelismo de 32 para 6 aumentou a velocidade útil, não diminuiu.
Caso 2: exportação de arquivos de mídia e o policer
Tarefa: download de vídeos de 40 a 200 megabytes de um host público via proxy, cerca de 2 terabytes por mês. Sintomas: velocidade instável, média metade do anunciado, interrupções frequentes no meio do arquivo.
A medição mostrou o serrote clássico: quedas de 40 a 50 por cento a cada poucos segundos, RTT estável, contador de retransmissões subindo dezenas por segundo. Policer com limite por conexão em torno de 12 megabits, agregado até 4 fluxos crescia quase linearmente.
O que foi feito: dividimos cada arquivo em quatro partes por Range e baixávamos em paralelo com quatro conexões, cada uma com balde no cliente a 10 megabits, logo abaixo do limite do policer, para não provocar perdas. Adicionamos retomada por Range em timeout de progresso. Resultado: a velocidade média por arquivo subiu de 5,5 para 36 megabits, as interrupções deixaram de causar perda do que já havia sido baixado, e o volume mensal passou a ser concluído em 12 dias em vez de 30. O policer não se engana, mas dá para não dar motivo para ele descartar pacotes.
Caso 3: carga mista de API e downloads
Tarefa: operação simultânea com API de plataforma social (milhares de chamadas pequenas) e exportação de mídia em segundo plano pelos mesmos canais. Sintomas: chamadas de API periodicamente caíam para latência de 3 a 5 segundos, a plataforma começava a considerar o cliente lento.
Diagnóstico: shaper por sessão, os downloads de fundo enchiam a fila, as requisições pequenas ficavam atrás deles. Bufferbloat clássico dentro de uma mesma sessão.
O que foi feito: separamos as classes em portas de proxy diferentes do mesmo nó; nas portas de download de fundo, balde a 70 por cento do teto delas; nas portas de API, paralelismo no máximo 3 e prioridade por latência. Resultado: o nonagésimo percentil de latência da API caiu de 3,8 segundos para 210 milissegundos, os downloads de fundo desaceleraram 12 por cento, o que era aceitável. A eficiência geral do sistema, medida em operações bem-sucedidas por hora, cresceu 27 por cento.
FAQ: perguntas difíceis sobre banda e shaping
Por que com um fluxo a velocidade é 8 megabits, e com dez são os mesmos 8, mas tudo ficou mais lento?
O limite é por sessão, não por conexão. Dez fluxos dividem um único rate e enchem a fila do shaper. A banda não cresce, mas a latência cresce proporcionalmente à profundidade da fila. O ideal é manter 2 a 4 fluxos e limitar a leitura no cliente.
Como saber que bati no canal de rádio, e não numa configuração do proxy?
A configuração dá um platô estável com número "redondo" em horários diferentes e forma de chegada igual. O canal de rádio dá valores flutuantes, não redondos, e coeficiente de variação alto, especialmente à noite. Adicionalmente, compare duas portas do mesmo nó simultaneamente: se a soma for maior que uma porta, o limite está na porta, não no modem.
Vale a pena colocar BBR no meu servidor se trabalho via proxy?
O BBR influencia o fluxo de saída do seu servidor. Se você entrega dados via proxy, ele ajuda a manter a fila do shaper vazia e reduz a latência. No fluxo de entrada, dos sites destino para você, ele não influencia: ali quem gerencia é o remetente. Para o lado cliente, o mais importante é o limitador na leitura.
Quanto abaixo do teto manter o balde do cliente?
Para shaper — 85 a 90 por cento do teto estável: a fila fica quase vazia, a latência baixa, a perda de banda mínima. Para policer — 80 a 85 por cento do limite por conexão, para não provocar descarte. Para canal de rádio instável, melhor confiar o ponto ao controlador adaptativo e definir o balde pelo perfil da noite.
Posso usar HTTP/2 via proxy para acelerar?
Através de um túnel CONNECT, HTTP/2 para o site destino funciona, mas todos os fluxos dividem uma única conexão TCP e um único limite, se for por conexão. Além do head-of-line blocking sob saturação. Para tarefas pesadas, várias conexões HTTP/1.1 via proxy geralmente dão melhor goodput e latência previsível.
Como medir o tamanho do balde de burst com mais precisão?
Dê ao canal uma pausa de 30 a 60 segundos, registre os bytes com resolução de 100 milissegundos, encontre o ponto de quebra para a velocidade estável, calcule o excesso acima da linha estável. Repita cinco vezes, pegue a mediana. Precisão de cerca de 15 por cento basta para o planejamento.
O que fazer se os timeouts aparecem só em domínios específicos?
Provavelmente o gargalo não está no proxy, mas no caminho do proxy até esse domínio ou no próprio domínio. Meça o teto contra sua fonte de referência no mesmo instante: se estiver normal, a limitação é externa. No código, destine a esse domínio uma classe separada com menos paralelismo e timeout de primeiro byte mais longo.
Como saber se o controlador adaptativo está funcionando corretamente?
Nos gráficos, o paralelismo deve cair suavemente à noite e crescer de madrugada, a latência do primeiro byte deve se manter dentro de uma vez e meia a duas vezes os valores basais, e a fração de timeouts deve ficar abaixo de um por cento. Se o paralelismo oscila entre mínimo e máximo a cada minuto, a janela de avaliação está curta demais ou o limiar de reação está sensível demais.
É preciso considerar a criptografia no cálculo de bytes?
O TLS adiciona 2 a 5 por cento de despesas indiretas em cabeçalhos de registro e handshakes. Para planejamento de orçamento, basta um coeficiente de 0,8 para tudo junto com TCP/IP. Para contabilização exata, conte bytes no nível do socket, não no nível do corpo da resposta.
Conclusão: de suposições a banda gerenciável
Percorremos o caminho dos conceitos básicos até a arquitetura de um cliente que não guerreia com o limitador, mas se harmoniza com ele. Vamos resumir o essencial.
- O teto é o mínimo de vários níveis, e para canais móveis ele oscila ao longo do dia. Um número só não significa nada, é preciso um perfil.
- Shaper e policer exigem códigos diferentes. O shaper pune com latência, o policer com perdas. Distingui-los leva dez minutos de teste de latência sob carga e estatística de retransmissões.
- Saturação não é sobre velocidade, é sobre fila. O bufferbloat transforma um canal rápido em pegajoso e mata requisições pequenas antes que a velocidade das grandes caia.
- O cliente deve ler em streaming, limitar a leitura pouco abaixo do teto, usar três timeouts separados, gerenciar o paralelismo de forma adaptativa e repetir com atraso.
- Planeje bytes, não requisições. Compressão, descarte de recursos desnecessários e requisições condicionais muitas vezes rendem mais que qualquer artifício com fluxos.
O que fazer a seguir? Hoje: suba a fonte de referência e levante a ficha do canal pelos Métodos 1 e 2, ao menos para uma porta. Nesta semana: monte o ambiente local com tc, reproduza a ficha e reescreva o cliente conforme o checklist do Método 3. Ao longo do mês: ative a contabilização de bytes, monte painéis e configure o controlador adaptativo, depois recalcule o orçamento de tráfego pelo Método 4.
A banda deixa de ser fonte de surpresas exatamente no momento em que você começa a medi-la e a respeitá-la. Código escrito com compreensão do limitador não só funciona mais rápido. Ele funciona de forma previsível, e em tarefas de infraestrutura a previsibilidade é a principal moeda.