🛣️ Как проходит запрос от URL до ответа
Между вызовом http.Get и первым байтом ответа запрос проходит пять-шесть этапов, и каждый может съесть сотни миллисекунд или повиснуть до таймаута. Бэкендеру эта цепочка нужна, когда сервис внезапно отвечает за две секунды вместо двадцати миллисекунд и надо понять, где именно теряется время. На собеседовании её спрашивают как «что происходит, когда вводишь адрес в браузере», и сильный ответ отличается от слабого тем, что кандидат считает задержки, а не перечисляет протоколы
🧠 Как это устроено
Возьмём запрос GET https://api.example.com/orders/42 с нового клиента, у которого ещё нет ни кэша, ни открытых соединений
- Разбор URL. Клиент достаёт схему (
httpsзначит порт 443 и TLS), хост и путь. Браузер вдобавок проверяет свой HTTP-кэш и список HSTS: если сайт там есть,http://молча превращается вhttps://без лишнего редиректа - DNS. Имя
api.example.comпревращается в IP-адрес. Сначала смотрят локальные кэши (браузер, ОС,/etc/hosts), потом идут к рекурсивному резолверу провайдера или компании. Тот, если у него нет ответа, спрашивает корневые серверы, серверы зоны.comи авторитетный серверexample.com. Ответ кэшируется на время TTL из записи: поэтому после смены IP часть клиентов ещё минуты или часы ходит на старый адрес - TCP-соединение. Трёхстороннее рукопожатие: клиент шлёт SYN, сервер отвечает SYN-ACK, клиент отправляет ACK. Это один полный RTT (round-trip time, время «туда и обратно»), и данные до его конца не идут
- TLS. Клиент и сервер договариваются о шифре, сервер показывает сертификат, клиент проверяет цепочку до доверенного корня и имя хоста. В TLS 1.3 полное рукопожатие занимает один RTT, в TLS 1.2 — два. Повторное соединение с тем же сервером в TLS 1.3 может отправить данные сразу (0-RTT), но атакующий может отправить такие данные повторно, поэтому серверы принимают их только для запросов, повтор которых ничего не ломает
- HTTP-запрос. Клиент отправляет строку запроса, заголовки и тело. Ещё один RTT плюс время, пока сервер считает ответ
- Балансировщик и прокси. Обычно запрос сначала попадает не в сервис, а на балансировщик или ingress: nginx, Envoy, облачный L7-балансировщик. Часто TLS заканчивается именно там, а дальше до сервиса идёт отдельное соединение, нередко обычный HTTP внутри сети. Балансировщик выбирает экземпляр сервиса и дописывает заголовки вроде
X-Forwarded-For, потому что сервис теперь видит IP балансировщика, а не клиента - Сервис. Роутер, middleware (логирование, авторизация, лимиты), обработчик, походы в базу, кэш и соседние сервисы. Каждый такой поход снова проходит часть этой цепочки, только внутри сети
- Ответ. Статус, заголовки, тело. Браузер дальше парсит HTML, находит CSS, JS и картинки и запускает те же шаги для каждого нового хоста
Сколько это стоит
Посчитаем, сколько RTT уходит до первого байта ответа при RTT 50 мс и пустых кэшах:
| Этап | RTT | Время при RTT 50 мс |
|---|---|---|
| DNS через резолвер | ~1 | ~50 мс, если резолверу не пришлось идти дальше |
| TCP | 1 | 50 мс |
| TLS 1.3 | 1 | 50 мс |
| HTTP-запрос и ответ | 1 | 50 мс плюс время работы сервера |
| Итого на новом соединении | ~4 | ~200 мс |
| Итого на открытом соединении | 1 | 50 мс |
По таблице видно, что новое соединение стоит в несколько раз дороже запроса по готовому. Поэтому HTTP-клиенты держат пул соединений (keep-alive) и переиспользуют их, а HTTP/3 переехал на QUIC поверх UDP: там транспортное и криптографическое рукопожатие объединены в одно, и новое соединение экономит один RTT. Подробнее про версии HTTP — на странице «HTTP: методы, коды и версии»
🛠️ На практике
Самый быстрый способ увидеть этапы — curl с форматом вывода. Все значения считаются от начала запроса, поэтому длительность этапа — разница соседних строк:
curl -s -o /dev/null -w 'dns %{time_namelookup}\ntcp %{time_connect}\ntls %{time_appconnect}\nttfb %{time_starttransfer}\ntotal %{time_total}\n' https://go.dev/dns 0.002820
tcp 0.057966
tls 0.168715
ttfb 0.388564
total 0.507564Здесь DNS ответил из кэша за 3 мс, TCP занял 55 мс, TLS ещё 111 мс, а отправка запроса и работа сервера до первого байта — 220 мс. Последние 120 мс ушли на передачу тела
В Go то же самое видно изнутри приложения через пакет net/http/httptrace: он даёт хуки на каждый этап клиентского запроса. Пример делает два запроса подряд, чтобы показать, что даёт пул соединений:
Go · Тайминги запроса через httptrace
func get(url string) {
var start, dns, conn, tlsDone time.Time
trace := &httptrace.ClientTrace{
DNSDone: func(httptrace.DNSDoneInfo) { dns = time.Now() },
ConnectDone: func(string, string, error) { conn = time.Now() },
TLSHandshakeDone: func(tls.ConnectionState, error) { tlsDone = time.Now() },
GotConn: func(i httptrace.GotConnInfo) {
fmt.Println("соединение переиспользовано:", i.Reused)
},
GotFirstResponseByte: func() {
fmt.Println("первый байт через", time.Since(start).Round(time.Millisecond))
},
}
req, _ := http.NewRequest("GET", url, nil)
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
start = time.Now()
resp, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
io.Copy(io.Discard, resp.Body) // дочитать тело, иначе соединение не вернётся в пул
resp.Body.Close()
if !dns.IsZero() {
fmt.Println("DNS:", dns.Sub(start).Round(time.Millisecond),
"TCP:", conn.Sub(dns).Round(time.Millisecond),
"TLS:", tlsDone.Sub(conn).Round(time.Millisecond))
}
}
func main() {
get("https://go.dev/")
get("https://go.dev/")
}соединение переиспользовано: false
первый байт через 747ms
DNS: 236ms TCP: 135ms TLS: 91ms
соединение переиспользовано: true
первый байт через 219msПервый запрос потратил почти полсекунды на DNS, TCP и TLS. Второй взял готовое соединение из пула: хуки DNS и TCP не сработали вовсе, и первый байт пришёл в три с лишним раза быстрее
Что смотреть при таймауте
Таймаут сам по себе ничего не говорит. Сначала выясни, на каком этапе он случился, и причина обычно сужается до двух-трёх вариантов:
| Где застряло | Частые причины |
|---|---|
| DNS | Резолвер медленный или недоступен. В Kubernetes под с ndots:5 сначала перебирает домены из search, и одно внешнее имя превращается в несколько запросов |
| TCP connect | Порт закрыт файрволом, и SYN просто пропадает. Сервер перегружен и не принимает соединения. Адрес из DNS устарел |
| TLS | Сертификат не проходит проверку, на клиенте нет нужного корневого сертификата, сервер тратит CPU на рукопожатия при всплеске новых соединений |
| Первый байт | Сервис медленно работает: долгий запрос в базу, блокировка, очередь в пуле соединений к БД, медленный соседний сервис |
| Тело ответа | Большой ответ, медленная сеть, сервис отдаёт данные потоком и тормозит посередине |
Если клиент видит таймаут, а в логах сервиса запроса нет вообще, запрос не дошёл до обработчика: ищи на этапах до него или на балансировщике
⚠️ Где ошибаются
- Клиент без таймаута. У
http.Clientв Go полеTimeoutпо умолчанию нулевое, а ноль означает «без ограничения». Зависший сосед держит горутину и соединение бесконечно, и под нагрузкой сервис падает следом. СтавьTimeoutу клиента или дедлайн черезcontextна каждый запрос - Тело ответа не дочитано и не закрыто. Тогда соединение не возвращается в пул, и каждый следующий запрос платит за новые TCP и TLS. Внешне это выглядит как «сервис медленный», хотя медленный клиент
- Маленький пул под нагрузкой. У
http.Transportв GoMaxIdleConnsPerHostпо умолчанию 2. Сервис, который шлёт сотни запросов в секунду в один соседний сервис, держит открытыми только два простаивающих соединения, остальные закрывает и открывает заново. Растут задержки и число сокетов вTIME_WAIT(про него — на странице «TCP и UDP») - Задержку меряют только на сервере. Метрика обработчика показывает 20 мс, а клиент видит 300 мс, потому что новые соединения, DNS и балансировщик в метрику сервиса не попадают. Смотри задержку и со стороны клиента
- Новый IP после переезда, а клиенты ходят на старый. Запись в DNS поменяли, но TTL был сутки, и кэши резолверов честно держат старый адрес. Перед переездом TTL понижают заранее
🎯 Вопросы с собеседований
Что происходит, когда вводишь адрес сайта в браузере?
Браузер разбирает URL и проверяет свой кэш. Потом DNS превращает имя в IP: локальные кэши, затем рекурсивный резолвер. Дальше TCP-рукопожатие, TLS-рукопожатие с проверкой сертификата, и только потом уходит HTTP-запрос. На стороне сервера его принимает балансировщик, передаёт экземпляру сервиса, тот ходит в базу и отвечает. Браузер парсит HTML и повторяет то же самое для CSS, скриптов и картинок. Хороший ответ добавляет цену: на новом HTTPS-соединении это около четырёх RTT до первого байта
Сколько round trip нужно до первого байта ответа на новом HTTPS-соединении?
Один на TCP, один на TLS 1.3 (или два на TLS 1.2), один на сам запрос. Плюс DNS, если имени нет в кэше. Итого три-четыре RTT для TLS 1.3. HTTP/3 на QUIC объединяет транспортное и TLS-рукопожатие и экономит один RTT, а повторное соединение с 0-RTT может отправить запрос сразу
Зачем нужен keep-alive и пул соединений?
Чтобы не платить за TCP и TLS на каждый запрос. Открытое соединение отвечает за один RTT, новое — за три-четыре и ещё за CPU на рукопожатие. В Go пул живёт в http.Transport, поэтому клиент создают один раз и переиспользуют, а тело ответа дочитывают и закрывают. Иначе соединение не вернётся в пул
Запрос к соседнему сервису падает по таймауту. Как найдёшь, где теряется время?
Сначала разделю этапы: DNS, соединение, TLS, ожидание первого байта, тело. Снаружи это curl -w с таймингами, изнутри Go-сервиса — httptrace или трейсы. Если долго до соединения — смотрю DNS, файрвол, доступность адреса. Если соединение есть, а первого байта нет — проблема в самом сервисе, и дальше смотрю его логи, трейс и запросы к базе. Если в логах сервиса запроса нет совсем, он застрял до обработчика, например на балансировщике
Где обычно заканчивается TLS и что из этого следует для сервиса?
Чаще всего на балансировщике или ingress: он расшифровывает трафик и передаёт запрос сервису по отдельному соединению. Сервис видит IP балансировщика, а адрес клиента берёт из X-Forwarded-For или похожего заголовка. Этому заголовку можно доверять только от своего прокси, клиент может прислать его сам. Внутри сети между сервисами иногда включают mTLS, чтобы трафик был зашифрован и там
Почему первые запросы после деплоя медленнее остальных?
У новых экземпляров пустые пулы соединений: каждый первый запрос к базе, кэшу и соседям платит за TCP и TLS. DNS-кэш тоже пустой. Сверху добавляются ленивые инициализации в самом коде. Поэтому трафик на новые экземпляры подают постепенно, а в readiness-пробе прогревают важные соединения
📚 Что почитать
- Introducing HTTP Tracing — короткий пост команды Go про
httptraceс примером - How browsers work — путь запроса со стороны браузера на MDN, от DNS до отрисовки
- High Performance Browser Networking: Building Blocks of TCP — почему рукопожатия и RTT определяют задержку, с расчётами
- DNS for Services and Pods — как устроен DNS в Kubernetes и откуда берётся
ndots:5