CS Fundamentals Trainer · Guias
TCP na prática: conexões, latência, timeouts e o que quebra em produção
O que o TCP promete e o que não promete, quanto custa uma conexão (handshakes, TLS, partida lenta, janelas), a pausa de 40 ms do algoritmo de Nagle com ACKs atrasados, TIME_WAIT e esgotamento de portas, o backlog de accept, conexões semiabertas, keepalive e timeouts, com medições de experimentos em loopback e uma tabela de sintomas para diagnosticar problemas em produção.
32 min de leitura
Uma requisição que normalmente leva 2 milissegundos às vezes leva 44. Um serviço que aguentava bem a carga na segunda-feira começa a falhar na terça com "cannot assign requested address". Uma verificação de saúde passa enquanto os usuários veem timeouts. Cada um desses casos tem o mesmo tipo de causa: a aplicação tratou a rede como uma chamada de função, e o TCP, o protocolo por baixo de quase tudo, se comporta de formas que uma chamada de função não se comporta. O TCP é confiável e ordenado, mas também é um fluxo de bytes com um custo de partida, uma memória, temporizadores e limites, e são essas as coisas que aparecem em produção.
Este guia explica o TCP do ponto de vista de quem escreve e opera serviços: quanto custa uma conexão, o que decide a velocidade com que os dados se movem, a clássica pausa de 40 milissegundos (o algoritmo de Nagle encontrando as confirmações atrasadas), o que é o estado TIME_WAIT e quando ele esgota as portas de um serviço, o que acontece quando um servidor não consegue acompanhar as novas conexões e como perceber que o outro lado desapareceu. Vários desses pontos foram medidos em uma máquina real, e o código está no apêndice.
Uma nota sobre as medições. Os números marcados como "medido" vêm de programas em Go 1.24 em uma pequena VM na nuvem (2 vCPUs de um Intel Xeon a 2,1 GHz, 8 GB de memória, Linux 6 com as configurações padrão de TCP, exceto onde indicado), conversando pela interface de loopback. O loopback não tem distância nem perda de pacotes, então mostra o custo do protocolo e do kernel, não o custo de uma rede real. Esse é o objetivo de usá-lo: ele isola o comportamento (uma pausa, um limite, um temporizador) do ruído de uma rede. Onde a distância importa, o guia usa aritmética que você pode conferir, e diz isso.
1. O que o TCP promete, e o que não promete
O TCP oferece à aplicação um fluxo de bytes confiável e ordenado entre dois pontos. Se os bytes chegam, chegam uma vez e em ordem; pacotes perdidos são retransmitidos; um remetente rápido demais é desacelerado. Quatro consequências disso costumam ser esquecidas:
- Um fluxo não tem fronteiras de mensagem. Duas chamadas
writede 4 e 100 bytes podem chegar como um únicoreadde 104 bytes, ou como três leituras de 40, 50 e 14. Mensagens são algo que a aplicação constrói por cima (seção 6). - "Enviado" não significa "recebido", e "recebido" não significa "processado". Um
writebem-sucedido significa que o kernel aceitou os bytes em um buffer. Uma confirmação significa que o outro kernel os tem, não que o outro programa os leu, e muito menos que agiu sobre eles. Só uma resposta no nível da aplicação diz isso. - O TCP não consegue dizer que o par sumiu, a menos que tente falar com ele. Uma máquina que perde energia, ou um cabo cortado, não envia nada; o outro lado vê silêncio (seção 9).
- A confiabilidade é paga com atraso. Um pacote perdido faz tudo o que está atrás dele esperar pela retransmissão (bloqueio de cabeça de fila), e as conexões começam devagar (seção 4).
2. A vida de uma conexão
Diagram: A TCP connection from open to close
Os estados que importam na prática:
| Estado | Significado | Se você vir muitos deles |
|---|---|---|
| LISTEN | o servidor espera conexões | normal |
| SYN_SENT / SYN_RECV | um handshake está em andamento | uma enxurrada de novas conexões, ou um servidor sobrecarregado (seção 8) |
| ESTABLISHED | aberta, os dados podem fluir | normal; conte-as para dimensionar uma camada de conexões |
| FIN_WAIT, CLOSING | este lado fechou e espera o par | o par demora a fechar, ou está inacessível |
| TIME_WAIT | este lado fechou primeiro e a conexão é mantida por 60 s | muitas conexões curtas (seção 7) |
| CLOSE_WAIT | o par fechou, e o programa local não | um bug: a aplicação não está fechando seus sockets |
O CLOSE_WAIT merece menção especial. Ele significa que o outro lado terminou e este programa nunca chamou close. Os sockets ficam para sempre, e os descritores de arquivo vão acabando devagar. Nunca é um problema de rede, sempre um vazamento no programa, tipicamente um close ou defer ausente em um caminho de erro.
3. Quanto custa uma nova conexão
Abrir uma conexão custa uma ida e volta antes que o primeiro byte da requisição possa ser enviado e, com TLS, uma ou mais idas e voltas a mais. A distância multiplica isso. A tabela é aritmética: uma resposta chega depois do número de idas e voltas indicado (a própria requisição leva uma).
| Tempo de ida e volta | Conexão reutilizada | Nova conexão TCP | Nova conexão TCP + handshake TLS 1.3 completo |
|---|---|---|---|
| 1 ms (mesmo data center) | 1 ms | 2 ms | 3 ms |
| 10 ms (mesma região) | 10 ms | 20 ms | 30 ms |
| 50 ms (através de um continente) | 50 ms | 100 ms | 150 ms |
| 100 ms | 100 ms | 200 ms | 300 ms |
| 200 ms (intercontinental, celular) | 200 ms | 400 ms | 600 ms |
Há também um custo de CPU e de kernel que não depende da distância. Medido no loopback, uma requisição de um byte levou 9,5 microssegundos em uma conexão reutilizada e 68,5 microssegundos quando uma nova conexão foi aberta e fechada a cada requisição: 7,2 vezes mais lento, sem rede nenhuma. (O TLS acrescenta verificação de certificado e troca de chaves, que custam muito mais.)
A consequência é a regra operacional mais importante sobre o TCP: não abra uma conexão por requisição. Use pools de conexões para bancos de dados e para clientes HTTP, o keep-alive do HTTP (o padrão no HTTP/1.1) ou a multiplexação do HTTP/2, e a retomada de sessão TLS. Um serviço que fala com dez outros serviços deve manter conexões de longa duração com cada um. Um cliente HTTP criado e descartado a cada chamada é um bug de desempenho muito comum, e também o caminho habitual para o esgotamento de portas da seção 7.
4. A velocidade dos dados: janelas, partida lenta e o produto banda-atraso
O TCP limita quantos dados podem estar em trânsito, enviados mas ainda não confirmados. Dois limites se aplicam: a janela de recepção (quanto espaço o receptor tem, anunciado em cada confirmação) e a janela de congestionamento (quanto o remetente acredita que a rede consegue carregar). A menor das duas decide a velocidade.
Isso dá um teto rígido que nada tem a ver com a capacidade do enlace: vazão ≤ janela ÷ tempo de ida e volta. Com uma janela de 64 KB e uma ida e volta de 50 ms, no máximo 64 KB podem ser enviados a cada 50 ms, ou seja, 1,3 MB/s, ou cerca de 10 Mbit/s, mesmo em um enlace de 10 Gbit/s. Para encher um enlace, a janela precisa ser tão grande quanto o produto banda-atraso, largura de banda × tempo de ida e volta: um caminho de 1 Gbit/s com ida e volta de 50 ms comporta 6,25 MB em trânsito. Sistemas modernos escalam a janela automaticamente (a opção de escala de janela e o ajuste automático de buffers), mas o limite aparece com um buffer configurado pequeno, com um receptor que lê devagar e em transferências de longa distância.
As novas conexões também começam com uma janela de congestionamento pequena e a aumentam a cada ida e volta, uma fase chamada partida lenta (slow start). O tamanho inicial comum é de 10 segmentos (cerca de 14,6 KB), e ele praticamente dobra a cada ida e volta enquanto nada se perde. Contando as idas e voltas necessárias para uma resposta a partir de uma conexão fria:
| Tamanho da resposta | Idas e voltas (janela inicial de 10 segmentos, dobrando, sem perda) |
|---|---|
| 15 KB | 2 |
| 100 KB | 3 |
| 1 MB | 7 |
| 10 MB | 10 |
Com 100 ms de tempo de ida e volta, uma resposta de 1 MB sobre uma conexão novinha gasta 700 ms só para ganhar velocidade, antes mesmo de a largura de banda importar. Esse é um segundo motivo, depois do handshake, para reutilizar conexões: uma conexão aquecida já fez crescer a sua janela. (O Linux pode reiniciar a janela depois de um período de inatividade, e é por isso que uma conexão de um pool que ficou parada por um tempo pode voltar a ficar lenta; verifique a configuração tcp_slow_start_after_idle nos seus hosts.)
O controle de congestionamento, o algoritmo que decide como a janela cresce e diminui diante de perda ou atraso, é uma configuração do kernel. Hosts Linux costumam usar o CUBIC, e a VM desta medição estava configurada com BBR. Você raramente o ajusta, mas ele explica por que a mesma transferência se comporta de forma diferente em hosts diferentes.
5. A pausa de 40 milissegundos: o algoritmo de Nagle e as confirmações atrasadas
Duas otimizações sensatas, uma de cada lado, se combinam em uma patologia famosa.
- O algoritmo de Nagle (lado do remetente) poupa a rede de pacotes minúsculos: se há dados não confirmados em trânsito, uma escrita pequena é retida até que uma confirmação chegue, de modo que várias escritas pequenas saiam em um pacote só.
- A confirmação atrasada (lado do receptor) poupa a rede de confirmações minúsculas: o receptor espera um pouco (até 40 ms no Linux) na esperança de anexar a confirmação a uma resposta que está prestes a enviar.
Agora pegue um cliente que envia uma requisição como duas escritas pequenas, um cabeçalho de 4 bytes e depois um corpo de 100 bytes, e espera a resposta:
Diagram: Nagle plus delayed ACK: the stall
O cliente espera uma confirmação antes de enviar o corpo, e o servidor espera o corpo (ou um temporizador) antes de confirmar. Nada se perde, e nada é rápido: a requisição passa cerca de 40 ms em um impasse que o temporizador de atraso desfaz.
Medido no loopback, 300 requisições em uma conexão, cada uma enviada como write(4 bytes), write(100 bytes), e então a espera de uma resposta de um byte:
| Configuração | Média por requisição | Percentil 99 |
|---|---|---|
| Nagle ativado (o socket padrão), duas escritas | 44,02 ms | 47,32 ms |
TCP_NODELAY, duas escritas | 0,02 ms | 0,05 ms |
| Nagle ativado, uma escrita de 104 bytes | 0,01 ms | 0,04 ms |
Os mesmos bytes, a mesma máquina e um fator de dois mil entre a primeira linha e as outras. Um serviço com esse padrão mostra uma latência suspeitosamente presa em redondos 40 ms (ou um múltiplo) e uma CPU ociosa.
Há duas correções, e a segunda é melhor:
- Defina
TCP_NODELAYno socket, o que desliga o Nagle. O Go faz isso por padrão em conexões TCP; muitos outros ambientes de execução e bibliotecas não fazem, então verifique o que você usa. O custo é mais pacotes pequenos se o programa escrever em muitos pedaços minúsculos. - Não faça várias escritas pequenas para uma mensagem. Monte a mensagem inteira em um buffer (um escritor com buffer, ou reúna as partes em uma única escrita) e envie de uma vez. Isso é mais rápido em qualquer configuração: menos chamadas de sistema, menos pacotes e nenhuma interação com os temporizadores.
O padrão a observar tem nome, write-write-read: duas escritas seguidas e depois a espera da resposta. Ele é comum em código que envia um cabeçalho e um corpo separadamente, em implementações de protocolo escritas direto a partir de uma especificação e em clientes que descarregam um escritor com buffer no meio de uma mensagem.
6. Um fluxo não tem mensagens: enquadramento
Como o TCP é um fluxo, a aplicação precisa marcar onde uma mensagem termina. Protocolos reais fazem isso de três maneiras: um prefixo de tamanho (a mensagem começa com o seu tamanho, como na maioria dos protocolos binários e no Content-Length do HTTP), um delimitador (uma quebra de linha ou uma sequência especial de bytes, como em protocolos baseados em linhas, com escape se o delimitador puder ocorrer nos dados) ou um tamanho fixo. Um prefixo de tamanho é o mais simples e o mais seguro. O código abaixo mostra os três hábitos que importam: ler exatamente o número de bytes de que você precisa (io.ReadFull, porque um único Read pode devolver menos), recusar tamanhos absurdos antes de alocar memória e escrever o tamanho e o conteúdo com uma única escrita.
const maxMessage = 1 << 20
// readMessage reads one message that is sent as a 4-byte length followed by that many bytes.
func readMessage(r io.Reader) ([]byte, error) {
var n uint32
if err := binary.Read(r, binary.BigEndian, &n); err != nil {
return nil, err
}
if n > maxMessage { // never trust a length that came from the network
return nil, errors.New("message too large")
}
buf := make([]byte, n)
_, err := io.ReadFull(r, buf) // Read may return fewer bytes than asked; ReadFull loops until it has all of them
return buf, err
}
// writeMessage sends the length and the payload with one write, so Nagle's algorithm never holds back the second half.
func writeMessage(w io.Writer, payload []byte) error {
buf := make([]byte, 4+len(payload))
binary.BigEndian.PutUint32(buf, uint32(len(payload)))
copy(buf[4:], payload)
_, err := w.Write(buf)
return err
}
func call(addr string, payload []byte) ([]byte, error) {
d := net.Dialer{
Timeout: 3 * time.Second, // the handshake
KeepAlive: 30 * time.Second, // probes on an idle connection, well below a load balancer's idle timeout
}
c, err := d.Dial("tcp", addr)
if err != nil {
return nil, err
}
defer c.Close()
c.SetDeadline(time.Now().Add(5 * time.Second)) // one limit for the whole exchange
if err := writeMessage(c, payload); err != nil {
return nil, err
}
return readMessage(bufio.NewReader(c))
}
(A listagem compila; é uma ilustração, não um protocolo completo.) O mesmo exemplo mostra a forma correta de definir limites em uma conexão, que é o assunto das próximas seções: um timeout de discagem, um período de keep-alive e um prazo para a troca inteira.
7. Fechando conexões: TIME_WAIT e o esgotamento de portas
Quando uma conexão é fechada de forma ordenada, o lado que fecha primeiro não a esquece de imediato. Ele mantém a conexão no estado TIME_WAIT por duas vezes o tempo máximo de vida de um segmento, que é de 60 segundos no Linux. O motivo é sólido: um pacote duplicado e atrasado da conexão antiga não pode ser tomado como parte de uma nova conexão com os mesmos endereços e portas, e a confirmação final pode ter se perdido e precisar ser reenviada.
Um socket em TIME_WAIT custa pouca memória, mas ocupa a sua porta local em relação àquele destino durante todos os 60 segundos. Um cliente que se conecta a um endereço de servidor tem cerca de 28.000 portas efêmeras (nesta máquina a faixa é de 32768 a 60999, 28.232 portas). Se 28.232 portas ficam presas por 60 segundos cada, o teto é de cerca de 470 novas conexões por segundo para um destino. Além disso, connect falha com "cannot assign requested address".
Medido no loopback, um cliente abriu 40.000 conexões curtas para um endereço, fechando cada uma primeiro. Com a configuração que permite ao kernel reutilizar portas em TIME_WAIT desligada:
| Configuração | Conexões tentadas | Falhas | Sockets em TIME_WAIT depois |
|---|---|---|---|
| Reutilização de portas em TIME_WAIT desligada | 40.000 | 8.091 ("cannot assign requested address") | 16.774 |
| Padrão do Linux neste host (reutilização só para loopback) | 40.000 | 0 | 20.405 |
A configuração padrão esconde o problema no loopback, e é por isso que um teste em uma máquina passa e a produção falha: o kernel aplica a regra de reutilização somente ao loopback, então o mesmo código falando com um servidor remoto de verdade bate no limite de portas. Nas duas execuções, dezenas de milhares de sockets estavam em TIME_WAIT no final. (O número de falhas fica abaixo das 11.768 conexões além da faixa de portas porque sockets em TIME_WAIT do início da execução expiraram enquanto ela ainda corria.)
O que fazer, em ordem de preferência:
- Reutilizar conexões (seção 3). Um pool transforma milhares de conexões por segundo em algumas dezenas.
- Distribuir entre mais destinos ou endereços de origem se você realmente precisa de uma taxa de conexões muito alta: o limite se aplica por combinação de endereços e porta de destino.
- Deixar o outro lado fechar primeiro quando você controla o protocolo. O TIME_WAIT fica com o lado que fecha primeiro; em um protocolo em que o servidor pode enviar "terminei" e fechar, o cliente é poupado. (Para servidores, sockets em TIME_WAIT não consomem portas da mesma maneira, porque cada cliente tem um endereço diferente.)
- Ampliar a faixa de portas efêmeras, um paliativo que move o teto sem remover a causa.
- Não "conserte" encurtando o TIME_WAIT nem com opções perigosas que o ignoram (o
tcp_tw_recyclefoi removido do Linux porque quebrava conexões atrás de NAT). O estado existe por uma razão.
Uma configuração relacionada e inofensiva: servidores que reiniciam e não conseguem se associar à porta por causa de conexões antigas precisam de SO_REUSEADDR no socket de escuta, que a maioria das bibliotecas de servidor define por você.
8. Quando o servidor não acompanha: o backlog de accept
Um servidor que escuta mantém duas filas para cada socket de escuta: conexões que ainda estão fazendo o handshake e conexões que completaram o handshake mas ainda não foram pegas pelo accept do programa. A segunda fila tem um comprimento limitado, o backlog. Se o programa está ocupado demais para chamar accept com rapidez suficiente (um laço de eventos bloqueado, um pool de threads esgotado), a fila enche, e os handshakes seguintes são ignorados. O cliente não recebe um erro. O seu kernel simplesmente retransmite o primeiro pacote depois de um temporizador: 1 segundo, depois mais 2, depois mais 4, e assim por diante.
Medido: um servidor que escuta com um backlog de 1 e só começa a aceitar 2,5 segundos depois. Quatro clientes se conectam um após o outro.
| Cliente | Pediu em | Conectou depois de |
|---|---|---|
| 1 | 0,00 s | 0,000 s (a fila tinha espaço) |
| 2 | 0,00 s | 0,000 s (a fila tinha espaço) |
| 3 | 0,00 s | 3,061 s |
| 4 | 3,06 s | 0,000 s |
A conexão 3 encontrou a fila cheia no segundo 0. O servidor começou a aceitar em 2,5 segundos, mas o cliente esperava o seu temporizador de retransmissão, que disparou em 1 segundo (fila ainda cheia) e em 3 segundos (sucesso). Um servidor que se recupera ainda deixa alguns clientes esperando por um temporizador de retransmissão, então a sobrecarga aparece como degraus de latência de 1 s, 3 s, 7 s e como timeouts, enquanto os gráficos do próprio servidor mostram carga baixa e respostas rápidas para as requisições que ele processou. As requisições que nunca entraram são invisíveis para as suas métricas.
O que observar e fazer:
- Latências agrupadas em 1, 3 ou 7 segundos apontam para handshakes descartados.
- Dimensione o backlog com bom senso. O comprimento real da fila é o menor entre o valor do programa e o limite do kernel (
net.core.somaxconn; neste host 4096), e a outra fila, de handshakes semiabertos, tem o seu próprio limite (tcp_max_syn_backlog, 512 aqui, com SYN cookies como recurso de reserva). Os servidores padrão de muitas linguagens já escolhem o limite do kernel. - Não esconda a sobrecarga com uma fila funda. Uma fila longa apenas transforma "recusado" em "lento". Aplique descarte de carga (load shedding) e timeouts: rejeite rápido e deixe o chamador tentar de novo em outro lugar.
- Garanta que o laço de accept nunca bloqueie em trabalho da aplicação.
9. Saber que o outro lado sumiu: keepalive, timeouts e conexões semiabertas
Se um par cai de forma limpa, o sistema operacional fecha os seus sockets e envia um FIN ou RST, e você fica sabendo. Se uma máquina perde energia, é particionada, ou um NAT ou firewall esquece a conexão em silêncio, nada é enviado, e o seu socket continua ESTABLISHED. Isso é uma conexão semiaberta. Quanto tempo você espera depende do que faz:
- Se você está enviando dados, o kernel retransmite e por fim desiste depois de
tcp_retries2tentativas, o que com o padrão de 15 leva cerca de 15 minutos. Uma escrita para um par morto pode parecer bem-sucedida por muito tempo. - Se você está apenas lendo, espera para sempre, a menos que algo sonde a conexão.
- O keepalive do próprio kernel sonda uma conexão ociosa, mas seus padrões são muito preguiçosos: 7.200 segundos de inatividade, depois uma sonda a cada 75 segundos, até 9 sondas, ou seja, mais de duas horas para notar um par morto (esses são os valores deste host). Além disso, o keepalive fica desligado a menos que o programa o ative no socket.
A conclusão é que você precisa definir os seus próprios timeouts e não depender dos padrões:
- Um timeout de conexão (segundos, não minutos).
- Um prazo por requisição, cobrindo a troca inteira (como no código acima), ou pelo menos um timeout de leitura. Sem isso, um único par morto pode prender uma thread, uma conexão e a requisição de um usuário por 15 minutos.
- Keepalive com período curto em conexões ociosas de longa duração (o exemplo usa 30 segundos), ou heartbeats no nível da aplicação (uma mensagem de ping a cada poucos segundos, que também testa se o outro programa, e não só o seu kernel, está vivo).
- Novas tentativas com limites e backoff, sobre operações idempotentes (veja o guia sobre idempotência).
Uma armadilha relacionada fica no meio da rede: balanceadores de carga, gateways NAT e firewalls descartam conexões ociosas em silêncio depois de um tempo que costuma ficar entre um e alguns minutos. O próximo pacote em uma conexão assim é respondido com um reset, ou com nada. Defina o período do keepalive ou do heartbeat abaixo do menor timeout de inatividade no caminho, e deixe os pools de conexões descartarem conexões que ficaram ociosas por mais tempo que isso.
10. Lendo os sintomas
| Sintoma | Causa provável | Onde olhar |
|---|---|---|
| Latência presa em cerca de 40 ms, CPU ociosa | write-write-read com Nagle e ACK atrasado | duas escritas por mensagem; defina TCP_NODELAY ou una as escritas |
| Latência ocasional de 1, 3 ou 7 s; conexões recusadas ou com timeout | fila de accept cheia, handshakes descartados | contadores de listen overflow em nstat ou netstat -s; backlog; laço de accept bloqueado |
| "Cannot assign requested address", milhares de TIME_WAIT | muitas conexões curtas de uma origem para um destino | ss -s; reutilização e pool de conexões |
| Número crescente de sockets em CLOSE_WAIT | o programa não fecha os sockets | close ausente em um caminho de erro; contagem de descritores de arquivo |
| Travamentos de muitos minutos após uma falha do par ou da rede | sem timeouts; conexão semiaberta | prazos, keepalive, heartbeats |
| Resets ou travamentos em conexões ociosas por cerca de um minuto | timeout de inatividade de um intermediário | período de keepalive abaixo do timeout de inatividade; expiração no pool |
| Rápido na mesma máquina, lento entre regiões | limites de janela e de ida e volta; nova conexão por requisição | produto banda-atraso; reutilização; buffers maiores |
As ferramentas a usar: ss -tan (estados e comprimentos de fila por socket), ss -s (um resumo dos estados), nstat ou netstat -s (contadores de retransmissões e de overflow de escuta), tcpdump ou Wireshark (os pacotes reais: o intervalo de 40 ms e as retransmissões ficam visíveis de imediato) e, para HTTP, curl -w com variáveis de tempo para ver o tempo de cada fase (resolução de nome, conexão, TLS, primeiro byte).
11. Erros comuns
- Abrir uma conexão a cada requisição, e depois se surpreender com a latência, o uso de CPU e o TIME_WAIT.
- Dividir uma mensagem em várias escritas pequenas sem um buffer; a pausa da seção 5.
- Supor que um
readdevolve uma mensagem inteira, ou que umwriteescreve tudo. Use enquadramento e repita em leituras e escritas parciais (io.ReadFull,io.Copy, um escritor com buffer). - Confiar nos timeouts padrão. Quase nenhum padrão é certo para um serviço: conexão, leitura, escrita e inatividade precisam todos de valores explícitos.
- Tratar um
writebem-sucedido ou um ACK como "o outro lado fez". Espere uma resposta no nível da aplicação e torne a operação idempotente para que uma nova tentativa seja segura. - Vazar sockets, que aparece como CLOSE_WAIT e uma contagem crescente de descritores de arquivo.
- Testar apenas no loopback ou em um data center. Distância, perda e intermediários criam as falhas; teste o caminho lento de propósito.
- Mexer em configurações perigosas do kernel por causa de um sintoma (encurtar o TIME_WAIT, reciclar) sem entender a causa.
- Aprofundar a fila de accept para consertar a sobrecarga, em vez de rejeitar cedo.
12. O que mencionar em uma entrevista
- O TCP é um fluxo de bytes confiável e ordenado: sem fronteiras de mensagem, sem garantia de que o par processou alguma coisa e sem como detectar um par silencioso sem temporizadores.
- Uma nova conexão custa pelo menos uma ida e volta, mais o TLS, mais a partida lenta, então mantenha as conexões abertas e use pools. Dê os números: com 100 ms de ida e volta, uma nova conexão com TLS 1.3 acrescenta 200 ms antes mesmo de a requisição sair.
- A vazão é limitada por janela ÷ tempo de ida e volta; para encher um tubo longo e largo, a janela precisa chegar ao produto banda-atraso.
- A interação entre Nagle e ACK atrasado (uma pausa de 40 ms em um padrão write-write-read) e as duas correções:
TCP_NODELAYe uma escrita por mensagem. - TIME_WAIT: para que serve, quem o mantém e como um cliente com muitas conexões curtas fica sem portas efêmeras (cerca de 470 novas conexões por segundo por destino, com 60 s de retenção e 28.000 portas). A cura é a reutilização.
- CLOSE_WAIT significa um bug no seu programa.
- Descreva o backlog de accept e por que a sobrecarga aparece como atrasos de retransmissão que as métricas do servidor não mostram.
- Descreva as conexões semiabertas e por que toda chamada precisa de um prazo, e como o keepalive e os heartbeats diferem.
- Use medições para fazer o argumento: "Eu medi uma pausa de 44 ms que caiu para 0,02 ms."
Resumo rápido
- O TCP dá um fluxo de bytes confiável e ordenado, não mensagens, e não prova de que o par agiu. Acrescente enquadramento e respostas no nível da aplicação.
- Uma nova conexão custa idas e voltas (1 para o TCP, 1 a mais para o TLS 1.3) mais a partida lenta; medido 7 vezes o custo de CPU de uma conexão reutilizada, mesmo no loopback. Use pools e reutilize.
- A velocidade é limitada por janela ÷ tempo de ida e volta; longas distâncias precisam de uma janela do tamanho do produto banda-atraso.
- Nagle mais ACK atrasado transforma o write-write-read em uma pausa de 40 ms (medido 44 ms contra 0,02 ms). Envie cada mensagem em uma escrita e defina
TCP_NODELAY. - O TIME_WAIT dura 60 s no lado que fecha primeiro; muitas conexões curtas esgotam cerca de 28.000 portas (medido: 8.091 de 40.000 conexões falharam com a reutilização desligada).
- Uma fila de accept cheia descarta handshakes e aparece como atrasos de 1, 3, 7 segundos (medido 3,06 s). Rejeite cedo em vez de enfileirar fundo.
- Pares mortos são silenciosos. Defina prazos de conexão e de requisição, keepalive curto ou heartbeats, e mantenha-os abaixo de todo timeout de inatividade no caminho.
Apêndice: o código dos experimentos
O main.go abaixo (chamado tcpx nas medições) contém os quatro experimentos, um por comando: go run . nagle, go run . setup, go run . backlog e go run . timewait 40000. Eles usam apenas a biblioteca padrão do Go e precisam de Linux (o programa lê /proc/net/tcp para contar os sockets por estado). A execução de esgotamento de portas foi feita duas vezes: uma com a configuração padrão e outra depois de escrever 0 em /proc/sys/net/ipv4/tcp_tw_reuse (isso exige root, e a configuração deve ser restaurada ao valor anterior depois).
main.go
// tcpx: small experiments on TCP behaviour over the loopback interface (Linux). Usage: go run . nagle|setup|timewait|backlog
package main
import (
"bufio"
"errors"
"fmt"
"io"
"net"
"os"
"sort"
"strings"
"syscall"
"time"
)
func must(err error) {
if err != nil {
panic(err)
}
}
func pct(d []time.Duration, p float64) time.Duration {
s := append([]time.Duration(nil), d...)
sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
return s[int(float64(len(s)-1)*p)]
}
// ---------- 1. Nagle's algorithm and delayed acknowledgements ----------
// A server that reads a 4-byte header and a 100-byte body, then answers with one byte.
func requestServer(ln net.Listener, noDelay bool) {
for {
c, err := ln.Accept()
if err != nil {
return
}
go func(c net.Conn) {
defer c.Close()
c.(*net.TCPConn).SetNoDelay(noDelay)
buf := make([]byte, 104)
for {
if _, err := io.ReadFull(c, buf); err != nil {
return
}
c.Write([]byte{1})
}
}(c)
}
}
func nagleRun(noDelay, oneWrite bool, n int) (avg, p99 time.Duration) {
ln, err := net.Listen("tcp", "127.0.0.1:0")
must(err)
defer ln.Close()
go requestServer(ln, noDelay)
c, err := net.Dial("tcp", ln.Addr().String())
must(err)
defer c.Close()
c.(*net.TCPConn).SetNoDelay(noDelay)
hdr, body, both, one := make([]byte, 4), make([]byte, 100), make([]byte, 104), make([]byte, 1)
var lat []time.Duration
for i := 0; i < n; i++ {
t := time.Now()
if oneWrite {
c.Write(both)
} else {
c.Write(hdr) // two small writes, then wait for the answer: the classic write-write-read
c.Write(body)
}
io.ReadFull(c, one)
lat = append(lat, time.Since(t))
}
var sum time.Duration
for _, d := range lat {
sum += d
}
return sum / time.Duration(len(lat)), pct(lat, 0.99)
}
func nagle() {
fmt.Println("write(4 bytes), write(100 bytes), then wait for a 1-byte answer; 300 requests on one connection")
for _, tc := range []struct {
name string
noDelay, single bool
}{
{"Nagle on (default socket), two writes", false, false},
{"TCP_NODELAY, two writes", true, false},
{"Nagle on (default socket), one write ", false, true},
} {
avg, p99 := nagleRun(tc.noDelay, tc.single, 300)
fmt.Printf(" %-42s average %8.2f ms 99th percentile %8.2f ms\n", tc.name, float64(avg.Microseconds())/1000, float64(p99.Microseconds())/1000)
}
}
// ---------- 2. What a new connection costs ----------
func echoServer(ln net.Listener) {
for {
c, err := ln.Accept()
if err != nil {
return
}
go func(c net.Conn) {
defer c.Close()
io.Copy(c, c)
}(c)
}
}
func setup() {
ln, err := net.Listen("tcp", "127.0.0.1:0")
must(err)
defer ln.Close()
go echoServer(ln)
addr := ln.Addr().String()
one := []byte{1}
rt := func(c net.Conn) { c.Write(one); io.ReadFull(c, make([]byte, 1)) }
const n = 5000
c, err := net.Dial("tcp", addr)
must(err)
t := time.Now()
for i := 0; i < n; i++ {
rt(c)
}
reuse := time.Since(t) / n
c.Close()
t = time.Now()
for i := 0; i < n; i++ {
c, err := net.Dial("tcp", addr)
must(err)
rt(c)
c.Close()
}
fresh := time.Since(t) / n
fmt.Printf("loopback, one request of 1 byte: reused connection %.1f us, new connection each time %.1f us (%.1fx)\n",
float64(reuse.Nanoseconds())/1000, float64(fresh.Nanoseconds())/1000, float64(fresh)/float64(reuse))
fmt.Println("(loopback has no distance, so this is the CPU and kernel cost only. On a real network every new connection also costs the round trips below.)")
fmt.Println()
fmt.Println("round trips before the first byte of a response, by round-trip time (RTT):")
fmt.Printf(" %-8s %-26s %-30s %-30s\n", "RTT", "reused connection", "new TCP connection", "new TCP + TLS 1.3 (full)")
for _, rtt := range []int{1, 10, 50, 100, 200} {
fmt.Printf(" %-8s %-26s %-30s %-30s\n", fmt.Sprintf("%d ms", rtt), fmt.Sprintf("%d ms", rtt), fmt.Sprintf("%d ms", 2*rtt), fmt.Sprintf("%d ms", 3*rtt))
}
// slow start: how many round trips to send 100 KB, 1 MB, 10 MB from a cold connection with an initial window of 10 segments
fmt.Println()
fmt.Println("slow start: round trips to send a response over a new connection (initial window 10 segments of 1,460 bytes, doubling every round trip, no loss)")
for _, size := range []int{15_000, 100_000, 1_000_000, 10_000_000} {
w, sent, rounds := 10*1460, 0, 0
for sent < size {
sent += w
w *= 2
rounds++
}
fmt.Printf(" %10s bytes: %d round trips\n", commas(size), rounds)
}
}
func commas(n int) string {
s := fmt.Sprint(n)
var out []string
for len(s) > 3 {
out = append([]string{s[len(s)-3:]}, out...)
s = s[:len(s)-3]
}
return strings.Join(append([]string{s}, out...), ",")
}
// ---------- 3. TIME_WAIT ----------
func countStates() map[string]int {
names := map[string]string{"01": "ESTABLISHED", "06": "TIME_WAIT", "08": "CLOSE_WAIT", "0A": "LISTEN"}
out := map[string]int{}
for _, f := range []string{"/proc/net/tcp", "/proc/net/tcp6"} {
fh, err := os.Open(f)
if err != nil {
continue
}
sc := bufio.NewScanner(fh)
sc.Scan()
for sc.Scan() {
fs := strings.Fields(sc.Text())
if len(fs) > 3 {
if n, ok := names[fs[3]]; ok {
out[n]++
}
}
}
fh.Close()
}
return out
}
func timewait() {
ln, err := net.Listen("tcp", "127.0.0.1:0")
must(err)
defer ln.Close()
go func() { // server: read to EOF, then close (so the CLIENT closes first and keeps the TIME_WAIT)
for {
c, err := ln.Accept()
if err != nil {
return
}
go func(c net.Conn) { io.Copy(io.Discard, c); c.Close() }(c)
}
}()
addr := ln.Addr().String()
before := countStates()["TIME_WAIT"]
n := 20000
if len(os.Args) > 2 {
fmt.Sscan(os.Args[2], &n)
}
t := time.Now()
failures := 0
var firstErr error
for i := 0; i < n; i++ {
c, err := net.DialTimeout("tcp", addr, 2*time.Second)
if err != nil {
failures++
if firstErr == nil {
firstErr = err
}
continue
}
c.Close()
}
el := time.Since(t)
st := countStates()
fmt.Printf("%d short connections to one address, the client closing first, in %.1f s (%.0f per second)\n", n, el.Seconds(), float64(n)/el.Seconds())
fmt.Printf(" sockets in TIME_WAIT: %d before, %d after (failed connects: %d)\n", before, st["TIME_WAIT"], failures)
if firstErr != nil {
fmt.Println(" first error:", firstErr)
}
lo, hi := portRange()
fmt.Printf(" ephemeral port range %d-%d = %d ports; a port towards one destination is blocked for 60 s after a close, so the ceiling is about %d new connections per second per destination\n",
lo, hi, hi-lo+1, (hi-lo+1)/60)
}
func portRange() (int, int) {
b, _ := os.ReadFile("/proc/sys/net/ipv4/ip_local_port_range")
var lo, hi int
fmt.Sscan(string(b), &lo, &hi)
return lo, hi
}
// ---------- 4. The accept backlog ----------
func backlog() {
fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
must(err)
defer syscall.Close(fd)
must(syscall.Bind(fd, &syscall.SockaddrInet4{Port: 0, Addr: [4]byte{127, 0, 0, 1}}))
must(syscall.Listen(fd, 1)) // backlog of 1, and the program never calls accept
sa, _ := syscall.Getsockname(fd)
addr := fmt.Sprintf("127.0.0.1:%d", sa.(*syscall.SockaddrInet4).Port)
fmt.Println("a server that listens with a backlog of 1 and does not call accept at first; clients connect one after the other; accept starts after 2.5 s")
// The server starts accepting after 2.5 seconds, which empties the queue.
go func() {
time.Sleep(2500 * time.Millisecond)
for {
nfd, _, err := syscall.Accept(fd)
if err != nil {
return
}
syscall.Close(nfd)
}
}()
var keep []net.Conn
start := time.Now()
for i := 1; i <= 4; i++ {
t := time.Now()
c, err := net.DialTimeout("tcp", addr, 10*time.Second)
d := time.Since(t)
if err != nil {
var ne net.Error
kind := "error"
if errors.As(err, &ne) && ne.Timeout() {
kind = "timed out"
}
fmt.Printf(" connection %d: %s after %.2f s\n", i, kind, d.Seconds())
continue
}
keep = append(keep, c)
fmt.Printf(" connection %d: asked at %.2f s, connected after %.3f s\n", i, t.Sub(start).Seconds(), d.Seconds())
}
for _, c := range keep {
c.Close()
}
}
func main() {
if len(os.Args) < 2 {
fmt.Println("usage: tcpx nagle|setup|timewait|backlog")
return
}
switch os.Args[1] {
case "nagle":
nagle()
case "setup":
setup()
case "timewait":
timewait()
case "backlog":
backlog()
}
}
Fontes
- Wesley M. Eddy (ed.), RFC 9293: Transmission Control Protocol (TCP), 2022, a especificação atual: estados, TIME_WAIT, retransmissão.
- John Nagle, RFC 896: Congestion Control in IP/TCP Internetworks, 1984 (o algoritmo de Nagle), e RFC 1122: Requirements for Internet Hosts, 1989 (confirmações atrasadas, keepalive).
- RFC 5681: TCP Congestion Control (partida lenta) e RFC 6928: Increasing TCP's Initial Window (janela inicial de 10 segmentos).
- RFC 7323: TCP Extensions for High Performance (escala de janela) e RFC 1337: TIME-WAIT Assassination Hazards in TCP.
- A página de manual do Linux tcp(7): as configurações
tcp_tw_reuse,tcp_retries2,tcp_keepalive_*,tcp_max_syn_backlogeTCP_NODELAY. - Neal Cardwell et al., BBR: Congestion-Based Congestion Control, ACM Queue, 2016.
- W. Richard Stevens, TCP/IP Illustrated, Volume 1: The Protocols (Addison-Wesley), os capítulos sobre estabelecimento e encerramento de conexões, Nagle e confirmações atrasadas.
- A documentação do Go para o pacote net (
TCPConn.SetNoDelay,Dialer.KeepAlive, prazos).
Pratique este tema: Networking & APIs