Сервис бронирования изнутри: микросервисы, контейнеры и управление нагрузкой

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

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

Когда монолит перестаёт быть удобным

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

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

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

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

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

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

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

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

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

Порядок действий при бронировании номера:

  1. Поиск вариантов.

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

  2. Проверка перед подтверждением.

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

  3. Сохранение брони.

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

  4. Передача события.

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

  5. Подтверждение для гостя.

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

Архитектура сервиса бронирования

Зачем сервисы упаковывают в контейнеры

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

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

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

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

Порядок выпуска новой версии сервиса:

  1. Изменение и проверка кода.

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

  2. Сборка образа.

    Из проверенного кода и зависимостей создают контейнерный образ с однозначным идентификатором содержимого.

  3. Испытание в тестовой среде.

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

  4. Постепенное обновление.

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

  5. Контроль результата.

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

Процесс деплоя приложения

Кто следит за запущенными контейнерами

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

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

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

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

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

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

Автоматическое масштабирование ориентируется на метрики: загрузку процессора, количество запросов, длину очереди или другие показатели. В Kubernetes за изменение числа экземпляров сервиса может отвечать Horizontal Pod Autoscaler (HPA). Важно выбрать метрику, связанную с реальной задержкой в работе сервиса. Если проблема в перегруженной базе данных, запуск новых обработчиков её не решит. Наоборот, дополнительные запросы к базе могут ещё сильнее увеличить время ответа.

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

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

Порядок масштабирования при наплыве посетителей:

  1. Сбор метрик.

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

  2. Расчёт потребности.

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

  3. Поиск ресурсов.

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

  4. Запуск и подключение.

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

  5. Возврат к обычной нагрузке.

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

Схема масштабирования

Почему один сбой всё ещё может затронуть весь сайт

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

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

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

Где допустима задержка, а где ошибаться нельзя

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

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

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

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

С чего начинать переход на микросервисы

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

Через некоторое время стоит оценить результат. Стали ли обновления выходить быстрее? Легче ли найти причину неисправности? Удалось ли масштабировать наиболее загруженную часть без лишних расходов? Вместе с преимуществами нужно подсчитать и новые затраты: поддержку инфраструктуры, дежурства, наблюдение за несколькими приложениями и согласование изменений в их интерфейсах. Если сервис постоянно приходится выпускать вместе с соседним, границу между ними, возможно, выбрали неудачно.

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

Получите бесплатную консультацию по вашему проекту