Архитектура высоконагруженных веб-проектов: от балансировки до отказоустойчивости

 

 

 

Высоконагруженный веб-проект: от медленного запроса до полного отказа

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

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

[ DIAGRAM : CASCADING_SLOWDOWN_EFFECT ]
МЕДЛЕННЫЙ ЗАПРОСДержит соединениеРОСТ ОЧЕРЕДИПЕРЕГРУЗКА БДОТКАЗ

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

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

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

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

Нагрузка начинается не с количества посетителей

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

Два интернет-магазина с одинаковым количеством посетителей могут предъявлять совершенно разные требования к серверной части. В первом большинство пользователей просматривает каталог и карточки товаров. Во втором значительная часть аудитории одновременно выполняет поиск, фильтрацию, добавляет товары в корзину, проверяет остатки и оформляет заказы. Во втором случае нагрузка на динамические компоненты может оказаться значительно выше.

ЗАПРОСЫ КАТАЛОГА

Сколько запросов приходится на каталог и карточки товаров.

ПОИСК И ФИЛЬТРАЦИЯ

Как часто выполняется поиск с фильтрацией и сортировкой.

ЧТЕНИЕ ИЗ БД

Какая доля обращений требует чтения из основной базы данных.

ИЗМЕНЕНИЕ СОСТОЯНИЯ

Сколько операций изменяют состояние системы (корзина, заказ).

ПЕРЕСЧЁТ ЦЕН

Как часто пересчитываются цены, скидки и доступность товаров.

ПИК ОФОРМЛЕНИЯ

Сколько одновременных операций оформления заказа происходит в пиковые периоды.

РАВНОМЕРНОСТЬ

Насколько равномерно распределяется нагрузка в течение дня. Особенно важно учитывать разницу между средними и пиковыми значениями. Если магазин обрабатывает в среднем 100 запросов в секунду, это ещё не означает, что инфраструктура должна быть рассчитана ровно на такую производительность. Во время рекламной кампании нагрузка может кратковременно увеличиться в несколько раз.

Стоимость операции важнее, чем RPS

Но даже пиковое значение RPS (Requests Per Second) не даёт полной картины. Например, тысяча простых запросов к закэшированной странице и тысяча запросов, каждый из которых запускает несколько обращений к базе данных, расчёт доступности и обращение к внешнему сервису, — совершенно разные нагрузки.

ПРОСТОЙ ЗАПРОС

Запрос к закэшированной странице. Минимум процессорного времени, одно обращение к кэшу, небольшой объём возвращаемых данных.

СЛОЖНЫЙ ЗАПРОС

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

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

Именно стоимость операции, а не просто количество запросов, определяет реальную нагрузку на инфраструктуру и её способность масштабироваться.

 

Почему важен не только средний ответ, но и хвост распределения

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

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

[ DIAGRAM : LATENCY_PERCENTILE_DISTRIBUTION ]
p50 (100 мс)p95 (500 мс)p99 (5 сек)ХВОСТКритичные задержки

Поэтому при оценке производительности необходимо смотреть на перцентили задержки:

p50

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

p95

Позволяет оценить задержки для наиболее медленных 5% запросов. Реальный опыт значительной части пользователей.

p99

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

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

Балансировка нагрузки: почему несколько серверов ещё не означают масштабируемость

Один из первых архитектурных шагов при росте проекта — вынести обработку HTTP-запросов за пределы одного сервера. Перед группой серверов приложений размещается балансировщик нагрузки. Он принимает входящие соединения и распределяет запросы между доступными экземплярами приложения.

[ DIAGRAM : LOAD_BALANCER_DISTRIBUTION ]
КЛИЕНТЫКЛИЕНТЫКЛИЕНТЫБАЛАНСИРОВЩИКL4 / L7APP SERVER 1APP SERVER 2APP SERVER 3БАЗА ДАННЫХ

Наиболее распространены два подхода к распределению нагрузки:

БАЛАНСИРОВКА L4

Работает на транспортном уровне. Распределяет трафик на основе IP-адресов и портов без анализа содержимого HTTP-запросов. Высокая скорость, низкая гибкость.

