mufassall

Словарь терминов

Главные термины курса: каждый в одной-двух фразах и со ссылкой на урок, где он объясняется.

Балансировщик нагрузки

Компонент, который распределяет входящий трафик между серверами. L4 раздаёт соединения, L7 — отдельные запросы; выбирает по round robin, least connections или весам.

В уроке: Балансировка нагрузки →
Вертикальное масштабирование

Замена сервера на более мощный. Это просто, но однажды больше сервера не найти, и он всё равно остаётся единой точкой отказа.

В уроке: Вертикальное и горизонтальное масштабирование →
Горизонтальное масштабирование

Добавление серверов вместо одного большого. Для этого нужен балансировщик впереди и stateless-серверы приложения.

В уроке: Вертикальное и горизонтальное масштабирование →
Горячий ключ

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

В уроке: Шардирование →
Группа консьюмеров

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

В уроке: Pub/sub и журнал событий →
Грязное чтение (dirty read)

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

В уроке: Транзакции →
Двухфазный коммит (2PC)

Координатор сначала просит всех участников подготовиться и проголосовать, и только если все «за», рассылает commit. Участники всё это время держат блокировки и зависают, если координатор упал, поэтому 2PC избегают.

В уроке: Саги и outbox →
Доставка at-least-once

Сообщение доставляется минимум один раз, а иногда дважды. Поэтому потребитель отбрасывает дубли по event_id или пишет идемпотентно.

В уроке: Саги и outbox →
Единая точка отказа (SPOF)

Часть, без которой останавливается вся система. Ей дают резерв, который подменяет её без участия человека.

В уроке: Резервирование и failover →
Задержка (latency)

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

В уроке: Задержка и пропускная способность →
Идемпотентность

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

В уроке: Надёжные колбэки →
Инвалидация кеша

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

В уроке: Кеширование →
Индекс

Отдельная отсортированная структура, обычно B-tree, чтобы база находила строки без полного сканирования таблицы. В составном индексе важен порядок колонок, а каждый индекс замедляет каждую запись.

В уроке: Индексы в базе данных →
Кворум (R + W > N)

Запись считается выполненной, когда её подтвердили W из N реплик, а чтение опрашивает R реплик. Если R + W > N, каждое чтение пересекается с последней записью хотя бы на одной реплике, и писать может только большинство.

В уроке: CAP: когда рвётся связь →
Ключ шардирования

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

В уроке: Шардирование →
Консенсус (Raft)

Несколько узлов договариваются о лидере и общем журнале голосованием большинства. Изменение закоммичено, когда его сохранило большинство, а термы и голоса дают не больше одного лидера на терм.

В уроке: Консенсус и выбор лидера →
Консистентное хеширование

Узлы и ключи размещают на одном кольце, ключ принадлежит следующему узлу по часовой стрелке. При добавлении или уходе узла переезжает лишь ~1/N ключей, а виртуальные узлы выравнивают нагрузку.

В уроке: Консистентное хеширование →
Курсорная пагинация

Следующую страницу просят не через OFFSET, а курсором, указывающим на последнюю показанную запись. Новые записи не вызывают повторов и пропусков.

В уроке: Стили API →
Микросервис

Небольшой сервис со своим деплоем и своими данными; остальные обращаются к нему только через API или события. Цена — сетевые вызовы, частичные отказы и отсутствие общей транзакции, поэтому начинают с чистого монолита.

В уроке: Микросервисы →
Набег на кеш (stampede)

В момент истечения горячего ключа тысячи запросов одновременно промахиваются и идут в базу с одним и тем же запросом. Против этого работают coalescing и случайный TTL.

В уроке: Кеширование →
Оптимистичная блокировка (version)

Вместо блокировки строки заранее при записи проверяется, что столбец version не изменился. Если кто-то успел раньше, update ничего не меняет, и операция повторяется.

В уроке: Транзакции →
Отставание репликации

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

В уроке: Репликация базы данных →
Оценка на салфетке

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

В уроке: Оценка на салфетке →
Очередь (queue)

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

В уроке: Очереди сообщений →
Перцентиль (p50, p95, p99)

p95 означает, что 95% запросов быстрее этого значения, то есть каждый двадцатый медленнее. Среднее прячет медленный хвост, поэтому смотрят на p95 и p99.

В уроке: Задержка и пропускная способность →
Пропускная способность (throughput)

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

В уроке: Задержка и пропускная способность →
Репликация (лидер и фолловеры)

Лидер принимает все записи и передаёт свой журнал фолловерам, которые проигрывают его и держат копию. Реплики дают ёмкость на чтение и резерв для failover.

В уроке: Репликация базы данных →
Сага

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

В уроке: Саги и outbox →
Сброс нагрузки (load shedding)

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

В уроке: Задержка и пропускная способность →
Сетевой раздел (partition)

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

В уроке: CAP: когда рвётся связь →
Таймаут

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

В уроке: Таймауты и ретраи →
Транзакция

Несколько связанных записей внутри BEGIN ... COMMIT: сохраняются либо все, либо ни одна. Даже если сервер умрёт посередине, половины записи не останется.

