# Вопросы на собеседовании по HTTP и сетям

62 вопроса с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/http-networking

## Методы и коды ответа

### Клиент создаёт заказ. Чем `POST /orders` отличается от `PUT /orders/7f3a…` с идентификатором, который клиент сгенерировал сам, и что происходит при повторе каждого запроса?

Различие в том, кто выбирает адрес нового ресурса и что значит повтор. `POST /orders` отдаёт представление на обработку ресурсу-коллекции: адрес заказа назначает сервер и возвращает его в `Location` с кодом `201 Created`. Повтор того же запроса по умолчанию создаёт второй заказ. `PUT /orders/{id}` означает «состояние ресурса по этому адресу должно стать таким»: клиент сам знает адрес, а сервер либо создаёт ресурс и отвечает `201`, либо заменяет существующий и отвечает `200` или `204`. После повтора состояние то же, поэтому PUT идемпотентен и его можно повторять после обрыва.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-9.3.3

### API получает два запроса: с истёкшим токеном и с действующим токеном обычного пользователя на админский эндпоинт. Какой статус вернуть в каждом случае и чем `401` отличается от `403`?

Истёкший токен даёт `401 Unauthorized`, действующий токен без нужных прав даёт `403 Forbidden`. `401` говорит, что запрос не прошёл аутентификацию: учётных данных нет или они недействительны. Ответ обязан содержать `WWW-Authenticate` с описанием схемы (для токена `Bearer`), и клиент после обновления токена может повторить запрос. `403` говорит, что сервер запрос понял, но выполнять не будет: учётные данные приняты, прав не хватает. Повтор с теми же данными ничего не изменит, поэтому клиенту RFC советует его не делать.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-15.5.2

### За обратным прокси стоит приложение. Пользователи видят `502`, через час `504`, а во время деплоя `503`. Что каждый из этих кодов говорит о том, где искать причину?

`502` указывает на неисправный вышестоящий сервер, `504` на медленный, `503` на сервер, который сам отказывается принимать работу. `502 Bad Gateway`: прокси получил от вышестоящего сервера недопустимый ответ. Например, приложение упало, закрыло соединение без ответа или вернуло мусор вместо HTTP. Проверяют, жив ли процесс и что в его журнале. `504 Gateway Timeout`: прокси не дождался ответа вовремя. Приложение медленное или недоступно по сети: смотрят связность, время обработки, очередь запросов, зависшие обращения к базе и внешним сервисам, а также соотношение таймаута прокси и реального времени ответа. `503 Service Unavailable`: сервер сейчас не может обработать запрос из-за перегрузки или обслуживания и ожидает, что это пройдёт; он вправе указать срок в `Retry-After`. Так отвечают, например, на деплое, когда экземпляр сам сообщает, что не принимает запросы, или при срабатывании собственной защиты от перегрузки.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-15.6.3

## Идемпотентность и повторы

### Чем безопасный метод HTTP отличается от идемпотентного и в каком смысле `DELETE` идемпотентен, если второй такой же запрос возвращает `404`, а не `204`?

Безопасный метод только читает, идемпотентный даёт при повторе тот же эффект на сервере, а `DELETE` идемпотентен, потому что сравнивается эффект, а не ответ. Безопасный метод по своей семантике не просит изменить состояние сервера и не ждёт этого. Идемпотентный таков, что предполагаемый эффект нескольких одинаковых запросов совпадает с эффектом одного. Безопасные в RFC 9110: `GET`, `HEAD`, `OPTIONS`, `TRACE` (метод `QUERY` из RFC 10008 тоже безопасен и идемпотентен). Идемпотентны они же и ещё `PUT` и `DELETE`. `POST` и `PATCH` не относятся ни к тем, ни к другим.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1

### Клиент отправил `POST /bookings` на бронирование и получил таймаут чтения: ответа нет, бронь могла создаться. Можно ли автоматически повторить запрос и что нужно, чтобы повтор был безопасным?