БАЛАНСИРОВКА L7

Работает на прикладном уровне. Учитывает HTTP-заголовки, пути запросов и домены. Позволяет направлять обращения к разным группам сервисов в зависимости от характера операции.

Состояние приложения не должно зависеть от конкретного сервера

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

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

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

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

Балансировщик должен понимать, когда сервер действительно неисправен

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

LIVENESS (ЖИВОСТЬ)

Процесс приложения функционирует и не находится в состоянии, требующем перезапуска. Отвечает на вопрос: «Нужно ли перезапускать контейнер?»

READINESS (ГОТОВНОСТЬ)

Экземпляр готов принимать пользовательский трафик с учётом необходимых зависимостей (БД, кэш). Отвечает на вопрос: «Можно ли слать сюда трафик?»

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

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

 

Кэширование: самый эффективный способ не выполнять одну и ту же работу повторно

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

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

[ DIAGRAM : MULTI_LEVEL_CACHING_ARCHITECTURE ]
01 / CDN И ПЕРИФЕРИЙНЫЙ КЭШСтатика, изображения, публичный контент02 / HTTP И ПРОКСИ-СЕРВЕРГотовые ответы на идентичные запросы03 / КЭШ ПРИЛОЖЕНИЯСправочники, метаданные, в памяти процесса04 / РАСПРЕДЕЛЁННЫЙ КЭШ (REDIS)Сессии, результаты вычислений, блокировки

Кэширование должно быть многоуровневым

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

CDN И ПЕРИФЕРИЯ

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

HTTP И ПРОКСИ

Хранение готовых ответов на определённые запросы. Требует внимательной работы с HTTP-заголовками, cookies и параметрами персонализации во избежание утечки данных.

КЭШ ПРИЛОЖЕНИЯ

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

REDIS

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

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

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

Почему кэш иногда увеличивает нагрузку вместо её снижения

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

База данных получает резкий всплеск нагрузки, хотя количество пользователей практически не изменилось. Это явление называют Cache Stampede (или «эффект лавины»). Проблема особенно заметна, когда срок действия большого количества ключей истекает одновременно.

[ DIAGRAM : CACHE_STAMPEDE_PHENOMENON ]
TTL ИСТЁКРЕЗКИЙ ВСПЛЕСКОдинаковые SQL-запросыОДИН ПРОЦЕСС ОБНОВЛЯЕТ

Для предотвращения Cache Stampede используют несколько подходов:

JITTER (ДРОЖАНИЕ)

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

БЛОКИРОВКА ОБНОВЛЕНИЯ

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

ПРЕДВАРИТЕЛЬНОЕ ОБНОВЛЕНИЕ

Pre-warming: фоновое обновление популярных данных до того, как истечёт их актуальный TTL.

STALE-WHILE-REVALIDATE

Использование предыдущего (устаревшего) значения, пока в фоне формируется новое.

ОБЪЕДИНЕНИЕ ЗАПРОСОВ

Request coalescing: если тысяча пользователей запрашивает одно и то же, система выполняет один SQL-запрос.

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

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

 

Redis и инвалидация кэша: где заканчивается ускорение и начинается проблема согласованности

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

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

[ DIAGRAM : CACHE_INVALIDATION_STRATEGIES ]
1. TTL (ВРЕМЯ ЖИЗНИ)Пассивное устаревание. Не гарантирует актуальность.2. CACHE-ASIDEЧтение: кэш → БД. Запись: БД → удаление ключа.3. WRITE-THROUGHЗапись проходит через слой кэширования.4. ИНВАЛИДАЦИЯ ПО СОБЫТИЯМ (TRANSACTIONAL OUTBOX)БД фиксирует данные + событие. Отдельный воркер инвалидирует кэш.Чем критичнее актуальность данных, тем строже должен быть протокол обновления

Почему простой TTL не решает все задачи

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

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

Cache-Aside: приложение само управляет чтением и обновлением

Один из наиболее распространённых вариантов — Cache-Aside. Логика следующая: приложение запрашивает данные из Redis. Если значение найдено, возвращает его. Если ключ отсутствует, обращается к основной базе данных. Полученный результат записывает в Redis. При последующих запросах использует сохранённое значение.

