# Вопросы на собеседовании по System Design

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

Страница: https://jobjump.app/questions/system-design

## Требования и оценка нагрузки

### Чем функциональные требования отличаются от нефункциональных и почему архитектуру определяют вторые?

**Функциональное требование** говорит, что система делает: создать короткую ссылку, перенаправить по ней, показать статистику переходов. **Нефункциональное** задаёт, насколько хорошо она это делает: задержка на заданном процентиле, поток запросов, доступность, допустимая потеря данных, согласованность, стоимость, безопасность. Рабочим нефункциональное требование становится, когда у него есть число и окно измерения.

Источник: https://docs.aws.amazon.com/wellarchitected/latest/framework/the-pillars-of-the-framework.html

### Какие параметры системы нужно выяснить, прежде чем предлагать архитектуру?

Нужно выяснить критические сценарии, масштаб, соотношение чтения и записи, данные, задержку, доступность и восстановление, согласованность, географию и ограничения, потому что каждое из них отбрасывает часть вариантов:

Источник: https://learn.microsoft.com/en-us/azure/well-architected/reliability/metrics

### Как из числа активных пользователей получить средний и пиковый поток запросов в секунду?

Средний поток = активные пользователи в сутки × запросов на пользователя ÷ секунд в сутках. В сутках 86 400 секунд (в уме для прикидки берут около 10⁵, ниже считаем по точному значению).

Источник: https://sre.google/sre-book/introduction/

## Масштабирование и доступность

### Чем вертикальное масштабирование отличается от горизонтального и когда первое разумнее?

**Вертикальное** масштабирование увеличивает мощность одного узла: больше ядер, памяти, быстрее диски. **Горизонтальное** добавляет узлы и делит нагрузку между ними.

Источник: https://learn.microsoft.com/en-us/azure/architecture/best-practices/auto-scaling

### Почему stateless-сервис масштабируется горизонтально проще всего и куда при этом уходит состояние?

Экземпляр сервиса без состояния не хранит между запросами ничего, что понадобится следующему запросу. Поэтому любой экземпляр обслужит любой запрос. Балансировщик может отправить запрос куда угодно, без привязки клиента к экземпляру. Экземпляры можно добавлять и убирать в любой момент, и новый сразу получает свою долю трафика. Отказ экземпляра теряет только запросы, которые он обрабатывал в этот момент.

Источник: https://12factor.net/processes

### В чём трудность горизонтального масштабирования stateful-сервиса?

У сервиса с состоянием экземпляры не взаимозаменяемы: запрос нужно отправить туда, где лежат его данные. Добавить узел недостаточно, данные надо либо **разделить**, либо **скопировать**, и у каждого пути своя цена.

Источник: https://learn.microsoft.com/en-us/azure/well-architected/design-guides/partition-data

### Что такое привязка сессии к экземпляру (sticky sessions) и чем она мешает масштабированию и отказоустойчивости?

**Привязка сессии** (session affinity) — режим балансировщика, при котором запросы одного клиента всегда попадают на один и тот же экземпляр. Клиента узнают по cookie, выданному балансировщиком, или по хешу адреса. Нужна она, когда сессия хранится в памяти экземпляра.

Источник: https://learn.microsoft.com/en-us/azure/architecture/guide/design-principles/scale-out

### Как найти узкое место системы под нагрузкой и почему масштабировать нужно именно его?

Нагрузочным тестом с ростом нагрузки находят точку, где пропускная способность перестаёт расти, и проходят по всем ресурсам методом USE (загрузка, насыщение, ошибки); масштабировать нужно ресурс, который насыщается первым.

Источник: https://www.brendangregg.com/usemethod.html

## CAP и модели согласованности

### Что утверждает теорема CAP и в какой именно момент системе приходится выбирать?

Теорема (гипотеза Брюера, доказанная Гилбертом и Линчем в 2002 году; здесь — в их изложении 2012 года) утверждает: в сети, где сообщения между узлами могут теряться, невозможно реализовать атомарный (линеаризуемый) регистр чтения-записи, который отвечает на каждый запрос, пришедший на работающий узел.

Источник: https://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf

### Почему распределённую систему нельзя честно отнести к классу CA?

Потому что разрыв сети нельзя исключить, а при разрыве выбор сводится к C или A. P в CAP — свойство среды, в которой работает система: сообщения между узлами теряются и задерживаются. Разработчик не выбирает, будут ли разрывы, он выбирает только поведение системы, когда разрыв случился. Если выбрать «CA», а разрыв всё же случится, выбор, по словам Брюера, придётся свести к C или A. Значит, система отдаст несогласованные данные или перестанет отвечать, то есть всё равно окажется на одной из двух сторон, только без заранее выбранного плана.

Источник: https://www.infoq.com/articles/cap-twelve-years-later-how-the-rules-have-changed/

### Как ведут себя CP- и AP-системы при разрыве сети? Приведите примеры хранилищ.

CP-система при разрыве отказывает той части, что не может подтвердить свежесть данных, а AP-система принимает запросы на обеих сторонах и сводит расхождения позже.

Источник: https://docs.cockroachlabs.com/docs/stable/frequently-asked-questions

## Репликация

### Какие задачи решает репликация данных, кроме отказоустойчивости?

Репликация даёт масштабирование чтения, изоляцию нагрузки, близость к пользователю и миграции без остановки системы, а не только сохранность данных при отказе узла:

Источник: https://vitess.io/docs/reference/features/sharding/

### Как работает репликация с одним ведущим узлом (leader-follower)?

Все записи принимает один узел — ведущий. Он применяет изменение у себя, пишет его в журнал (в PostgreSQL — WAL) и передаёт поток записей журнала ведомым узлам. Ведомые применяют записи в том же порядке и поэтому проходят ту же последовательность состояний, только с задержкой. Порядок задаёт один узел, так что конфликтов записи между копиями не бывает.

Источник: https://www.postgresql.org/docs/current/warm-standby.html

### Чем синхронная репликация отличается от асинхронной и что такое полусинхронная?