Автоматически повторять нельзя, пока неизвестно, что операция идемпотентна или что первая попытка не применилась. Таймаут чтения означает «результат неизвестен», а не «не выполнено»: сервер мог принять запрос, создать бронь и не успеть ответить. `POST` не идемпотентен, повтор способен создать вторую бронь. RFC 9110 прямо советует клиенту не повторять неидемпотентные запросы автоматически без такой уверенности.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-9.2.2

### Клиент A отправил `PUT /profiles/5`, ответ потерялся, и он повторил запрос. Между попытками клиент B изменил тот же профиль, и правка B пропала. `PUT` идемпотентен: как это произошло и как не допустить потери?

`PUT` идемпотентен, но потерю правки B предотвращает условный запрос с `If-Match`, а не идемпотентность. Идемпотентность гарантирует лишь, что повтор не добавит эффекта сверх первого, и не защищает от изменений, которые другие клиенты сделали между попытками: повторный `PUT` от A снова заменил состояние данными A, и правка B стала потерянным обновлением.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-13.1.1

## HTTP-кэширование

### Чем `Cache-Control: no-cache` отличается от `no-store` и какую директиву выбрать для ответа с персональными данными, который не должен оседать даже на устройстве пользователя?

Для такого ответа нужен `no-store`: он запрещает кэшу сохранять любую часть запроса и ответа. `no-cache` разрешает хранить ответ, но запрещает отдавать его без успешной проверки на сервере: кэш посылает условный запрос, и если ответ не изменился, сервер отвечает `304`. Название `no-cache` сбивает с толку: оно не запрещает кэшировать.

Источник: https://www.rfc-editor.org/rfc/rfc9111#section-5.2.2.4

### У браузера сохранён ответ `/report.json` с `ETag: "v42"`, срок свежести истёк. Что браузер отправит, что ответит сервер, если отчёт не менялся, и что при этом экономится?

Браузер отправит условный `GET` с `If-None-Match: "v42"`. Если текущий `ETag` совпадает, сервер отвечает `304 Not Modified` без тела, а браузер обновляет метаданные сохранённой копии и отдаёт её пользователю. Экономится передача тела, но не обязательно работа сервера. Выигрыш на стороне сервера появляется, когда версию ресурса определяют дёшево (метка версии, время изменения), а не строят весь отчёт ради хеша. В `304` сервер повторяет заголовки, которые были бы в `200` и управляют кэшем: `Cache-Control`, `ETag`, `Vary`.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-13.1.1

### Браузер получил от CDN ответ с заголовками `Cache-Control: max-age=600` и `Age: 240`. Сколько секунд после получения он вправе использовать этот ответ без запроса к серверу?

Не больше 360 секунд. Оставшуюся свежесть считают как срок жизни минус текущий возраст: 600 − 240 = 360 в момент получения, и дальше запас убывает по часам браузера. `Age` оценивает время с момента, когда ответ создан или проверен на сервере-источнике, включая пребывание в вышестоящих кэшах и передачу. Поэтому `max-age` отсчитывается от создания ответа, а не от получения, и цепочка кэшей не продлевает жизнь копии. Одинаковый `max-age=600` у разных пользователей даёт разный остаток.

Источник: https://www.rfc-editor.org/rfc/rfc9111#section-4.2.1

## REST на практике

### Нужна операция «отменить заказ». Как выразить её в REST-стиле и допустим ли эндпоинт `POST /orders/7/cancel`?

Допустим как компромисс, но предпочтительнее описать отмену как изменение состояния (`PATCH /orders/7` с `{"status": "cancelled"}`) или как новый ресурс (`POST /orders/7/cancellations` с ответом `201` и адресом записи об отмене). В едином интерфейсе клиент работает с ресурсами через стандартные методы, и смысл метода известен промежуточным узлам: кэшам, прокси, библиотекам повторов. Отмена как ресурс получает адрес, по которому читают причину и время, и место, к которому можно привязать ключ идемпотентности.

Источник: https://roy.gbiv.com/pubs/dissertation/rest_arch_style.htm#sec_5_1_5