Преимущество подхода — простота и возможность постепенно внедрять кэширование без существенного изменения модели хранения данных. Но есть важная проблема при обновлении. Если приложение сначала изменило базу данных, а затем должно удалить старый ключ из Redis, между этими действиями может произойти сбой. В результате основная запись обновлена, а кэш продолжает содержать прежнее значение.

Write-Through и Write-Behind: когда запись проходит через кэш

Другие стратегии предполагают более тесную связь между записью и кэшированием. Write-Through означает, что операция обновления проходит через специальный слой, который обеспечивает запись данных в основное хранилище и обновление кэша в рамках согласованного процесса. Это позволяет сократить вероятность ситуации, когда база данных уже обновлена, а кэш продолжает выдавать старое значение. Но необходимо учитывать, что Redis и реляционная база данных обычно не участвуют в одной общей транзакции. Поэтому простое выполнение двух последовательных записей не обеспечивает атомарности.

Write-Behind предполагает, что приложение сначала записывает данные в кэш или промежуточный слой, а перенос в основное хранилище происходит позже. Такой подход может быть полезен для определённых типов накопительных или событийных данных, но требует особой осторожности. Если Redis временно становится единственным местом, где существует ещё не сохранённое бизнес-изменение, его отказ может привести к потере данных. Поэтому применять Write-Behind для оформления заказов, изменения финансовых показателей и других критичных операций без специально спроектированной модели долговечности нельзя.

Инвалидация по событиям: Transactional Outbox

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

Но здесь появляется вопрос надёжности. Представим, что транзакция в базе данных успешно завершилась, а отправка события в систему инвалидации Redis не состоялась. Основная запись обновлена, но кэш остался прежним. Один из распространённых способов решения — Transactional Outbox. В рамках одной транзакции приложение сохраняет изменение бизнес-данных и запись о событии, которое необходимо опубликовать. Отдельный обработчик читает эти события и передаёт их дальше.

АТОМАРНОСТЬ ЗАПИСИ

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

ИДЕМПОТЕНТНОСТЬ

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

Когда лучше удалить ключ, а когда пересобрать его

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

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

ЯВНОЕ УДАЛЕНИЕ

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

ПРОСТРАНСТВА ИМЁН

Группировка ключей по пространствам имён для массового сброса целых сегментов кэша.

ВЕРСИОНИРОВАНИЕ

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

СОБЫТИЯ ОБ ИЗМЕНЕНИЯХ

Публикация событий об изменении сущностей, которые триггерят пересборку зависимых структур.

ФОНОВОЕ ОБНОВЛЕНИЕ

Периодическая сверка и фоновое обновление устаревающих данных для предотвращения Cache Stampede.

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

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

 

Elasticsearch: почему поиск нельзя оставлять обычной базе данных

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

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

[ DIAGRAM : RELATIONAL_VS_ELASTICSEARCH_SEARCH ]
РЕЛЯЦИОННАЯ БАЗА ДАННЫХ[!] Полное сканирование таблиц (LIKE)[!] Сложные JOIN для характеристик[!] Отсутствие морфологии и релевантностиELASTICSEARCH[+] Инвертированный индекс (быстрый текст)[+] Ранжирование по релевантности (score)[+] Агрегации, фильтры и исправление опечаток

Elasticsearch основан на поисковой технологии Apache Lucene и предназначен для полнотекстового поиска, фильтрации и аналитической обработки данных. Его принципиальное отличие от реляционной базы данных заключается в способе организации информации.

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

Почему поиск может находить не то, что ожидает пользователь

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

Например, в каталоге промышленного оборудования пользователь ищет «насос 2.2 кВт». Если система анализирует текст неправильно, она может показать насосы другой мощности, модели с похожим названием или товары, где нужное значение упоминается только в описании. Для этого необходимо правильно определить типы полей и правила их обработки.

ТИПЫ ПОЛЕЙ

Текстовые поля для полнотекстового поиска отличаются от полей для точного совпадения, фильтрации и сортировки.