Разница в том, когда клиент получает подтверждение `COMMIT`.

Источник: https://www.postgresql.org/docs/current/runtime-config-wal.html

## Шардирование и партиционирование

### Чем шардирование отличается от партиционирования?

Оба приёма делят данные по ключу. Разница в том, где оказываются части.

Источник: https://www.postgresql.org/docs/current/ddl-partitioning.html

### Когда шардирование действительно нужно и что стоит попробовать до него?

Шардирование оправдано, когда одному узлу не хватает ресурсов на запись или объём данных, а более дешёвые приёмы исчерпаны. MongoDB описывает эту границу прямо: у вертикального масштабирования есть практический предел, заданный доступным железом, а горизонтальное покупается сложностью инфраструктуры и сопровождения. Vitess указывает разделение шардов как действие для роста пропускной способности записи.

Источник: https://www.mongodb.com/docs/manual/sharding/

### Какие бывают стратегии распределения данных по шардам и чем они расплачиваются?

**По диапазону ключа.** Соседние значения лежат в одном шарде, поэтому диапазонный запрос идёт в один или несколько шардов. Цена — неравномерность: монотонно растущий ключ (время, автоинкремент) направляет все новые записи в последний диапазон, и этот шард становится узким местом.

Источник: https://www.mongodb.com/docs/manual/sharding/

### Как выбрать ключ шардирования?

Ключ проверяют по четырём свойствам.

Источник: https://www.mongodb.com/docs/manual/core/sharding-choose-a-shard-key/

## Выбор хранилища

### По каким критериям выбирают между реляционной базой и NoSQL-хранилищем для конкретной задачи?

Выбор начинается не с ярлыка «SQL или NoSQL», а со списка запросов и требований к целостности данных.

Источник: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SQLtoNoSQL.WhyDynamoDB.html

### Правда ли, что NoSQL-хранилища быстрее на запись, и откуда на самом деле берётся разница?

Ярлык «NoSQL» скорость записи не объясняет. Разница складывается из трёх источников, и ни один из них не принадлежит модели данных.

Источник: https://github.com/facebook/mysql-5.6/wiki

### Чем колоночное хранилище отличается от строкового и почему оно быстрее на аналитике?

Колоночное хранилище на аналитике читает только упомянутые в запросе колонки, а строковое читает строки целиком. В строковом хранилище все поля одной строки лежат рядом на одной странице. Прочитать или изменить запись целиком дёшево: она в одном месте. Но аналитический запрос, которому нужны три колонки из ста, всё равно читает с диска строки целиком, то есть все сто.

Источник: https://clickhouse.com/docs/resources/support-center/knowledge-base/general-faqs/columnar-database

### Чем OLTP-нагрузка отличается от OLAP и почему их разносят по разным системам?

**OLTP** — поток коротких транзакций, каждая читает и меняет несколько строк по ключу: оформить заказ, списать остаток, обновить профиль. Важны миллисекундная задержка, высокая конкурентность и актуальное текущее состояние.

Источник: https://clickhouse.com/docs/resources/support-center/knowledge-base/general-faqs/olap

### Чем движок хранения на B-дереве отличается от движка на LSM-дереве и кому из них легче даётся запись?

Запись легче даётся LSM-дереву: оно откладывает упорядочивание и пишет последовательно, а B-дерево переписывает страницу на месте. **B-дерево** держит данные упорядоченными всегда. Запись находит нужную листовую страницу и переписывает её на месте, иногда с расщеплением. Чтобы изменить несколько байт, на диск уходит страница целиком, а соседние ключи лежат на разных участках носителя. Чтение предсказуемо: один путь от корня к листу.

Источник: https://www.cs.umb.edu/~poneil/lsmtree.pdf

### Для каких данных подходит хранилище широких колонок вроде Cassandra и чего в нём не стоит ожидать?

Хранилище широких колонок подходит для больших объёмов с интенсивной записью и заранее известными запросами, но в нём нет соединений, произвольных запросов и полноценных транзакций. Таблица в Cassandra задаётся ключом разбиения и ключами кластеризации. Хеш ключа разбиения определяет узлы, на которых лежит раздел. Ключи кластеризации задают порядок строк внутри раздела и позволяют выбирать диапазон. Эффективный запрос — «равенство по ключу разбиения плюс диапазон внутри раздела», он попадает в один раздел, и ёмкость растёт добавлением узлов.

Источник: https://cassandra.apache.org/doc/latest/cassandra/developing/data-modeling/intro.html

### Почему файлы и изображения хранят в объектном хранилище, а не в базе данных или на диске сервера?

Объектное хранилище выносит байты из базы и с диска сервера и берёт надёжность на себя: S3 Standard спроектирован на долговечность 99,999999999% и доступность 99,99% объектов. S3 хранит объекты по уникальным ключам и отдаёт их по HTTP.

Источник: https://docs.aws.amazon.com/AmazonS3/latest/userguide/DataDurability.html

### Как организовать загрузку больших файлов в объектное хранилище так, чтобы байты не шли через бэкенд?

Бэкенд выдаёт разрешение, а байты клиент отправляет прямо в хранилище по **подписанной ссылке** (presigned URL).

Источник: https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html

## Трафик: DNS, балансировка, CDN

### Что происходит между вводом адреса сайта в браузере и получением ответа от сервера?

1. Разрешение имени. Клиент спрашивает рекурсивный резолвер. Тот при промахе проходит цепочку делегирования: корневые серверы, серверы зоны верхнего уровня, авторитетный сервер домена. Ответ кэшируется на время жизни записи (TTL). Уже здесь может приниматься решение о маршруте: авторитетный сервер вернёт адрес ближайшей точки CDN или балансировщика региона. 2. Установление соединения. Трёхстороннее рукопожатие TCP — один обход до сервера. 3. TLS. В TLS 1.3 полное рукопожатие занимает ещё один обход; клиент проверяет сертификат сервера по цепочке доверия. 4. HTTP-запрос. Его принимает первый посредник: узел CDN, обратный прокси или балансировщик. Он может ответить из кэша или передать запрос серверу приложения. Приложение обращается к кэшу, базе, соседним сервисам и формирует ответ. 5. Ответ и отрисовка. Браузер разбирает HTML и запрашивает связанные ресурсы.

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