### Все запросы API идут как `POST /api` с телом `{"method": "getUser", "id": 5}`. Какие возможности HTTP команда при этом теряет?

Теряется всё, что промежуточные узлы выводят из метода, адреса и статуса, а не из тела. Кэширование: сохранённый ответ на `POST` может обслужить только последующие `GET` и `HEAD`, но не `POST`, так что чтение пользователя через `POST` кэшем не ускорить. Повторы: `POST` не идемпотентен, и клиентам автоматически повторять его не следует, даже если по смыслу это чтение. Наблюдаемость и защита: метрики, журналы, лимиты и правила на балансировщике или WAF видят один адрес и один метод, а операции не различают. Права на уровне пути тоже не разделить: адрес один для всех операций.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-9.3.3

### API на любую ошибку отвечает `200 OK` и телом `{"success": false, "error": "…"}`. Что от этого ломается, кроме удобства клиентов?

Ломается всё, что реагирует на статус, не читая тело. Мониторинг: доля `5xx` ноль, алерты молчат, пока пользователи видят сбои. Кэши: `200` на `GET` кэшируется по умолчанию, и ответ с ошибкой при наличии `max-age` или `Last-Modified` может быть сохранён и отдан другим как успешный. Прокси и балансировщики: проверка здоровья по коду ответа считает сломанный экземпляр рабочим. Клиентские библиотеки: механизмы повторов и размыкатели цепи не видят ошибку.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-15.1

## CORS

### Страница открыта на `https://app.example.com`. Какие из адресов относятся к тому же источнику (origin): `https://app.example.com/settings`, `https://app.example.com:8443/`, `http://app.example.com/`, `https://api.example.com/`?

Только первый, `https://app.example.com/settings`. Источник определяют три компонента: схема, хост и порт. Путь в сравнении не участвует. У остальных адресов отличается порт (`8443` вместо `443` по умолчанию), схема (`http`) и хост (`api`): поддомен считается другим источником.

Источник: https://www.rfc-editor.org/rfc/rfc6454#section-4

### Фронтенд с `app.example.com` отправляет `fetch` на `api.example.com`: `POST` с `Content-Type: application/json` и заголовком `Authorization`. В сети перед ним видна запись `OPTIONS`. Почему браузер её отправил и что должен ответить сервер?

Запрос не «простой», поэтому браузер сначала спрашивает разрешения предварительным запросом (preflight). Простыми считаются `GET`, `HEAD`, `POST` с набором безопасных заголовков и `Content-Type` из трёх значений: `application/x-www-form-urlencoded`, `multipart/form-data`, `text/plain`. Здесь `application/json` и `Authorization` выводят запрос из этого набора. Браузер шлёт `OPTIONS` с `Origin`, `Access-Control-Request-Method: POST` и `Access-Control-Request-Headers: authorization, content-type`.

Источник: https://fetch.spec.whatwg.org/#http-cors-protocol

### Запрос к API через `curl` и Postman проходит, а из браузера на чужом сайте блокируется с ошибкой CORS. Защищает ли CORS сервер от чужих запросов?

Нет. CORS настраивает политику браузера: он решает, покажет ли скрипту чужого источника ответ. Другим клиентам (`curl`, серверный код, Postman) политика недоступна, и они получают ответ всегда. Даже в браузере для «простого» запроса (например, `POST` формы) запрос уходит на сервер и выполняется, а CORS лишь скрывает ответ от скрипта. Поэтому CORS не заменяет аутентификацию, авторизацию и защиту от CSRF.

Источник: https://fetch.spec.whatwg.org/#http-cors-protocol

## Путь запроса: DNS, TCP, TLS, HTTP

### Клиент в Сиднее открывает `https://example.com`, сервер во Франкфурте, время кругового обхода (RTT) 280 мс. Ответ DNS уже в кэше, соединения нет, сервер отвечает мгновенно. Сколько пройдёт до первого байта ответа при TLS 1.3, при TLS 1.2 и на уже открытом соединении?