ЧИСЛОВЫЕ ДАННЫЕ

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

МОРФОЛОГИЯ

Учёт русскоязычной морфологии, словоформ, сокращений, технических обозначений и транслитерации.

СИНОНИМЫ И ОПЕЧАТКИ

Продуманные анализаторы, нормализация, словари синонимов и правила обработки опечаток (fuzziness).

ТОЧНЫЙ ПОИСК ПО АРТИКУЛУ

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

ОПАСНОСТЬ АГРЕССИВНОЙ НОРМАЛИЗАЦИИ

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

Почему Elasticsearch не должен становиться основным источником товарных данных

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

Если в базе данных изменилась цена или остаток, поисковый документ должен быть обновлён. Но индексация может происходить асинхронно, поэтому между изменением основной записи и обновлением Elasticsearch возникает временной интервал. Представим, что товар сняли с продажи. В базе данных он уже недоступен, но поисковый индекс ещё содержит старую информацию. Пользователь может увидеть товар в выдаче.

ПРИНЦИП АВТОРИТЕТНОГО ИСТОЧНИКА

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

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

 

Как организовать обновление поискового индекса

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

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

[ DIAGRAM : EVENT_DRIVEN_INDEX_UPDATE ]
ОСНОВНАЯ БДProductUpdated (v2)ОБРАБОТЧИКЧтение актуальных данныхELASTICSEARCHКОНТРОЛЬ ВЕРСИЙ

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

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

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

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

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

Репликация: разделение операций чтения и записи

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

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

[ DIAGRAM : ASYNCHRONOUS_REPLICATION_LAG ]
PRIMARY (Запись)ЗАДЕРЖКА (LAG)REPLICA (Чтение)1. Пользователь создаёт заказ (Primary)2. Чтение истории (Replica) → Заказ не найден!

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

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

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

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

 

Партиционирование и шардинг: когда одной базы становится недостаточно

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

[ DIAGRAM : PARTITIONING_VS_SHARDING ]
ПАРТИЦИОНИРОВАНИЕ (внутри одной БД)ЛОГИЧЕСКАЯ ТАБЛИЦА (events)2024-Q12024-Q22024-Q32024-Q4ШАРДИНГ (между несколькими БД)Шард AID 1-1000Шард BID 1001-2000Шард CID 2001-3000...Каждый шард — самостоятельная БДТребует координации и маршрутизации

Партиционирование: разделение внутри одной базы

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

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

Шардинг: более глубокое разделение

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

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

ТРАНЗАКЦИИ

Атомарные операции между шардами требуют распределённых транзакций или паттернов Saga.

УНИКАЛЬНОСТЬ

Гарантия уникальности значений (например, email) требует отдельной координации между шардами.

ЗАПРОСЫ

Запросы, затрагивающие несколько шардов, усложняются и требуют scatter-gather подхода.

ОТЧЁТНОСТЬ

Аналитические запросы требуют агрегации данных из нескольких независимых узлов.

РЕЗЕРВНОЕ КОПИРОВАНИЕ

Согласованное восстановление состояния требует координации всех шардов.

ИЗМЕНЕНИЕ СХЕМЫ

Миграции схемы данных должны выполняться на каждом шарде с контролем совместимости.

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

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

Самая опасная точка распродажи — оформление заказа

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

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

[ DIAGRAM : CHECKOUT_CRITICAL_PATH ]
ПРОВЕРКИКорзина, цена, скидкиРЕЗЕРВИРОВАНИЕАтомарная операцияСОХРАНЕНИЕИдемпотентный ключОПЛАТАВнешний провайдер✓

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

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

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

АТОМАРНОСТЬ РЕЗЕРВИРОВАНИЯ

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

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

Защита от двойного заказа и повторной оплаты

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

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

ИДЕМПОТЕНТНЫЙ КЛЮЧ

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

ПОВТОРНЫЙ ЗАПРОС

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

СОГЛАСОВАНИЕ С БИЗНЕС-СУЩНОСТЯМИ

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

НЕОПРЕДЕЛЁННЫЙ РЕЗУЛЬТАТ

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

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

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

 