### Чем балансировка на уровне L4 отличается от балансировки на уровне L7?

**L4 (транспортный уровень)** видит адреса, порты и протокол, но не содержимое. Решение принимается один раз на соединение: экземпляр выбирают, например, по хешу адресов и портов, и всё соединение живёт на нём.

Источник: https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/how-elastic-load-balancing-works.html

### Можно ли распределять нагрузку через DNS и какие у этого ограничения?

Можно. Имя возвращает несколько адресов, и сервер меняет их порядок от ответа к ответу (round-robin DNS). Управляемые DNS-службы умеют больше: доли трафика по весам, выбор по местоположению или по задержке до региона, исключение адресов, не прошедших проверку здоровья.

Источник: https://www.rfc-editor.org/rfc/rfc1794.html

## Ограничение частоты запросов

### Зачем ограничивать частоту запросов и где в системе ставят ограничитель?

Ограничитель нужен, чтобы исчерпание ёмкости было предсказуемым и справедливым, а ставят его слоями. Он не добавляет ёмкости. Без него один потребитель (цикл без паузы у партнёра, парсер, перебор паролей) способен занять пул соединений и поднять задержку всем остальным. С ним часть запросов получает явный отказ, а остальные обслуживаются в пределах цели. Отсюда задачи: справедливость между клиентами, защита от злоупотреблений, контроль стоимости дорогих операций, защита зависимостей ниже по цепочке.

Источник: https://stripe.com/blog/rate-limiters

### Как работает алгоритм token bucket и чем он отличается от leaky bucket?

**Token bucket (корзина токенов).** У корзины вместимость `B` и скорость пополнения `r` токенов в секунду. Запрос забирает токен (или несколько, если запрос дорогой); нет токенов — отказ. Хранить достаточно двух чисел: остаток и время последнего пополнения. Пополнение считают лениво при каждом запросе: `tokens = min(B, tokens + r × Δt)`. Средний темп ограничен `r`, а клиент, который молчал, может сразу отправить пачку до `B` запросов. По такой схеме работают Amazon API Gateway (лимиты скорости и всплеска) и ограничитель Stripe.

Источник: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html

### Почему фиксированное окно пропускает двойной всплеск на границе интервала и как это исправляют скользящие окна?

**Фиксированное окно** держит счётчик на ключ и календарный интервал (`user:42:12:05`), увеличивает его при каждом запросе и сбрасывает с началом нового интервала. В Redis это `INCR` плюс `EXPIRE`. Окна независимы, поэтому при лимите N в минуту клиент отправляет N запросов в последнюю секунду одной минуты и ещё N в первую секунду следующей. За две секунды проходит 2N, и формально ни одно окно не нарушено.

Источник: https://blog.cloudflare.com/counting-things-a-lot-of-different-things/

## Доставка событий клиенту

### Чем короткий опрос отличается от длинного и когда достаточно короткого?

При **коротком опросе** клиент через фиксированный интервал отправляет обычный запрос, а сервер сразу отвечает: есть новое или нет. Задержка доставки доходит до длины интервала, а нагрузка определяется числом клиентов и интервалом, а не числом событий: при редких событиях почти все ответы пустые. RFC 6202 формулирует это так: частота опроса зависит от задержки, которую клиент готов терпеть.

Источник: https://www.rfc-editor.org/rfc/rfc6202.html

### Как выбрать между длинным опросом, Server-Sent Events и WebSocket для конкретной задачи?

Выбор делают по четырём вопросам, а не по моде.

Источник: https://html.spec.whatwg.org/multipage/server-sent-events.html

### Что меняется в архитектуре, когда сервису нужно держать миллион постоянных WebSocket-соединений?

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

Источник: https://www.rfc-editor.org/rfc/rfc6455.html

## Отказы: таймауты, повторы, идемпотентность

### Зачем нужен таймаут на каждом сетевом вызове и как выбрать его значение?

Вызов без таймаута — обещание ждать вечно. Пока удалённая сторона не ответила, вызов держит поток, соединение или место в пуле. Если она не ответит никогда, ресурс потерян, а достаточное число таких вызовов исчерпывает пул: сервис перестаёт обслуживать всё, включая операции, не связанные с зависшей зависимостью. Таймаут превращает неопределённое зависание в явную ошибку, с которой можно что-то сделать. Значение по умолчанию на это полагаться не позволяет: в gRPC, например, дедлайна по умолчанию нет, и клиент может ждать сколь угодно долго.

Источник: https://builder.aws.com/content/3EumjoZascWd1oZiEgL8ORlv3qE/timeouts-retries-and-backoff-with-jitter

### Чем опасно простое увеличение таймаута, когда зависимость начала отвечать медленно?

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

Источник: https://sre.google/sre-book/addressing-cascading-failures/

### Почему ограничение времени лучше передавать по цепочке вызовов как общий дедлайн?

Независимые таймауты на каждом звене между собой не согласованы. Клиент ждёт 2 секунды, а внутренние вызовы настроены на 3 секунды каждый, да ещё с повторами. Клиент давно получил ошибку, а цепочка продолжает работать, занимая ресурсы ради результата, который никто не заберёт. Под нагрузкой такая работа вытесняет полезную.

Источник: https://sre.google/sre-book/addressing-cascading-failures/

### Какие ошибки имеет смысл повторять, а какие нет?

Повтор имеет смысл при двух условиях: ошибка связана с временным состоянием системы, а не с содержанием запроса, и повторное выполнение безопасно.

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

## Консенсус, лидеры и блокировки

### Что такое split-brain и почему кластер из двух узлов особенно к нему уязвим?

**Split-brain** — состояние, в котором система разделилась на две группы и в каждой свой ведущий: обе принимают записи, обе уверены, что вторая половина упала, и истории расходятся. Собирается оно из штатных механизмов: разрыв сети, детектор отказов принимает недоступных за мёртвых, роль ведущего передаётся по истечении аренды.