При TLS 1.3 около 840 мс, при TLS 1.2 около 1120 мс, на открытом соединении около 280 мс. Новое соединение платит по одному обходу за каждый этап: рукопожатие TCP (SYN, SYN-ACK; последний ACK уходит вместе со следующим сообщением), рукопожатие TLS 1.3 (один обход до того, как клиент сможет отправить запрос) и сам запрос с ответом. Итого 3 × 280 = 840 мс. Полное рукопожатие TLS 1.2 занимает два обхода, значит 4 × 280 = 1120 мс. Если соединение уже установлено, остаётся один обход на запрос и ответ.

Источник: https://www.rfc-editor.org/rfc/rfc9293#section-3.5

### Сервис переезжает на новый IP-адрес, у A-записи TTL 86400 секунд. Почему нельзя просто сменить адрес в панели DNS и как провести переезд без потери трафика?

Резолверы и клиенты хранят ответ на время TTL, поэтому после смены записи часть пользователей до суток обращается к старому адресу. Переезд готовят заранее: сначала снижают TTL, до нескольких минут, и ждут не меньше прежнего TTL, чтобы кэши с длинным сроком истекли. Затем меняют адрес. Старый сервер продолжает работать (отвечает сам или проксирует на новый), пока трафик не уйдёт. После переезда TTL возвращают, чтобы не нагружать DNS лишними запросами.

Источник: https://www.rfc-editor.org/rfc/rfc1035#section-3.2.1

### Корневой домен `example.com` нужно направить на CDN, которая выдала имя `example.cdn-provider.net`. DNS-провайдер не принимает CNAME для `example.com`. Почему и что делать?

CNAME объявляет имя псевдонимом другого имени, и других записей у такого имени быть не должно. На корне зоны (apex) всегда есть SOA и NS, часто MX и TXT, поэтому CNAME там несовместим с остальными записями (RFC 1034, RFC 2181 §10.1). Выходов три: записи ALIAS или ANAME (иначе CNAME flattening) у DNS-провайдера, который сам разворачивает имя и отдаёт клиентам обычные A и AAAA; адреса CDN, прописанные напрямую, если провайдер гарантирует их постоянство; адрес `www.example.com` как CNAME и редирект с корня на него.

Источник: https://www.rfc-editor.org/rfc/rfc1034#section-3.6.2

## TCP и UDP

### Чем TCP отличается от UDP по гарантиям и какой протокол выбрать для передачи файла, видеозвонка и одиночного DNS-запроса?

TCP даёт надёжный упорядоченный поток байт: соединение, подтверждения, повторная передача потерянного, управление потоком и перегрузкой. UDP отправляет отдельные датаграммы без соединения, без гарантии доставки и порядка, без повторов, зато с сохранением границ сообщений и минимальной задержкой.

Источник: https://www.rfc-editor.org/rfc/rfc9293#section-2.2

### В TCP-соединении потерян сегмент 5, сегменты 6–8 дошли до получателя. Почему приложение не получает данные из сегментов 6–8, пока не придёт повторная передача пятого?

TCP отдаёт приложению байты строго по порядку, поэтому полученные позже сегменты ждут в буфере приёма, пока не закроется пропуск. Получатель на каждый такой сегмент повторяет подтверждение последнего байта в порядке (дублирующий ACK). Отправитель после трёх дубликатов повторяет сегмент 5, не дожидаясь таймаута (быстрая повторная передача), и приложение получает 5–8 примерно через RTT после потери. Если дубликатов не хватило, ждёт срабатывания таймера повтора (RTO), и пауза заметно дольше. Это блокировка начала очереди (head-of-line blocking): цена порядка и надёжности.

Источник: https://www.rfc-editor.org/rfc/rfc5681#section-3.2

### Отправитель делает три вызова `send` по 100 байт. Сколько вызовов `recv` потребуется получателю и что он прочитает в случае UDP и в случае TCP?