В уроке: Транзакции →
Трейс и span

Каждый сервис пишет span для запроса: что делал, когда начал и сколько длилось. Span'ы по общему trace id собираются в одно дерево, и медленный шаг становится виден.

В уроке: Наблюдаемость →
Уровень изоляции

Определяет, насколько параллельные транзакции видят изменения друг друга: READ COMMITTED, REPEATABLE READ, SERIALIZABLE. Чем выше уровень, тем больше аномалий закрыто, но тем больше повторов.

В уроке: Транзакции →
Хеш пароля с солью

Хранят не сам пароль, а медленный хеш (argon2id или bcrypt) со случайной солью для каждого пользователя. Вход замедляется незаметно, а взлом утёкшей базы становится в миллионы раз дороже.

В уроке: Аутентификация →
Шардирование

Разделение таблицы, которая не помещается на один сервер, по строкам между несколькими серверами (шардами). Где лежит каждая строка, решает ключ шардирования.

В уроке: Шардирование →
Шифрование на диске (at rest)

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

В уроке: Шифрование и секреты →
Экспоненциальный backoff

Перед каждой повторной попыткой пауза удваивается. Мгновенные ретраи не превращаются в шторм, который добивает упавший сервис.

В уроке: Таймауты и ретраи →
API gateway

Единая входная дверь перед всеми сервисами: проверяет токен, применяет rate limit, добавляет request id и маршрутизирует по пути. Скрывает внутреннее устройство от клиентов.

В уроке: Микросервисы →
B-дерево (B-tree)

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

В уроке: Движки хранения: B-tree и LSM →
Backpressure (обратное давление)

Торможение продюсера, когда потребители не успевают. Очередь ограничена, и вместо бесконечного роста продюсер ждёт.

В уроке: Очереди сообщений →
Base62-код

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

В уроке: Проектируем сокращатель ссылок →
Batch и stream

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

В уроке: Batch и stream →
Blue-green деплой

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

В уроке: CI/CD: от коммита до продакшена →
Cache-aside

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

В уроке: Кеширование →
Canary-деплой

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

В уроке: CI/CD: от коммита до продакшена →
CAP

При сетевом разделе система должна выбрать: остаться согласованной (CP) и отказать в записи на отрезанной стороне или остаться доступной (AP) и принимать записи с обеих сторон. Во время разрыва нельзя получить и то и другое.

В уроке: CAP: когда рвётся связь →
CDN и edge

Сеть кешей на edge-серверах рядом с пользователями, которая отдаёт статику. Origin только заполняет промахи, а что и на сколько кешировать, решает Cache-Control.

В уроке: CDN и кеш на краю сети →
CI/CD

CI собирает и тестирует каждый коммит один раз и выпускает один неизменяемый артефакт; деплоится только зелёная сборка. Деплой становится маленьким, автоматическим и легко откатываемым.

В уроке: CI/CD: от коммита до продакшена →
Circuit breaker

Когда доля ошибок превышает порог, breaker размыкается и на время вообще не вызывает мёртвый сервис, отдавая запасной ответ. Затем в состоянии half-open одна пробная попытка решает, замкнуть его или снова разомкнуть.

В уроке: Таймауты и ретраи →
Dead-letter очередь

Отдельная очередь, куда уходит ядовитое сообщение, которое не обработалось после нескольких попыток. Оно не блокирует основную очередь, а за ней следят.

В уроке: Очереди сообщений →
Envelope-шифрование (KMS)

Каждую запись шифруют своим data key, а data key заворачивают master key, который не покидает KMS. В базе лежит только завёрнутый ключ, а ротация требует перезавернуть ключи, а не перешифровать данные.

В уроке: Шифрование и секреты →
Eventual consistency (согласованность в конечном счёте)

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

В уроке: CAP: когда рвётся связь →
Failover

Когда основная база умирает, резервную реплику повышают до primary и переключают на неё приложение. Автоматический failover делает это без человека за секунды.

В уроке: Резервирование и failover →
Fan-out (on write / on read)

Fan-out on write при публикации кладёт id поста в кеш ленты каждого подписчика, а fan-out on read собирает ленту при открытии. Лучше всего работает гибрид: push для большинства, pull для звёзд.

В уроке: Проектируем ленту новостей →
Feature flag

Код уходит в прод выключенным и через флаг включается сначала для сотрудников, затем для части пользователей. При проблеме флаг гасят за секунду: деплой — это ещё не релиз.

В уроке: CI/CD: от коммита до продакшена →
Fencing-токен

Растущий номер, который выдаётся с каждой новой блокировкой. Защищаемый ресурс помнит самый большой номер и отклоняет запись воркера, проснувшегося со старой блокировкой.

В уроке: Консенсус и выбор лидера →
GraphQL

Клиент сам пишет в запросе, какие поля ему нужны, и получает их одним вызовом. N+1 переезжает на сервер, поэтому резолверы группируют, а стоимость запроса ограничивают.

В уроке: Стили API →
gRPC

Быстрый RPC-протокол со строгой схемой и бинарным форматом. Подходит для внутренних вызовов между своими сервисами.

В уроке: Стили API →
Health check (проверка здоровья)