Источник: https://etcd.io/docs/v3.5/faq/

### Почему кластеры координации собирают из нечётного числа узлов?

Потому что добавление узла к нечётному составу поднимает кворум, но не устойчивость к отказам. Кластер на консенсусе работает, пока доступно **большинство**: кворум равен `⌊n/2⌋ + 1`. Отказоустойчивость — сколько узлов можно потерять с сохранением кворума — равна `n − кворум`.

Источник: https://etcd.io/docs/v3.5/faq/

### Зачем распределённой системе выбирать ведущий узел и как это делают?

**Зачем.** Один ведущий делает систему проще: порядок операций и решения о владении принимает один узел, конфликтов нет, рассуждать и отлаживать легче. Это и эффективнее: ведущий объявляет решения, а не согласует каждое заново. Цена: ведущий — единая точка отказа и потолок масштаба. Потолок снимают шардированием: по ведущему на раздел данных.

Источник: https://builder.aws.com/content/3Ev0vH0hfkcUizISUWYTvHibtcp/leader-election-in-distributed-systems

### Как Raft обеспечивает согласие узлов о журнале операций?

Raft раскладывает задачу на выбор ведущего, тиражирование журнала и ограничения безопасности.

Источник: https://raft.github.io/raft.pdf

## Данные в масштабе

### Как генерировать уникальные идентификаторы в распределённой системе и чем отличаются UUID, Snowflake и выдача диапазонов?

Автоинкремент одной базы перестаёт работать, когда записи создаются на многих узлах. Схемы различаются тем, нужна ли координация, сколько занимает идентификатор и упорядочен ли он по времени.

Источник: https://www.rfc-editor.org/rfc/rfc9562.html

### Как сервис коротких ссылок генерирует короткий код и гарантирует его уникальность?

Код записывают в алфавите base62 (`0-9a-zA-Z`). Пространство кодов длины 7 — 62⁷ = 3 521 614 606 208, около 3,5 триллиона; длины 6 — 62⁶ = 56 800 235 584.

Источник: https://www.postgresql.org/docs/current/sql-insert.html

### Как считать просмотры при большой нагрузке, не обновляя строку в базе на каждый просмотр?

`UPDATE videos SET views = views + 1` на каждый просмотр упирается в одну строку: все транзакции выстраиваются в очередь за её блокировкой. В PostgreSQL каждый `UPDATE` к тому же создаёт новую версию строки, старую потом убирает VACUUM, и популярное видео порождает поток мёртвых версий и записей в журнал.

Источник: https://redis.io/docs/latest/commands/incr/

## Задержка, пропускная способность и полоса

### Нагрузочный тест из 1000 запросов: 960 ответили за 15 мс, 40 запросов за 400 мс. Цель по задержке: 99% запросов быстрее 250 мс. Выполняется ли цель, и какая доля запросов пользователя заденет медленный ответ, если каждый запрос пользователя параллельно и независимо обращается к десяти таким сервисам и ждёт все ответы?

Цель не выполняется: p99 равен 400 мс, потому что медленных запросов 4%, больше допустимого 1%. Среднее при этом около 30 мс и выглядит благополучно, поэтому цели по задержке ставят по высокому процентилю, а не по среднему.

Источник: https://research.google/pubs/the-tail-at-scale/

### Большой файл передаётся по одному TCP-соединению между двумя регионами. Канал 1 Гбит/с, время оборота 100 мс, потерь пакетов нет, процессор и диски простаивают, а скорость держится около 5 Мбит/с. Что ограничивает скорость и как это исправить?

Скорость ограничена окном приёма. Отправитель вправе иметь в пути не больше окна неподтверждённых данных, поэтому за один оборот передаётся не больше окна. Без масштабирования поле окна в заголовке TCP ограничено 64 КиБ, и это даёт 65 536 × 8 / 0,1 ≈ 5,2 Мбит/с, как в условии. Современные стеки включают масштабирование по умолчанию, так что такая скорость говорит о том, что опция не согласовалась (её отключили или срезало промежуточное устройство) либо буфер приёма слишком мал.

Источник: https://www.rfc-editor.org/rfc/rfc7323.html

## Адресация, потоки байтов и целостность данных

### Сервис с адресом 10.0.1.17 и маской /24 обращается к 10.0.1.42 и к базе 10.0.2.9. Как отправитель решает, передать пакет напрямую или шлюзу, и что произойдёт с пакетом к 10.0.2.9, если на нём по ошибке настроена маска /16?

Отправитель применяет свою маску к своему адресу и к адресу получателя. Если номера сети совпали, получатель в подключённой сети и пакет уходит напрямую; если не совпали, пакет отдаётся шлюзу (RFC 1122).

Источник: https://www.rfc-editor.org/rfc/rfc1122.html

### В таблице маршрутов маршрутизатора три записи: `172.16.0.0/20` напрямую через eth0, `172.16.8.0/22` через следующий маршрутизатор 172.16.0.77 и `default` через шлюз 172.16.0.1. Куда уйдёт пакет для 172.16.9.20 и по какому правилу?

Пакет уйдёт через 172.16.0.77, потому что из подходящих маршрутов выбирается самый длинный префикс (RFC 1812).

Источник: https://www.rfc-editor.org/rfc/rfc1812.html

### Продуктовая сеть VPC в AWS занимает `10.0.0.0/16`, тестовая в другом аккаунте занимает `10.0.128.0/17`. Нужно соединить их пирингом, чтобы ресурсы обращались друг к другу напрямую по своим частным адресам. Получится ли и что делать?

Не получится: диапазоны пересекаются. `10.0.0.0/16` покрывает адреса от `10.0.0.0` до `10.0.255.255`, а `10.0.128.0/17` от `10.0.128.0` до `10.0.255.255`, то есть вторая сеть целиком лежит внутри первой.

Источник: https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-basics.html

## Проектирование API: GraphQL и бинарные контракты

