К содержимому
Войти

Python Road Map

📦 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 делает четыре вещи:

  1. Нумерует байты. У каждого сегмента есть порядковый номер, получатель собирает поток по номерам и выбрасывает дубли
  2. Подтверждает и переотправляет. Получатель шлёт ACK, а отправитель, не дождавшись подтверждения, отправляет сегмент снова
  3. Управляет потоком. Получатель сообщает размер окна, сколько байтов он готов принять. Медленный читатель не захлебнётся данными
  4. Управляет перегрузкой. Отправитель начинает осторожно и разгоняется, пока сеть не начнёт терять пакеты. В Linux начальное окно перегрузки 10 сегментов, это около 14 КБ. Поэтому первые килобайты на новом соединении идут медленнее, чем на прогретом

Цена этих гарантий:

  • Рукопожатие перед данными: SYN, SYN-ACK, ACK, и только потом первый байт. Это целый RTT на каждое новое соединение
  • Состояние на обеих сторонах. Ядро держит буферы, номера и таймеры на каждое соединение, даже на закрытое (про это — TIME_WAIT ниже)
  • Блокировка очереди, head-of-line blocking. Если потерялся один сегмент, приложение не получит следующие байты, пока его не переотправят, даже если они уже пришли. Для одного потока это нормально. Для HTTP/2, который гонит десятки запросов по одному соединению, одна потеря тормозит все запросы разом

UDP почти ничего не добавляет к IP: порты отправителя и получателя, длину и контрольную сумму. Заголовок 8 байт против минимум 20 у TCP. Нет соединения, нет подтверждений, нет порядка. Датаграмма либо дошла целиком, либо нет. Зато UDP сохраняет границы сообщений: одна запись на стороне отправителя — одно чтение на стороне получателя. TCP таких границ не знает, у него только поток байтов

TCPUDP
СоединениеЕсть, с рукопожатиемНет, сразу шлёшь датаграмму
Доставка и порядокГарантированыНе гарантированы
Единица данныхПоток байтов без границДатаграмма с границами
Перегрузка сетиСам снижает скоростьНичего не делает, это задача приложения
Где встречается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 идут и передачи целой зоны между серверами

📚 Что почитать