Очереди помогают переживать пики, но не отменяют ограничения

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

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

[ DIAGRAM : SYNC_VS_ASYNC_CHECKOUT_OPERATIONS ]
СИНХРОННЫЕ (ДО ПОДТВЕРЖДЕНИЯ)Проверка остатковРезервирование товараСоздание записи заказаАСИНХРОННЫЕ (В ОЧЕРЕДИ)Уведомление покупателюПередача в ERP / WMSАналитика и фоновые задачиОШИБКА АРХИТЕКТУРЫРезервирование в фоне = риск овербукинга

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

ГЛУБИНА ОЧЕРЕДИ

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

ВОЗРАСТ СООБЩЕНИЯ

Время, которое самое старое сообщение провело в очереди. Критичный показатель задержки бизнес-процессов.

ПОВТОРНЫЕ ПОПЫТКИ

Количество ретраев. Высокое значение сигнализирует о системной проблеме, а не о временном сбое.

СКОРОСТЬ ОБРАБОТКИ

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

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

Защита от пиковых нагрузок: система должна уметь ограничивать собственную нагрузку

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

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

Rate Limiting: не каждому запросу необходимо разрешать выполнение

Rate Limiting позволяет ограничивать интенсивность обращений к определённым ресурсам. Например, можно установить разные ограничения для публичного API, авторизованных пользователей, операций поиска, отправки сообщений, административных интерфейсов и отдельных дорогостоящих операций.

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

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

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

Circuit Breaker: зачем временно прекращать обращения к неисправному сервису

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

Circuit Breaker (предохранитель) решает эту проблему иначе. Он отслеживает состояние зависимости и при определённых условиях временно прекращает отправлять в неё новые запросы.

CLOSED

Обращения выполняются в штатном режиме. Ошибки отслеживаются, но не блокируют трафик.

OPEN

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

HALF-OPEN

Выполняются ограниченные проверочные запросы, позволяющие определить, восстановился ли сервис. При успехе — возврат в Closed, при неудаче — обратно в Open.

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

Graceful Degradation: что должно продолжать работать при отказе

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

ПОЛНЫЙ ОТКАЗ (CASCADE FAILURE)

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

ГРАЦИОЗНАЯ ДЕГРАДАЦИЯ

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

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

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

 

Автомасштабирование: почему добавление серверов не всегда спасает

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

Это позволяет эффективнее использовать вычислительные мощности и адаптироваться к изменению количества запросов. Но автомасштабирование не является универсальным решением проблем производительности.

[ DIAGRAM : AUTO_SCALING_BOTTLENECK_SHIFT ]
10 APP1 БАЗА ДАННЫХ(На пределе возможностей)Масштабирование30 APP1 БАЗА ДАННЫХ(Полный отказ из-за нагрузки)Масштабирование приложения без масштабирования зависимостей только усугубляет проблему

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

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

По каким показателям масштабировать инфраструктуру

Количество CPU и использование оперативной памяти — полезные, но недостаточные показатели. Например, сервер может иметь относительно невысокую загрузку процессора, но приложение уже не справляется из-за исчерпания пула соединений или длительного ожидания внешнего сервиса.

РЕСУРСЫ СЕРВЕРА

Загрузка процессора и памяти.

НАГРУЗКА

Количество одновременных запросов и активных соединений.

ПРОИЗВОДИТЕЛЬНОСТЬ

Время ответа приложения и скорость обработки запросов.

ОЧЕРЕДИ

Длина очередей сообщений и задач.

ОШИБКИ

Количество ошибок и тайм-аутов.

БАЗЫ ДАННЫХ

Задержки обращения к базам данных и репликам.

ФОНОВЫЕ ЗАДАЧИ

Скорость поступления и выполнения задач (особенно показательна для воркеров).

ПРОВЕРКА РЕСУРСОВ

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

Почему автомасштабирование нужно готовить заранее

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

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

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

Отказоустойчивость: что произойдёт, если один из серверов перестанет работать

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