### GraphQL-запрос `orders(first: 20) { items(first: 5) { product { name } } }` выполняет наивный сервер, у которого резолвер каждого поля ходит в базу сам. В каждом из 20 заказов ровно пять позиций, у каждой позиции один товар. Сколько обращений к базе получится и как сделать, чтобы их число не росло с размером списков?

Получится 1 + 20 + 100 = 121 обращение, а с пакетированием их станет 3, по одному на уровень запроса.

Источник: https://graphql.org/learn/performance/

### Публичный GraphQL API ограничивает глубину запроса значением 5. Клиент присылает запрос `users(first: 100) { posts(first: 100) { comments(first: 100) { text } } }`. Глубина всего три, пакетирование есть. Какой предел должен отвергнуть этот запрос и как он считается?

Его отвергает предел на общее число узлов (сложность запроса), который считается по аргументам `first` и `last` до выполнения запроса.

Источник: https://graphql.org/learn/security/

### В proto-схеме поле `string name = 2;` переименовали в `string full_name = 2;`, номер оставили. Сломается ли старый клиент, который обращается к сервису по gRPC, и что ещё в системе зависит от имени поля?

Старый gRPC-клиент не сломается: в двоичной кодировке protobuf на проводе лежат номер поля и тип, имён нет, поэтому значение под номером 2 читается как раньше.

Источник: https://protobuf.dev/programming-guides/proto3/

## Связь между системами: поток изменений и прямые соединения

### Коннектор Debezium к PostgreSQL 18 остановили на трое суток для переезда. Нагрузка на базу прежняя, но свободное место на диске основного сервера быстро тает и растёт каталог журнала транзакций. Почему это происходит и что настроить, чтобы такая остановка не уронила базу?

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

Источник: https://www.postgresql.org/docs/18/logicaldecoding-explanation.html

### Три чужие команды подписались на поток изменений таблицы `orders`, который Debezium читает из журнала базы. Владелец сервиса заказов собирается переименовать колонку и разделить таблицу на две. Что в такой схеме потока опасно для владельца и как это исправить?

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

Источник: https://debezium.io/documentation/reference/stable/connectors/postgresql.html

### В видеозвонке один из участников сидит за корпоративным NAT. Перебор пар адресов не находит рабочей, и прямое соединение между клиентами не устанавливается. Какой компонент WebRTC даёт связь в этом случае и что это значит для нагрузки на вашу инфраструктуру?

Связь обеспечивает сервер-ретранслятор TURN (RFC 8656): он принимает трафик от обеих сторон и пересылает его друг другу. Прямого соединения нет, но звонок работает.

Источник: https://www.rfc-editor.org/rfc/rfc8656.html

## Масштабирование базы данных: пул, сжатие, представления

### Сервис делает 200 запросов в секунду, пул рассчитан на 20 соединений. После релиза каждая транзакция стала держать соединение около 200 мс (внутрь добавили вызов внешнего сервиса), хотя сам SQL выполняется 10 мс. Процессор и диск базы спокойны, а 99-й процентиль задержки приложения вырос. В чём причина и что покажут метрики?

Пул стал узким местом: соединение занято дольше, чем нужно, и запросы ждут свободного. По закону Литтла число занятых соединений равно потоку, умноженному на время удержания. При 10 мс это 200 × 0,01 = 2 соединения, при 200 мс 200 × 0,2 = 40, а в пуле их 20. Пул пропускает не больше 20 / 0,2 = 100 запросов в секунду при потоке 200, поэтому очередь в приложении растёт, пока не сработают таймауты.

Источник: https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing

### Чтобы убрать ожидание соединений, пул на каждом экземпляре увеличили с 20 до 100. Через неделю 99-й процентиль задержки стал выше, а процессор базы загружен сильнее. Почему размер пула не помог?

Соединений стало больше, чем база выполняет одновременно, и очередь переехала из приложения внутрь базы. Каждый запрос теперь конкурирует с остальными за процессор и память, а сама работа быстрее не стала.

Источник: https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing

### Материализованное представление в PostgreSQL 18 пересчитывается раз в пять минут командой `REFRESH MATERIALIZED VIEW`. Пересчёт идёт 40 секунд, и всё это время запросы читателей стоят. Как убрать блокировку и какое условие для этого нужно?

Использовать `REFRESH MATERIALIZED VIEW CONCURRENTLY`: читатели при таком обновлении не блокируются. Условие: у представления должен быть хотя бы один уникальный индекс по обычным столбцам, без условия `WHERE`.

Источник: https://www.postgresql.org/docs/18/sql-refreshmaterializedview.html

## Файловые и объектные хранилища, помехоустойчивое кодирование

### Сервис хранит в S3 лог-файл на сотни мегабайт, и разработчик предлагает менять в нём отдельные записи по смещению, как в обычном файле. Возможно ли это в объектном хранилище и что придётся делать?

Изменить кусок объекта на месте нельзя: объект в S3 записывается и заменяется целиком, а у обычного PutObject нет смещения записи.

Источник: https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html

### В кластере HDFS лежат сотни миллионов мелких файлов по несколько килобайт, дисков и места много, но NameNode упирается в память и работа встала. Почему так происходит и что с этим делают?

NameNode держит всё пространство имён и карту «файл — блоки — DataNode» в оперативной памяти одного сервера, поэтому предел кластера задаётся числом файлов и блоков, а не объёмом дисков.

Источник: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html

### Команда хочет положить в HDFS данные для интернет-магазина: заказы, которые постоянно обновляются по первичному ключу, и ночные выгрузки логов на несколько терабайт для аналитики. Какие из этих данных подходят для HDFS и почему?

Для HDFS подходят выгрузки логов: он рассчитан на файлы, записанные один раз и читаемые целиком последовательно с высокой пропускной способностью. Заказы с обновлением по ключу ему не подходят.

Источник: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html

## Архитектурные стили: уровни, события, ports and adapters

### В мобильном приложении скидка по промокоду считается на клиенте, а сервер принимает итоговую сумму заказа из запроса. Что здесь не так и как должно быть устроено?

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

Источник: https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html

