📦 TCP и UDP
Почти всё, с чем работает бэкендер, едет поверх TCP: HTTP/1.1 и HTTP/2, gRPC, протоколы Postgres, Redis и Kafka. UDP встречается реже, но именно на нём работают DNS и HTTP/3. От того, как устроен транспорт, зависят задержки, ошибки вида connection reset by peer и тысячи сокетов в TIME_WAIT на сервере. На собеседовании разница TCP и UDP — разминочный вопрос, а дальше спрашивают про рукопожатие, TIME_WAIT и QUIC
🧠 Как это устроено
TCP превращает ненадёжную сеть в надёжный поток байтов между двумя программами. Пакеты в интернете теряются, приходят не по порядку и дублируются, а приложение видит ровную последовательность байтов. Для этого TCP делает четыре вещи:
- Нумерует байты. У каждого сегмента есть порядковый номер, получатель собирает поток по номерам и выбрасывает дубли
- Подтверждает и переотправляет. Получатель шлёт ACK, а отправитель, не дождавшись подтверждения, отправляет сегмент снова
- Управляет потоком. Получатель сообщает размер окна, сколько байтов он готов принять. Медленный читатель не захлебнётся данными
- Управляет перегрузкой. Отправитель начинает осторожно и разгоняется, пока сеть не начнёт терять пакеты. В Linux начальное окно перегрузки 10 сегментов, это около 14 КБ. Поэтому первые килобайты на новом соединении идут медленнее, чем на прогретом
Цена этих гарантий:
- Рукопожатие перед данными: SYN, SYN-ACK, ACK, и только потом первый байт. Это целый RTT на каждое новое соединение
- Состояние на обеих сторонах. Ядро держит буферы, номера и таймеры на каждое соединение, даже на закрытое (про это — TIME_WAIT ниже)
- Блокировка очереди, head-of-line blocking. Если потерялся один сегмент, приложение не получит следующие байты, пока его не переотправят, даже если они уже пришли. Для одного потока это нормально. Для HTTP/2, который гонит десятки запросов по одному соединению, одна потеря тормозит все запросы разом
UDP почти ничего не добавляет к IP: порты отправителя и получателя, длину и контрольную сумму. Заголовок 8 байт против минимум 20 у TCP. Нет соединения, нет подтверждений, нет порядка. Датаграмма либо дошла целиком, либо нет. Зато UDP сохраняет границы сообщений: одна запись на стороне отправителя — одно чтение на стороне получателя. TCP таких границ не знает, у него только поток байтов
| TCP | UDP | |
|---|---|---|
| Соединение | Есть, с рукопожатием | Нет, сразу шлёшь датаграмму |
| Доставка и порядок | Гарантированы | Не гарантированы |
| Единица данных | Поток байтов без границ | Датаграмма с границами |
| Перегрузка сети | Сам снижает скорость | Ничего не делает, это задача приложения |
| Где встречается | HTTP/1.1, HTTP/2, gRPC, базы, брокеры | DNS, QUIC и HTTP/3, звонки и видео, игры, метрики StatsD |
Когда берут UDP
UDP выбирают, когда опоздавшие данные хуже потерянных или когда надёжность приложение строит само. В видеозвонке кадр, переотправленный через 300 мс, уже никому не нужен, проще показать следующий. DNS по UDP укладывает запрос и ответ в одну пару датаграмм, без рукопожатия. Если ответ не влезает, сервер обрезает его и ставит флаг TC, и клиент повторяет запрос уже по TCP. Поэтому DNS-серверу нужен открытый и 53/udp, и 53/tcp
Протокол QUIC, на котором работает HTTP/3, тоже живёт поверх UDP, хотя гарантирует доставку не хуже TCP. Он сам нумерует пакеты, переотправляет потери и управляет перегрузкой, но делает это для каждого потока отдельно: потерянный пакет тормозит только те запросы, чьи данные в нём были. Почему не сделали новый транспорт рядом с TCP, объясняет RFC 9308: UDP проходит через NAT и файрволы без обновления сетевого оборудования, а реализацию можно держать в приложении и обновлять вместе с ним, а не ждать новых ядер ОС. У этого есть обратная сторона: по тому же RFC от 3 до 5% сетей режут UDP целиком, и браузер тогда откатывается на HTTP/2 по TCP
Закрытие соединения и TIME_WAIT
Закрывают соединение обменом FIN и ACK в обе стороны. Та сторона, что закрыла первой, после этого не забывает соединение сразу, а переходит в TIME_WAIT на время 2×MSL (удвоенное максимальное время жизни сегмента в сети). В Linux это 60 секунд, значение зашито в ядро. Зачем:
- если последний ACK потерялся, вторая сторона переотправит FIN, и ей нужно ответить, а не сбросить соединение
- старые сегменты, застрявшие в сети, не попадут в новое соединение с теми же адресами и портами
TIME_WAIT становится проблемой у того, кто открывает много коротких соединений к одному адресу. Соединение определяется четвёркой «IP и порт клиента, IP и порт сервера». Свободные порты клиента в Linux по умолчанию берутся из диапазона 32768–60999, это 28 232 порта. Если каждое соединение после закрытия минуту висит в TIME_WAIT, к одному ip:порт получится открывать около 470 новых соединений в секунду. Дальше connect падает с cannot assign requested address. Лечится это почти всегда пулом соединений, а не настройками ядра
Два разных keep-alive
Слово одно, механизмы разные, и на собеседовании их любят путать:
- HTTP keep-alive — переиспользование одного TCP-соединения для нескольких HTTP-запросов. В HTTP/1.1 включено по умолчанию. Из-за него и существует пул соединений в
http.Transport - TCP keepalive — пустые пробы, которые ядро шлёт по простаивающему соединению, чтобы узнать, жив ли собеседник. В Linux по умолчанию первая проба уходит через 2 часа тишины. Go при
DialиListenвключает keepalive сам и ставит 15 секунд до первой пробы, 15 секунд между пробами и 9 проб
Зачем пробы, если соединение и так «есть»? Балансировщики, NAT и файрволы держат таблицу соединений и молча выкидывают тихие записи через несколько минут. Без проб приложение узнает о мёртвом соединении только на следующем запросе, когда получит connection reset by peer или зависнет до таймаута
🛠️ На практике
Главное, что надо почувствовать руками: TCP — поток, а не сообщения. Пример пишет два раза по пять байтов в TCP и в UDP и смотрит, сколько придёт за одно чтение:
Go · Границы сообщений в TCP и UDP
func main() {
// TCP: две записи клиента
ln, _ := net.Listen("tcp", "127.0.0.1:0")
go func() {
c, _ := net.Dial("tcp", ln.Addr().String())
c.Write([]byte("hello"))
c.Write([]byte("world"))
c.Close()
}()
conn, _ := ln.Accept()
time.Sleep(100 * time.Millisecond) // даём обеим записям дойти
buf := make([]byte, 64)
n, _ := conn.Read(buf)
fmt.Printf("TCP прочитал %d байт: %q\n", n, buf[:n])
// UDP: две датаграммы
pc, _ := net.ListenPacket("udp", "127.0.0.1:0")
c, _ := net.Dial("udp", pc.LocalAddr().String())
c.Write([]byte("hello"))
c.Write([]byte("world"))
for i := 0; i < 2; i++ {
n, _, _ := pc.ReadFrom(buf)
fmt.Printf("UDP прочитал %d байт: %q\n", n, buf[:n])
}
}TCP прочитал 10 байт: "helloworld"
UDP прочитал 5 байт: "hello"
UDP прочитал 5 байт: "world"TCP склеил две записи в одно чтение, UDP отдал две датаграммы по отдельности. Бывает и наоборот: одна большая запись в TCP приходит несколькими кусками. Поэтому любой протокол поверх TCP сам размечает сообщения: префиксом длины, как gRPC и Postgres, или разделителем, как HTTP/1.1 с его \r\n. В Go для этого читают через io.ReadFull или bufio.Reader, а не одним conn.Read
На Linux-сервере состояние TCP смотрят через ss:
# сколько соединений в каждом состоянии
ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c
# диапазон портов для исходящих соединений
sysctl net.ipv4.ip_local_port_rangeЕсли в выводе десятки тысяч TIME-WAIT к одному адресу, кто-то открывает соединение на каждый запрос. Тысячи CLOSE-WAIT — другая беда: собеседник закрыл соединение, а твоё приложение так и не вызвало Close. Это почти всегда утечка в коде, например не закрытое тело ответа
⚠️ Где ошибаются
- Читают TCP как сообщения. Один
conn.Readсчитают одним сообщением. На локальной машине всё работает, а в сети с другими задержками сообщения склеиваются и рвутся посередине. Нужна явная разметка иio.ReadFull - Открывают соединение на каждый запрос. Новый
http.Clientв каждом обработчике илиDisableKeepAlives: trueбез причины. Каждый запрос платит рукопожатием, а TIME_WAIT съедает порты. Клиент создают один раз на сервис - Лечат TIME_WAIT ядром. Крутят
sysctlвместо того, чтобы разобраться, кто открывает столько соединений. Параметрnet.ipv4.tcp_tw_reuseпо умолчанию разрешает переиспользовать TIME_WAIT только для loopback, а глобальное включение прячет настоящую причину: лишние соединения - Не ставят таймаут простоя меньше, чем у балансировщика. Балансировщик закрывает тихое соединение, скажем, через 60 секунд, а пул клиента считает его живым 90 секунд, как
DefaultTransportв Go. Первый запрос после паузы получаетconnection reset.IdleConnTimeoutклиента должен быть меньше таймаута простоя на пути - Думают, что UDP дойдёт. Метрики по UDP теряются под нагрузкой без единой ошибки в логах. Для метрик это допустимо, для платёжных событий — нет
🎯 Вопросы с собеседований
Чем TCP отличается от UDP?
TCP устанавливает соединение и даёт надёжный упорядоченный поток байтов: нумерует данные, подтверждает, переотправляет потери и сам снижает скорость при перегрузке. UDP шлёт отдельные датаграммы без соединения и без гарантий, зато без рукопожатия и с границами сообщений. За надёжность TCP платят задержкой на установку соединения, состоянием в ядре и блокировкой очереди при потерях. UDP берут для DNS, звонков, игр и как основу для QUIC
Зачем TCP трёхстороннее рукопожатие, почему не два шага?
Каждая сторона выбирает свой начальный порядковый номер, и обе должны убедиться, что другая его получила. Клиент шлёт свой номер в SYN, сервер подтверждает его и шлёт свой в SYN-ACK, клиент подтверждает номер сервера в ACK. Двух шагов не хватит: сервер не узнает, дошёл ли его номер, и не отличит свежий SYN от старого дубля, застрявшего в сети
Что такое TIME_WAIT и почему на сервере их может быть тысячи?
Это состояние, в котором остаётся сторона, первой закрывшая соединение. Оно длится 2×MSL, в Linux 60 секунд. Нужно, чтобы ответить на переотправленный FIN, если последний ACK потерялся, и чтобы старые сегменты не попали в новое соединение с той же четвёркой адресов. Тысячи TIME_WAIT значат, что кто-то открывает и закрывает много коротких соединений. Например, сервер отвечает с Connection: close или клиент не использует пул. Исправляют переиспользованием соединений
Чем HTTP keep-alive отличается от TCP keepalive?
HTTP keep-alive — это когда одно TCP-соединение обслуживает несколько HTTP-запросов подряд, чтобы не платить за рукопожатие каждый раз. TCP keepalive — пустые пробы, которые ядро шлёт по тихому соединению, чтобы заметить, что собеседник пропал. Первое про производительность, второе про обнаружение мёртвых соединений, особенно за NAT и балансировщиком. В Go TCP keepalive включён по умолчанию с интервалом 15 секунд
Почему HTTP/3 работает поверх UDP, если ему нужна надёжная доставка?
Надёжность QUIC делает сам: нумерует пакеты, переотправляет потери, управляет перегрузкой. Но делает это для каждого потока отдельно, поэтому потеря одного пакета не тормозит остальные запросы, как в HTTP/2 поверх TCP. UDP выбрали, потому что он проходит через существующие NAT и файрволы, а новый транспортный протокол они бы не пропустили. И реализация живёт в приложении, её можно обновлять без новой версии ядра. Ещё QUIC объединяет транспортное рукопожатие с TLS и экономит RTT
Что увидит клиент, если порт закрыт, и что, если пакеты режет файрвол?
Если на порту никто не слушает, ядро сервера отвечает на SYN пакетом RST, и клиент сразу получает connection refused. Если файрвол молча выбрасывает пакеты, ответа нет вовсе: клиент переотправляет SYN, пока не истечёт таймаут. В Linux без таймаута в приложении это больше минуты, по умолчанию 6 повторов. Поэтому быстрый отказ и долгое зависание указывают на разные причины
Почему DNS работает по UDP и когда переходит на TCP?
Обычный запрос и ответ помещаются в одну датаграмму, и UDP отвечает за один RTT без рукопожатия. Если ответ не влезает в разрешённый размер, сервер обрезает его и ставит флаг TC, и клиент повторяет запрос по TCP. Так бывает с большими ответами, например с подписями DNSSEC. По TCP идут и передачи целой зоны между серверами
📚 Что почитать
- Building Blocks of TCP и Building Blocks of UDP — главы из книги «High Performance Browser Networking»: рукопожатие, медленный старт, блокировка очереди, NAT и UDP
- RFC 9308: Applicability of the QUIC Transport Protocol — зачем QUIC поверх UDP и что с этим ломается в реальных сетях
- IP Sysctl — документация ядра Linux по сетевым параметрам: диапазон портов, keepalive,
tcp_tw_reuse - Пакет net: KeepAliveConfig — как Go настраивает TCP keepalive и какие значения ставит по умолчанию