Балансировщик регулярно опрашивает сервер и за несколько секунд выводит из пула тот, что не отвечает. Когда сервер оживает, его возвращают.

В уроке: Балансировка нагрузки →
Idempotency-Key

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

В уроке: Стили API →
Jitter (джиттер)

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

В уроке: Таймауты и ретраи →
JWT

Подписанный токен, который любой сервис проверит без похода в базу. Мгновенно отозвать его нельзя, поэтому access-токен делают коротким и дополняют refresh-токеном.

В уроке: Аутентификация →
Long polling

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

В уроке: Обновления в реальном времени →
LSM-дерево

Хранилище, которое дописывает запись в WAL, сортирует её в memtable в памяти и потом сбрасывает на диск файлом SSTable. Запись очень быстрая, плата — усиление чтения и compaction.

В уроке: Движки хранения: B-tree и LSM →
NoSQL (документ, wide-column, key-value)

Нереляционные хранилища: документное отдаёт весь объект за одно чтение, wide-column держит огромный поток записей, key-value ищет только по ключу. Они заточены под заранее известный сценарий, а реляционная база открыта новым вопросам.

В уроке: SQL и NoSQL →
OAuth2 / OIDC

Пользователь входит у провайдера идентификации и возвращается с одноразовым code, который API обменивает сервер-сервер на id token. Приложение вообще не видит пароль.

В уроке: Аутентификация →
Observability (логи, метрики, трейсы)

Логи говорят, что произошло, метрики — сколько и как часто, трейсы — куда ушло время. Для сервисов метрики RED, для ресурсов USE, а алерт ставят на p95, а не на среднее.

В уроке: Наблюдаемость →
Origin shield

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

В уроке: CDN и кеш на краю сети →
Outbox

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

В уроке: Саги и outbox →
Presigned URL

Короткоживущая ссылка, подписанная API, по которой клиент грузит файл прямо в объектное хранилище. Байты не идут через API, он только проверяет, кто грузит и какого размера файл.

В уроке: Загрузка файлов →
Pub/sub

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

В уроке: Pub/sub и журнал событий →
Rate limiting (ограничение частоты)

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

В уроке: Rate limiting →
RBAC и ABAC

RBAC выдаёт права по ролям, ABAC — по правилам об атрибутах пользователя, ресурса и контекста. Оба живут в одной политике в одном месте, по умолчанию — отказ.

В уроке: Авторизация →
Read-your-writes

Гарантия, что пользователь всегда видит то, что сам записал. После записи его чтения идут на лидера, пока реплика не догонит.

В уроке: Репликация базы данных →
Request coalescing (склейка запросов)

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

В уроке: Кеширование →
REST

У каждого ресурса один URL и стандартные HTTP-методы. Просто и хорошо кешируется, но легко приводит к over-fetching, under-fetching и N+1 запросам.

В уроке: Стили API →
Service discovery (обнаружение сервисов)

Экземпляры при старте записывают имя и адрес в реестр и удаляются, когда пропадает heartbeat. Вызывающий берёт адрес не из конфига, а из реестра: сам (client-side), через балансировщик (server-side) или через DNS.

В уроке: Обнаружение сервисов →
Snowflake ID (время + машина + счётчик)

64-битный id из миллисекунд с выбранной эпохи, номера машины и счётчика внутри миллисекунды. Каждый сервер делает id сам, а если часы пошли назад, ждёт или отказывает.

В уроке: Уникальные идентификаторы →
Split brain

Два узла одновременно считают себя primary и оба принимают записи. Данные расходятся, поэтому старый primary отсекают через fencing.

В уроке: Резервирование и failover →
Stateless-сервер

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

В уроке: Серверы без состояния →
Sticky-сессия

Балансировщик всегда отправляет пользователя на тот же сервер. Это прячет проблему, а не решает её: при перезапуске сервера сессия теряется, а нагрузка перекашивается.

В уроке: Серверы без состояния →
TLS

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

В уроке: Шифрование и секреты →
Token bucket

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

В уроке: Rate limiting →
TTL (время жизни)

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

В уроке: Кеширование →
UUIDv7

128-битный id, у которого первые 48 бит — время в миллисекундах, а остальное случайно. Новые id попадают в конец индекса и не разрывают B-tree, как случайный UUIDv4.

В уроке: Уникальные идентификаторы →
WAL (журнал предзаписи)

Каждое изменение сначала дописывается в конец журнала и только потом попадает в основную структуру. Если сервер упал, данные восстанавливаются из этого журнала.

В уроке: Движки хранения: B-tree и LSM →
Watermark

Метка, которая решает, сколько стрим-процессор ждёт опоздавшие события: самое новое увиденное event time минус допустимое опоздание. Окно становится окончательным, когда watermark проходит его конец, а ещё более поздние идут в side output.

В уроке: Batch и stream →
WebSocket

Одно постоянное соединение между клиентом и сервером, по которому обе стороны пишут в любой момент. Множество открытых соединений держит отдельный слой шлюзов.

В уроке: Обновления в реальном времени →
Write-through и write-back

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

В уроке: Кеширование →