### Чем уровень (tier) приложения отличается от сервера и что даёт разделение на уровни, если все они пока крутятся на одной машине?

Уровень — логическая роль в архитектуре (представление, бизнес-логика, данные), а сервер — физическая машина или процесс, на котором эта роль выполняется. Это независимые оси: три уровня могут работать на одной машине, а один уровень на десятках.

Источник: https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/n-tier

### Оформление заказа проходит через пять сервисов: оплата, склад, доставка, уведомление и бонусы. Чем хореография сказывается на понимании процесса по сравнению с оркестрацией и по каким признакам выбирают каждую?

При хореографии каждый сервис реагирует на события и публикует свои, а сценарий нигде не записан целиком: он складывается из суммы подписок. При оркестрации сценарий и состояние процесса хранит один координатор, который по шагам даёт сервисам команды.

Источник: https://learn.microsoft.com/en-us/azure/architecture/patterns/saga

## Паттерны микросервисов: BFF, миграция

### У продукта мобильное приложение и веб-клиент, и мобильному экрану главной приходится делать восемь запросов к разным сервисам. Как организовать слой, чтобы мобильный экран получал данные одним запросом, и кто должен им владеть?

Нужен слой Backend for Frontend: отдельный серверный компонент под конкретный клиент, который принимает один запрос экрана, сам обращается к нужным сервисам, собирает и сокращает ответ под этот клиент. Принадлежать он должен команде клиента.

Источник: https://learn.microsoft.com/en-us/azure/architecture/patterns/backends-for-frontends

### Чем Backend for Frontend отличается от единого API Gateway для всех клиентов?

Единый API Gateway даёт одну входную точку для всех клиентов: маршрутизация, аутентификация, ограничение частоты. BFF создаётся отдельно под каждый тип клиента и формирует API под нужды именно его.

Источник: https://learn.microsoft.com/en-us/azure/architecture/patterns/backends-for-frontends

### Старая система обслуживает клиентов, и её нужно заменить новой, не останавливая работу. Как по шагам это делает паттерн Strangler Fig?

Перед старой системой ставят фасад (прокси), который принимает все запросы клиентов, а затем по частям переносят функциональность в новые сервисы и переключают фасад на них.

Источник: https://learn.microsoft.com/en-us/azure/architecture/patterns/strangler-fig

## Основы распределённости: отказы, разрыв сети, часы, Paxos

### Сервис заказов по сети вызвал сервис списания денег и не получил ответа за отведённое время. Что известно о том, выполнилось ли списание?

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

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

### Сервис заказов записал заказ в свою базу и упал до отправки запроса в сервис склада. Чем такой отказ отличается от отказа одной машины с одной базой?

В распределённой системе отказ бывает частичным: часть операций выполнена, часть нет, и общего «откатить всё» нет. В одной машине с одной базой падение процесса откатывает незавершённую транзакцию, и наблюдатель видит либо состояние до, либо после.

Источник: https://en.wikipedia.org/wiki/Fallacies_of_distributed_computing

### В кластере из трёх узлов A, B и C пропала связь между A и C, а B по-прежнему связан с обоими. Что считает каждый из узлов о состоянии остальных?

Картины у узлов разные: A считает C недоступным, C считает недоступным A, а B видит живыми обоих. Это частичный разрыв, и вопрос «жив ли узел» не имеет единого ответа, потому что доступность задаётся парой «кто смотрит и на кого».

Источник: https://www.cockroachlabs.com/docs/stable/cluster-setup-troubleshooting

## Распределённые транзакции

### Заказ нужно записать в базу сервиса заказов и в базу сервиса склада. Почему нельзя открыть транзакцию в каждой базе и закоммитить их одну за другой?

Между двумя коммитами возможен сбой, и тогда первая база зафиксировала изменение, а вторая нет. Откатить первую уже нельзя: её коммит необратим. Получается заказ без резерва на складе или резерв без заказа.

Источник: https://www.postgresql.org/docs/18/sql-prepare-transaction.html

### Что происходит в PostgreSQL с транзакцией после `PREPARE TRANSACTION` и чем опасно оставить её в таком состоянии надолго?

Состояние транзакции целиком записывается на диск, и она отключается от сессии: после команды в сессии нет активной транзакции, а изменения не видны другим. Дальше транзакцию можно зафиксировать (`COMMIT PREPARED`) или откатить (`ROLLBACK PREPARED`) из любой сессии, и она переживает перезапуск сервера. Это и есть обещание участника двухфазной фиксации: зафиксировать почти наверняка получится.

Источник: https://www.postgresql.org/docs/18/sql-prepare-transaction.html

### В двухфазной фиксации все участники ответили «готов», и координатор упал до рассылки решения. Что делают участники и почему они не могут решить сами?

Участники остаются в подготовленном состоянии и ждут: они держат блокировки и не знают итога. Откатить транзакцию в одиночку нельзя, потому что координатор мог успеть записать решение «фиксировать» и разослать его другим участникам, а те уже зафиксировали. Зафиксировать в одиночку тоже нельзя: решение могло оказаться «откатить».

Источник: https://en.wikipedia.org/wiki/Two-phase_commit_protocol

## Структуры данных для масштаба

### В какую сторону ошибаются фильтр Блума, Count-Min sketch и HyperLogLog и как это влияет на то, где их можно применять?

Фильтр Блума ошибается в одну сторону: «элемента нет» верно всегда, а «возможно есть» может быть ложным. Поэтому он годится как предварительная проверка перед дорогим обращением: ложный положительный ответ стоит одного лишнего обращения, а нужный элемент не будет пропущен.

Источник: https://en.wikipedia.org/wiki/Bloom_filter

### Нужен фильтр Блума для 100 миллионов ключей с долей ложных срабатываний не выше 1%. Сколько памяти и сколько хеш-функций потребуется?

Около 120 МБ и 7 хеш-функций. Оптимальный фильтр тратит m/n = −ln p / (ln 2)² бит на ключ, то есть для p = 0,01 около 9,6 бита. Для 10⁸ ключей это примерно 9,6·10⁸ бит, то есть около 120 МБ.