Допустим, интернет-магазин использует несколько экземпляров приложения, балансировщик и отдельную базу данных. Один сервер приложения выходит из строя. Балансировщик перестаёт направлять на него новые запросы, а остальные экземпляры продолжают работу. Это относительно простой сценарий. Но что произойдёт, если станет недоступен Redis? Или основной узел базы данных? Или регион, в котором расположена вся инфраструктура?

Отказоустойчивость начинается с устранения единых точек отказа

Единая точка отказа (Single Point of Failure, SPOF) — компонент, неисправность которого способна остановить критически важную часть системы. Это может быть не только сервер.

[!] Один балансировщик без резервирования.
[!] Единственный сервер базы данных.
[!] Один узел хранения файлов.
[!] Единственный экземпляр интеграционного сервиса.
[!] Общий сетевой шлюз.
[!] Централизованное хранилище сессий без предусмотренного восстановления.

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

Репликация не гарантирует автоматическое и безопасное переключение

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

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

RPO И RTO: ДВЕ ХАРАКТЕРИСТИКИ, КОТОРЫЕ НЕОБХОДИМО ОПРЕДЕЛИТЬ ДО АВАРИИ
RPO (Recovery Point Objective)

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

RTO (Recovery Time Objective)

Допустимое время восстановления работоспособности. Если RTO составляет 15 минут, необходимо спроектировать процессы обнаружения отказа, переключения, восстановления и проверки системы так, чтобы уложиться в этот интервал.

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

Для корпоративного каталога с преимущественно информационными данными требования могут быть одними. Для интернет-магазина с активными заказами и платежами — совершенно другими. И главное: заявленные показатели должны подтверждаться испытаниями, а не только возможностями оборудования.

 

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

В распределённой системе один пользовательский запрос может пройти через множество компонентов. Балансировщик принимает соединение, приложение обращается к Redis, затем к базе данных, поисковому сервису или внешнему API.

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

[ DIAGRAM : THREE_PILLARS_OF_OBSERVABILITY ]
МЕТРИКИКоличественные показателиЗагрузка, RPS, ошибки,очереди, p95/p99Что: «Сколько?»ЛОГИСобытия и контекстЧто происходило,какие значения, ошибкиЧто: «Что случилось?»ТРАССИРОВКАПуть конкретного запросаСквозной Trace ID,время каждого spanЧто: «Где задержка?»

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

Например, пользователь жалуется, что оформление заказа выполняется десять секунд. Метрики показывают увеличение времени ответа. Трассировка позволяет обнаружить, что само приложение работает быстро, но четыре секунды тратит на получение информации из базы данных и ещё пять — на ожидание внешнего сервиса. Без трассировки разработчики могут начать оптимизировать не тот компонент.

Компонент
Что контролировать
Балансировщик.
Входящий трафик, ошибки, распределение запросов.
Приложение.
p95/p99, ошибки, активные запросы.
Redis.
Задержки, память, попадания в кэш, вытеснения ключей.
Elasticsearch.
Время поиска, состояние узлов, очереди запросов.
База данных.
Медленные запросы, блокировки, соединения, задержки репликации.
Очереди.
Размер, возраст сообщений, скорость обработки.
CDN.
Доля попаданий в кэш, ошибки и объём трафика.

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

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

Нагрузочное тестирование: почему проверка на 10 000 пользователей может ничего не доказать

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

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

Тип испытания
Что проверяет
Load Testing.
Работа при ожидаемой штатной и повышенной нагрузке. Позволяет определить производительность и выявить узкие места.
Stress Testing.
Постепенное увеличение нагрузки до момента, когда система перестаёт соответствовать требованиям. Определяет реальные пределы инфраструктуры.
Spike Testing.
Проверка резкого увеличения и последующего снижения нагрузки. Особенно актуальна для распродаж и рекламных кампаний.
Soak Testing.
Длительная работа под нагрузкой. Позволяет выявлять утечки памяти, рост очередей, исчерпание соединений и деградацию производительности.
Failover Testing.
Проверка поведения при отключении отдельных компонентов и переключении на резервные узлы.

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

ЛОВУШКА RPS

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

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

Проверять необходимо не только штатную работу, но и восстановление

