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

Java Road Map

🛣️ Как проходит запрос от URL до ответа

Между вызовом http.Get и первым байтом ответа запрос проходит пять-шесть этапов, и каждый может съесть сотни миллисекунд или повиснуть до таймаута. Бэкендеру эта цепочка нужна, когда сервис внезапно отвечает за две секунды вместо двадцати миллисекунд и надо понять, где именно теряется время. На собеседовании её спрашивают как «что происходит, когда вводишь адрес в браузере», и сильный ответ отличается от слабого тем, что кандидат считает задержки, а не перечисляет протоколы

🧠 Как это устроено

Возьмём запрос GET https://api.example.com/orders/42 с нового клиента, у которого ещё нет ни кэша, ни открытых соединений

  1. Разбор URL. Клиент достаёт схему (https значит порт 443 и TLS), хост и путь. Браузер вдобавок проверяет свой HTTP-кэш и список HSTS: если сайт там есть, http:// молча превращается в https:// без лишнего редиректа
  2. DNS. Имя api.example.com превращается в IP-адрес. Сначала смотрят локальные кэши (браузер, ОС, /etc/hosts), потом идут к рекурсивному резолверу провайдера или компании. Тот, если у него нет ответа, спрашивает корневые серверы, серверы зоны .com и авторитетный сервер example.com. Ответ кэшируется на время TTL из записи: поэтому после смены IP часть клиентов ещё минуты или часы ходит на старый адрес
  3. TCP-соединение. Трёхстороннее рукопожатие: клиент шлёт SYN, сервер отвечает SYN-ACK, клиент отправляет ACK. Это один полный RTT (round-trip time, время «туда и обратно»), и данные до его конца не идут
  4. TLS. Клиент и сервер договариваются о шифре, сервер показывает сертификат, клиент проверяет цепочку до доверенного корня и имя хоста. В TLS 1.3 полное рукопожатие занимает один RTT, в TLS 1.2 — два. Повторное соединение с тем же сервером в TLS 1.3 может отправить данные сразу (0-RTT), но атакующий может отправить такие данные повторно, поэтому серверы принимают их только для запросов, повтор которых ничего не ломает
  5. HTTP-запрос. Клиент отправляет строку запроса, заголовки и тело. Ещё один RTT плюс время, пока сервер считает ответ
  6. Балансировщик и прокси. Обычно запрос сначала попадает не в сервис, а на балансировщик или ingress: nginx, Envoy, облачный L7-балансировщик. Часто TLS заканчивается именно там, а дальше до сервиса идёт отдельное соединение, нередко обычный HTTP внутри сети. Балансировщик выбирает экземпляр сервиса и дописывает заголовки вроде X-Forwarded-For, потому что сервис теперь видит IP балансировщика, а не клиента
  7. Сервис. Роутер, middleware (логирование, авторизация, лимиты), обработчик, походы в базу, кэш и соседние сервисы. Каждый такой поход снова проходит часть этой цепочки, только внутри сети
  8. Ответ. Статус, заголовки, тело. Браузер дальше парсит HTML, находит CSS, JS и картинки и запускает те же шаги для каждого нового хоста

Сколько это стоит

Посчитаем, сколько RTT уходит до первого байта ответа при RTT 50 мс и пустых кэшах:

ЭтапRTTВремя при RTT 50 мс
DNS через резолвер~1~50 мс, если резолверу не пришлось идти дальше
TCP150 мс
TLS 1.3150 мс
HTTP-запрос и ответ150 мс плюс время работы сервера
Итого на новом соединении~4~200 мс
Итого на открытом соединении150 мс

По таблице видно, что новое соединение стоит в несколько раз дороже запроса по готовому. Поэтому 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 в Go MaxIdleConnsPerHost по умолчанию 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-пробе прогревают важные соединения

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