В UDP три `recv` по 100 байт, если пакеты дошли, а в TCP число и размеры чтений не определены. UDP сохраняет границы сообщений (порядок и доставка не гарантированы), TCP границ не имеет: это поток байт. Те же 300 байт получатель может прочитать одним `recv`, тремя или как 150 + 150, всё зависит от сегментации и момента чтения. Поэтому поверх TCP приложению нужно самому размечать сообщения: префикс длины, разделитель, фиксированный размер.

Источник: https://www.rfc-editor.org/rfc/rfc9293#section-2.2

## TLS

### Что гарантирует TLS соединению и что он не скрывает и не гарантирует?

TLS даёт три свойства: конфиденциальность (содержимое шифруется), целостность (подмена или вставка данных обнаруживается) и аутентификацию сервера по сертификату. Аутентификация клиента необязательна и включается отдельно (взаимный TLS, mTLS).

Источник: https://www.rfc-editor.org/rfc/rfc8446#section-1

### Клиент подключается к `api.example.com`, а сервер присылает сертификат, выданный доверенным центром сертификации, но на имя `www.other.com`. Принимать ли соединение и что именно проверяет клиент?

Нет, соединение отклоняется: доверие к издателю не доказывает, что сертификат выдан этому имени. Клиент проверяет цепочку подписей до доверенного корня, срок действия каждого сертификата и допустимое назначение ключа. Затем сверяет запрошенное имя с именами в расширении `subjectAltName`; поле `CN` для этого не используется. Учитывается и отзыв сертификата (CRL, OCSP), хотя строгость проверки зависит от клиента. Наконец, сервер подписью в сообщении `CertificateVerify` доказывает, что владеет закрытым ключом из сертификата, иначе чужой сертификат можно было бы просто воспроизвести.

Источник: https://www.rfc-editor.org/rfc/rfc9525#section-1

### Сайт открывается в браузере без предупреждений, но `curl` и серверный клиент на Python отвечают «unable to get local issuer certificate». Что не так с настройкой сервера?

Сервер не отправляет промежуточные сертификаты. Клиенту нужна цепочка от сертификата сайта до доверенного корня, и в TLS её присылает сам сервер: сертификат сайта, затем сертификаты издателей по порядку, причём корневой можно не включать. Если промежуточного нет, клиент не может связать сертификат сайта со своим хранилищем корней. Браузеры часто справляются: расширение Authority Information Access в сертификате указывает, где взять сертификат издателя, и клиент вправе докачать недостающий. Но клиенты не обязаны этого делать, и те, что не докачивают (в условии это `curl` и Python), отклоняют такую цепочку.

Источник: https://www.rfc-editor.org/rfc/rfc8446#section-4.4.2

## Соединения и таймауты

### HTTP-клиент настроен на «таймаут 5 секунд», но запрос к медленному серверу висит почти минуту. Какие бывают таймауты по этапам запроса и почему параметр «timeout» может не ограничивать всё время?

Параметр «timeout» в ряде клиентов (например, в Python `requests`) ограничивает одну операцию сокета, а не весь вызов, поэтому медленный сервер удерживает клиента дольше заданного значения. В Python `requests` значение ограничивает установку соединения и ожидание очередных данных, но не всю загрузку ответа: сервер, присылающий по байту каждые 4 секунды, удерживает клиента неограниченно долго. В Go `http.Client.Timeout`, наоборот, охватывает весь вызов вместе со временем соединения, редиректами и чтением тела.

Источник: https://requests.readthedocs.io/en/latest/user/quickstart/#timeouts

### Приложение на Node.js стоит за балансировщиком с таймаутом простоя 60 секунд. Время от времени пользователи получают `502`, хотя приложение живо, а нагрузка невелика. В журнале приложения этих запросов нет. Что происходит?