Источник: https://en.wikipedia.org/wiki/Bloom_filter

### Фильтр Блума рассчитан на 1 миллион ключей при 1% ложных срабатываний, а в него добавили 10 миллионов. Что станет с ответами фильтра?

Фильтр перестанет отсеивать: почти на любой запрос он ответит «возможно есть». Ложноотрицательных ответов по-прежнему не будет, но ложноположительных станет подавляющее большинство.

Источник: https://en.wikipedia.org/wiki/Bloom_filter

### Почему из кукушкиного фильтра можно удалять элементы, а из фильтра Блума нельзя, и какое условие нужно соблюдать при удалении?

Кукушкин фильтр хранит короткие отпечатки элементов в корзинах хеш-таблицы, и удаление убирает один экземпляр отпечатка. В фильтре Блума биты общие для многих элементов, и сброс бита испортил бы ответы про другие элементы.

Источник: https://en.wikipedia.org/wiki/Cuckoo_filter

### Кукушкин фильтр хранит только отпечатки элементов. Как при вытеснении отпечатка из корзины найти его вторую корзину, если исходный элемент неизвестен?

Вторую корзину получают из первой и самого отпечатка: h2(x) = h1(x) ⊕ hash(fingerprint(x)). Исходный ключ для этого не нужен.

Источник: https://en.wikipedia.org/wiki/Cuckoo_filter

### Почему Count-Min sketch оценивает частоту элемента минимумом счётчиков по строкам, а не средним, и в какую сторону ошибается оценка?

Каждый счётчик, в который попал элемент, содержит его настоящую частоту плюс вклад других элементов, столкнувшихся с ним в этой ячейке. Столкновения только прибавляют, поэтому каждый счётчик не меньше истинной частоты, и оценка не занижает её.

Источник: https://en.wikipedia.org/wiki/Count%E2%80%93min_sketch

## Обработка больших данных: расчёты, конвейеры, озеро

### Ночное задание агрегирует клики по user_id на кластере из 200 исполнителей. 199 задач завершились за минуту, одна работает уже два часа, и добавление узлов время не меняет. Почему так происходит?

Все записи одного ключа после перемешивания (shuffle) попадают в одну задачу свёртки, а ключ с непропорционально большой долей записей делает эту задачу тяжёлой, и расчёт заканчивается, когда закончит самая медленная задача.

Источник: https://spark.apache.org/docs/4.2.0/sql-performance-tuning.html

### Задание MapReduce считает слова в терабайте логов, и основное время уходит на передачу промежуточных пар «слово - 1» от map-задач к reduce-задачам. Какой приём уменьшит объём передаваемого по сети?

Комбайнер (combiner): локальная предагрегация выхода каждой map-задачи до отправки в reduce.

Источник: https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html

### Ночной шаг считает выручку за вчерашний день и дописывает строки в итоговую таблицу через INSERT. Он упал на половине, шаг перезапустили, и выручка за день удвоилась. Как переделать шаг, чтобы повторный запуск был безопасен?

Сделать шаг идемпотентным: привязать его к границам периода и заменять результат периода целиком в одной транзакции.

Источник: https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html

### Конвейер каждый час загружает заказы партнёра и заменяет ими таблицу, из которой строятся отчёты. Однажды партнёр прислал файл с пустой колонкой суммы, и отчёты за час показали нули. В какой точке конвейера нужна проверка качества и что она делает при провале?

Проверка стоит после преобразования и до подмены рабочей таблицы: данные сначала попадают в промежуточную область, проверяются, и только потом заменяют результат периода.

Источник: https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html

## Выкладка: стратегии, флаги, откат

### Сервис выкатывают по схеме blue-green. Через десять минут после переключения трафика на green видно рост ошибок, и команда хочет вернуть трафик на blue, но green уже записал в общую базу строки в новом формате. Что мешает безопасному откату?

База общая для обеих сред и не переключается вместе с трафиком, поэтому blue после возврата должен уметь работать с тем, что записал green.

Источник: https://martinfowler.com/bliki/BlueGreenDeployment.html

### Перед балансировщиком стоят две группы целей, blue и green. Трафик переключили на green, но на blue ещё идут долгие запросы и открытые соединения. Когда можно выключать blue?

После того как запросы и соединения на blue завершились или истёк период слива (connection draining), а не в момент переключения.

Источник: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/edit-target-group-attributes.html

### Сервис получает около 100 запросов в минуту. Новую версию пустили на канарейку с долей 1 процент и через 10 минут решили, что ошибок нет. Новая версия при этом падала на 20 процентах запросов. Почему сигнала не было?

Доля трафика определяет, сколько событий увидит канарейка: 1 процент от 1000 запросов за 10 минут дают около 10 запросов, и при 20 процентах ошибок это в среднем две ошибки, чего не хватает для различия с контролем.

Источник: https://sre.google/workbook/canarying-releases/

### Команда автоматизирует канареечную выкладку и решает, с чем сравнивать метрики канарейки, чтобы автоматически её остановить. С чем сравнивают и как формулируют правило остановки?

С контролем: параллельно работающими экземплярами старой версии в те же минуты. Правило формулируют как допустимое отклонение канарейки от контроля.

Источник: https://sre.google/workbook/canarying-releases/

## Наблюдаемость

### Сервис принимает 2000 запросов в секунду, 99% из них успешные, а на каждый запрос пишется запись уровня INFO. Хранилище логов растёт на сотни гигабайт в сутки. Как сократить объём и не потерять возможность разбирать сбои?

Записи об ошибках сохраняют всегда, а записи об успешных запросах пишут выборкой, например одну из ста, и оставляют их только в тех полях, которые кто-то читает.

Источник: https://opentelemetry.io/docs/specs/otel/logs/data-model/

### В трассе запроса оформления заказа корневой участок длится 480 мс, а внутри него идут пять дочерних участков get-price к одному сервису цен, каждый по 90 мс, один за другим. Что показывает трасса и что стоит сделать?