Предположим, тест показал, что интернет-магазин выдерживает необходимую нагрузку. Но что произойдёт, если в этот момент станет недоступна одна из реплик базы данных? Или Redis начнёт отвечать с повышенной задержкой? Или очередь фоновых задач перестанет успевать обрабатывать входящие события?

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

ВОЗВРАТ REDIS

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

РАЗГРЕБ ОЧЕРЕДИ

После восстановления очереди фоновых задач может начаться интенсивная обработка накопившихся сообщений.

ВТОРАЯ ВОЛНА

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

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

 

Как проектировать архитектуру без избыточного усложнения

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

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

[ DIAGRAM : ARCHITECTURE_COMPLEXITY_TRADEOFF ]
МОДУЛЬНЫЙ МОНОЛИТПростота + Горизонтальное масштабированиеРост нагрузкиМИКРОСЕРВИСЫГибкость + Распределённая сложностьИЗБЫТОЧНОСТЬСложность растёт быстрее пользы

Когда микросервисы действительно оправданы

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

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

ЛОКАЛЬНАЯ ТРАНЗАКЦИЯ (МОНОЛИТ)

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

РАСПРЕДЕЛЁННАЯ ОПЕРАЦИЯ (МИКРОСЕРВИСЫ)

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

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

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

Архитектура должна иметь понятные границы ответственности

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

Например, если цена товара хранится в основной базе, Redis и Elasticsearch, необходимо чётко понимать:

01 / ИСТОЧНИК ИЗМЕНЕНИЯ

Где именно происходит изменение цены?

02 / АВТОРИТЕТНЫЙ ИСТОЧНИК

Какой компонент считается единственным источником истины?

03 / РАСПРОСТРАНЕНИЕ

Как изменения синхронно или асинхронно распространяются?

04 / ОБНАРУЖЕНИЕ РАСХОЖДЕНИЙ

Каким образом система обнаруживает рассинхронизацию данных?

05 / ВОССТАНОВЛЕНИЕ

Как восстанавливается актуальное состояние при конфликте?

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

 

Вместо заключения: высокая нагрузка проверяет не серверы, а архитектурные решения

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

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

[ DIAGRAM : FAILURE_POINTS_AT_BOUNDARIES ]
КЭШ (REDIS)УСТАРЕВШИЕ ДАННЫЕПРИЛОЖЕНИЕПОВТОРНЫЕ ОПЕРАЦИИОЧЕРЕДЬПОТЕРЯННЫЕ СОБЫТИЯБИЗНЕС-ПРОЦЕСС

Поэтому при проектировании необходимо ответить на несколько принципиальных вопросов:

01 / ОТКАЗ ЭКЗЕМПЛЯРА

Что произойдёт, если один экземпляр приложения перестанет отвечать?

02 / НЕДОСТУПНОСТЬ REDIS

Как система поведёт себя, если Redis временно станет недоступен?

03 / ЗАДЕРЖКА ДАННЫХ

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

04 / ПОВТОРНАЯ ОТПРАВКА

Как предотвратить повторное создание заказа при повторной отправке запроса?

05 / РОСТ ОЧЕРЕДИ

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

06 / ОТКАЗ ВНЕШНЕГО СЕРВИСА

Как система продолжит работу при отказе внешнего сервиса?

07 / RPO И RTO

Сколько данных допустимо потерять при аварии и за какое время инфраструктура должна восстановиться?

08 / ПОДТВЕРЖДЕНИЕ НАГРУЗКИ

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

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

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

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

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

 

НАВИГАЦИЯ // SUGGESTED_READING
 
[ Модуль // ИНФРАСТРУКТУРА ]

Что происходит с системой после запуска

 
[ Модуль // ИНФРАСТРУКТУРА ]

Что произойдёт, если один сервер внезапно отключится

 
[ Модуль // РАЗРАБОТКА ]

Как понять, что программу пора переписывать

 
[ EXPERTISE JOURNAL ]

Все инженерные материалы и экспертные статьи

 
[ CORE GLOSSARY ]

Полный алфавитный справочник ИТ-терминов

 

AI Ассистент
×
ИИ может ошибаться