Приложение закрывает простаивающее keep-alive-соединение раньше балансировщика. В Node.js значение `keepAliveTimeout` по умолчанию традиционно 5 секунд, а увеличение до 65 секунд принято в основную ветку отдельным изменением (PR #62782, semver-major), поэтому для своей версии значение сверяют с документацией и задают явно. Пока оно меньше таймаута балансировщика (здесь 60), сценарий воспроизводится. Балансировщик не знает о закрытии и отправляет новый запрос по этому соединению как раз в момент, когда приложение его закрывает. Запрос не доходит, соединение сбрасывается, и балансировщик отвечает `502`. В журнале приложения запроса нет, потому что оно его так и не получило. Стандарт описывает эту гонку прямо: клиент мог начать отправку нового запроса одновременно с решением сервера закрыть соединение.

Источник: https://www.rfc-editor.org/rfc/rfc9112#section-9.5

### Сервис вызывает API партнёра через пул на 20 соединений, нагрузка 100 запросов в секунду. Пока партнёр отвечал за 100 мс, всё работало. Когда он замедлился до 1 секунды, сервис перестал отвечать, хотя таймаут чтения 5 секунд, а процессор простаивает. Что произошло?

Пул на 20 соединений исчерпан, и остальные запросы стоят в его очереди. Нужное число одновременных соединений равно нагрузке, умноженной на время ответа (закон Литтла): при 100 мс это 100 × 0,1 = 10, пула в 20 хватало, при 1 секунде это 100, а пул даёт 20. Ожидание в очереди не входит в таймаут чтения, потому что чтение отсчитывается уже после получения соединения и отправки запроса. Очередь растёт вместе с числом ожидающих потоков или горутин, ресурсы сервиса заканчиваются, и он перестаёт отвечать даже на запросы, не связанные с партнёром, при простаивающем процессоре.

Источник: https://doi.org/10.1287/opre.9.3.383

## HTTP/1.1, HTTP/2 и HTTP/3

### Страница загружает 80 ресурсов с одного хоста. Как это выглядит по HTTP/1.1 и по HTTP/2 и что именно меняется между версиями, если методы и коды остаются теми же?

Меняется способ передачи, а не смысл запросов. В HTTP/1.1 на одном соединении запрос и ответ идут последовательно, и пока ответ не пришёл целиком, следующий ответ по тому же соединению не передаётся. Чтобы загружать ресурсы параллельно, браузеры открывают несколько соединений на хост (на практике около шести, как описывает MDN), и каждое платит за TCP и TLS. HTTP/2 передаёт сообщения бинарными кадрами и мультиплексирует много запросов и ответов как независимые потоки (streams) в одном соединении, поэтому 80 ресурсов идут параллельно без очереди на уровне HTTP. Заголовки сжимаются (HPACK), что заметно для повторяющихся заголовков вроде `Cookie`.

Источник: https://www.rfc-editor.org/rfc/rfc9113#section-2

### После перехода на HTTP/2 на плохой мобильной сети с потерями пакетов страница иногда грузится медленнее, чем по HTTP/1.1. Почему так происходит и что меняет HTTP/3?

В HTTP/2 все потоки идут в одном TCP-соединении, а TCP отдаёт данные строго по порядку. Потерян один сегмент: приложение не получает ничего из последующих данных, пока не придёт повтор, даже если они относятся к другим потокам и дошли целыми. Задерживаются все параллельные ответы. В HTTP/1.1 соединений несколько, и потеря в одном из них не задерживает остальные.

Источник: https://www.rfc-editor.org/rfc/rfc9113#section-1

### На балансировщике включили HTTP/2 для клиентов, а приложение за ним осталось на HTTP/1.1. После этого код, который читает заголовок запроса из сырого словаря по ключу `Content-Type` с учётом регистра, перестал его находить. Почему и что исправить?

Код сравнивает имена заголовков с учётом регистра, а имена полей в HTTP регистронезависимы. В HTTP/2 имена полей передаются строчными буквами (`content-type`), а в HTTP/1.1 клиенты привычно присылали `Content-Type`. Прокси при преобразовании может передать бэкенду имена в том виде, в каком получил, и тогда приложение видит строчные. Исправление: читать заголовки через API фреймворка, которое сравнивает имена без учёта регистра, а не по ключу в сыром словаре.

Источник: https://www.rfc-editor.org/rfc/rfc9110#section-5.1