Трасса показывает цикл из одинаковых последовательных вызовов: пять раз по 90 мс дают 450 мс из 480, то есть почти всё время запроса уходит на ожидание сервиса цен, а не на работу корневого сервиса.

Источник: https://opentelemetry.io/docs/concepts/signals/traces/

### Запрос проходит через шлюз, сервис заказов кладёт сообщение в Kafka, а сервис склада читает его. В логах шлюза и заказов запросы связаны общим идентификатором, а в логах склада по этому идентификатору ничего не находится. Что нужно исправить?

Идентификатор нужно положить в сообщение, например в заголовок записи Kafka, а потребитель должен достать его оттуда и записывать в каждую запись лога при обработке.

Источник: https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/

### В три часа ночи дежурного разбудило оповещение «загрузка процессора узла выше 90%». Пользователи ничего не заметили, ошибок и задержек нет. По какому принципу выбирать, о чём будить человека?

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

Источник: https://sre.google/sre-book/monitoring-distributed-systems/

### Для сервиса задана цель доступности 99,9% за 30 дней. Как вывести порог оповещения, чтобы страница приходила при крупной аварии быстро и не срабатывала на короткие мелкие всплески?

Порог задают через скорость сгорания бюджета ошибок и проверяют сразу по двум окнам: длинному, которое показывает, что бюджет уходит заметными темпами, и короткому, которое подтверждает, что авария продолжается сейчас.

Источник: https://sre.google/workbook/alerting-on-slos/

## Безопасность в масштабе

### Внутри кластера сервис платежей должен принимать вызовы только от сервиса заказов, а не от любого пода в той же сети. Что нужно для проверки отправителя на уровне соединения и какова цена?

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

Источник: https://datatracker.ietf.org/doc/html/rfc8446#section-4.3.2

### Диски базы данных зашифрованы. Злоумышленник получил действующие учётные данные приложения и выгрузил таблицу клиентов запросами через обычное подключение. Защитило ли шифрование диска и что защитило бы?

Нет, шифрование диска здесь не помогло: оно прозрачно для любого, кто обращается к базе через работающий сервер, и база отдаёт данные в расшифрованном виде.

Источник: https://cheatsheetseries.owasp.org/cheatsheets/Cryptographic_Storage_Cheat_Sheet.html

### В хранилище лежат миллиарды зашифрованных объектов, и мастер-ключ нужно периодически менять. Как устроено шифрование конвертом и почему оно позволяет менять ключ без перешифрования всех данных?

Каждый объект шифруется своим ключом данных (DEK), а сам DEK шифруется мастер-ключом (KEK), который хранится в сервисе управления ключами (KMS) и не покидает его в открытом виде. Зашифрованный DEK хранится рядом с объектом.

Источник: https://docs.aws.amazon.com/kms/latest/developerguide/kms-cryptography.html#enveloping

### Пароль к базе данных лежит в переменной окружения контейнера и один раз утёк через логи сборки. Как перестроить выдачу секрета, чтобы такой утечкой нельзя было пользоваться долго?

Секрет выдаёт отдельное хранилище по требованию: сервис при старте подтверждает свою личность (например, токеном учётной записи Kubernetes) и получает учётные данные базы с коротким сроком жизни, а не статичный пароль.

Источник: https://developer.hashicorp.com/vault/docs/secrets/databases

## Модульность: слои, срезы и модульный монолит

### Чтобы добавить в интернет-магазин промокод, разработчик правит контроллер, сервис, репозиторий и модель в четырёх разных папках проекта (Controllers, Services, Data, Models). Команда спорит, перейти ли на раскладку по возможностям (вертикальные срезы) или оставить слои. По какому критерию выбирать?

Выбирают по оси изменений: если работа приходит как «добавь или измени возможность», подходят вертикальные срезы, а если нужно подменять целиком одну техническую часть (хранилище, транспорт), подходят слои.

Источник: https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures

### Команда перешла на вертикальные срезы. Через полгода в срезах «оформление заказа» и «повторный заказ» оказались две копии расчёта скидки, и они разошлись: цена в корзине и в оплате не совпадает. Что пошло не так и как это исправлять?

Срезы не отменяют общую логику: правило, которое обязано быть одним для всех срезов (расчёт скидки), нужно выносить из срезов, а в срезах оставлять то, что относится только к своему запросу.

Источник: https://www.jimmybogard.com/vertical-slice-architecture/

### В модульном монолите на C# модуль заказов разделён на два проекта: Orders.Contracts с публичным интерфейсом и Orders с реализацией, контекстом базы и сущностями, объявленными как internal. Что из требований к границе модуля проверяет компилятор, а что остаётся на ревью и договорённостях?

Компилятор проверяет, что закрытые типы модуля (`internal`) недоступны другим проектам: реализация, `DbContext` и сущности заказов не видны оплате, и проект оплаты, который ссылается на `OrdersDb` или `Order`, не соберётся.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/internal

## Внешняя языковая модель как зависимость

### Сервис вызывает внешнюю языковую модель. В одном сценарии пользователь смотрит на экран и ждёт ответа в чате, в другом ответ модели разбирается в JSON и кладётся в базу, а вкладку пользователь обычно закрывает. Какой режим вызова выбрать в каждом сценарии и почему?

Для чата подойдёт потоковый ответ (SSE), для записи в базу фоновая задача со статусом.

Источник: https://platform.claude.com/docs/en/api/errors

### У организации лимит провайдера 120 000 токенов в минуту. Один пользователь запустил скрипт, и остальные получают `429`. Как защитить сервис?

Ввести квоту на пользователя в своём коде и считать её в токенах: лимиты провайдера не знают о ваших пользователях.

Источник: https://developers.openai.com/api/docs/guides/rate-limits

### Запрос к языковой модели оборвался по таймауту, клиент повторил его, и в счёте два вызова, а сводки получились разные. Что изменить в обращении к модели?

Не повторять вслепую: поставить ключ идемпотентности на действие пользователя, кэш ответа по хешу входа и предел на число повторов.

Источник: https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create
