Монолит или микросервисы?
МЕЖДУ ДВУХ ПОДХОДОВ
Почему вопрос архитектуры нельзя решить одним универсальным правилом
Когда компания начинает разработку новой системы, вопрос архитектуры часто звучит почти автоматически:
«Делаем монолит или сразу микросервисы?»
Проблема в том, что сама постановка вопроса уже немного неправильная.
Монолит и микросервисы — это не соревнование двух технологий, где одна современная, а другая устаревшая. Это два разных способа распределить ответственность внутри системы. И оба могут быть правильными.
- › Для небольшой или средней системы хороший структурированный монолит нередко оказывается значительно более разумным и экономным решением, чем десятки отдельных распределённых сервисов.
- › Для большой платформы попытка искусственно удержать все бизнес-процессы в рамках одного приложения может, наоборот, превратиться в серьёзное инфраструктурное ограничение.
Поэтому архитектуру имеет смысл выбирать не по текущей моде и не по красивой абстрактной схеме на презентации. Необходимо детально оценивать следующие факторы:
- › общий физический размер системы;
- › количество задействованных команд разработки;
- › характер и пики входящей нагрузки;
- › требования к отказоустойчивости;
- › целевую скорость внесения изменений;
- › конечную стоимость эксплуатации инфраструктуры.
Сначала представим обычную систему
Допустим, компания заказывает разработку собственной информационной системы.
В системе предусмотрены работа с пользователями, заявками, документами и статусами, отправка уведомлений, формирование аналитических отчётов и интеграция с внешними сервисами.
Основная бизнес-логика сосредоточена в одном приложении и развёртывается как единое целое. При этом приложение может работать в нескольких экземплярах на разных серверах. Такая архитектура вполне подходит для многих корпоративных и продуктовых систем.
- › Услышав термин «монолит», многие представляют устаревшую программу, которую сложно сопровождать и масштабировать.
- › Но монолитная архитектура сама по себе ничего подобного не означает. Хорошо спроектированный монолит состоит из модулей с понятными границами ответственности и организованной кодовой базой.
Инженерная деградация проекта начинается далеко не тогда, когда ядро приложения классифицируется как монолит:
> Проблемы начинаются, когда в кодовой базе размываются границы между модулями и становится сложно контролировать их взаимосвязи.
А что меняется с микросервисами?
При микросервисном подходе систему разделяют на отдельные сервисы, каждый из которых отвечает за определённую часть функциональности.
Теперь отдельные сервисы можно разрабатывать, развёртывать и масштабировать независимо друг от друга — если между ними определены устойчивые контракты и устранены критические зависимости, требующие синхронного изменения нескольких компонентов. Это даёт командам больше автономности, но требует дополнительных усилий для организации взаимодействия и эксплуатации.
Но вместе с независимостью в архитектуре неизбежно появляется кое-что ещё:
> При этом появляются дополнительные компоненты инфраструктуры, которые нужно настраивать и сопровождать.
Микросервисы добавляют не только возможности
Каждый новый изолированный сервис — это отдельный процесс, который необходимо независимо запускать, непрерывно мониторить, обновлять и диагностировать.
- › В ландшафте появляются постоянные сетевые взаимодействия;
- › Один сервис вынужден постоянно вызывать по API другой;
- › Целевой компонент системы может быть временно недоступен;
- › Любой межсервисный запрос может завершиться сетевой ошибкой;
- › Асинхронное сообщение рискует зависнуть или застрять в очереди;
- › Одна простая бизнес-операция затрагивает несколько сервисов сразу.
При этом возникает другой архитектурный вопрос:
— «Как разбить монолитное приложение на несколько изолированных частей?»
Вопрос переходит на следующий уровень:
— «Как обеспечить предсказуемую работу сложной распределённой системы, в которой эти части непрерывно разговаривают друг с другом по сети?»
Это усложняет разработку, диагностику и эксплуатацию системы.
Монолит проще — но не всегда
У монолита есть очень практичное преимущество: простота взаимодействия между внутренними компонентами.
Если модуль работы с заявками должен обратиться к модулю пользователей, это происходит в оперативной памяти внутри одного приложения:
- › Не нужно формировать сетевой запрос и сериализовать данные для передачи по сети.
- › Не нужно думать о таймаутах на транспортном уровне.
- › Не нужно решать сложную задачу изоляции сбоев при недоступности второго сервиса.
- › Не нужен отдельный кастомный механизм повторных запросов (retries).
- › Не требуется сквозная распределённая трассировка (tracing) только ради того, чтобы понять, в каком именно месте сети потерялся вызов метода.
- › Для системы, которую поддерживает одна команда и используют несколько сотен или тысяч сотрудников, это упрощает разработку и сопровождение.
- › При таком раскладе разработчики тратят драгоценное рабочее время не на инфраструктурное обслуживание распределенной сложной архитектуры, а на прямое развитие продуктовых функций бизнеса.
Но у монолита тоже есть предел
Представим другую архитектурную ситуацию, характерную для крупной компании.
Несколько независимых продуктовых команд одновременно и параллельно развивают совершенно разные функциональные направления единой платформы:
- › отдельно развивается биллинг;
- › отдельно — товарный каталог;
- › отдельно — складская логистика;
- › отдельно — сервис авторизации;
- › отдельно — сквозная аналитика.
При этом компоненты могут существенно различаться по нагрузке. Например, каталог обязан стабильно обслуживать тысячи запросов в секунду, в то время как внутренний модуль корпоративного документооборота задействуется сотрудниками относительно редко.
> В таком сценарии горизонтальное масштабирование всего приложения может оказаться неэкономичным: вместе с высоконагруженным каталогом придётся запускать дополнительные экземпляры и других модулей. При этом отдельные компоненты модульного монолита нельзя независимо масштабировать как самостоятельные сервисы без дополнительных архитектурных решений.
- › Распределение изолированных компонентов по самостоятельным сервисам начинает приносить реальную пользу бизнесу: каждый сервис можно масштабировать с учётом его нагрузки.
В таких условиях микросервисная архитектура позволяет независимо масштабировать компоненты с разной нагрузкой.
Самая дорогая часть микросервисов — не серверы
Иногда микросервисы активно продают на презентациях как безальтернативный способ «масштабировать систему».
Но закупка дополнительных вычислительных ресурсов — далеко не единственная и не самая большая цена. Существенную часть затрат может составлять обслуживание распределённой системы.
- › Если у вас один сервер приложения: Локализовать, воспроизвести и оперативно разобраться с возникшей технической проблемой в кодовой базе относительно просто.
- › Если у вас двадцать сервисов: Развернута асинхронная очередь сообщений, несколько разнородных баз данных, API Gateway, балансировщики нагрузок и десятки скрытых сетевых взаимодействий — банальный поиск первопричины ошибки превращается в отдельную комплексную задачу.
На интерфейсе конечный пользователь видит лишь сухую абстрактную плашку:
При этом дежурный инженер техподдержки обязан по цепочке логов выяснить массу неочевидных вопросов:
- › дошёл ли исходный HTTP-запрос от клиента до API Gateway;
- › успешно ли Gateway проксировал и передал его сервису A;
- › смог ли сервис A корректно и без таймаутов вызвать B;
- › успел ли сервис B успешно записать событие в брокер;
- › приняла ли асинхронная очередь это сообщение без потерь;
- › вычитал ли и получил ли сервис C данную задачу;
- › была ли целевая база данных доступна в момент транзакции;
- › была ли операция отклонена проверкой бизнес-правил;
- › критическая ошибка произошла сразу или после серии повторных автоматических попыток (retries).
Поэтому при использовании микросервисов команде нужны мониторинг, сквозная трассировка и отлаженные процессы диагностики сбоев.
Есть ещё одна важная вещь — данные
Управление базами данных в монолитных и распределённых экосистемах подчиняется разным архитектурным законам.
Несколько модулей монолита могут использовать одну базу данных. Это упрощает обмен данными, но создаёт зависимости между модулями через структуру таблиц.
⚠️ Любое изменение схемы или структуры таблиц одним модулем рискует мгновенно сломать логику сразу нескольких других частей приложения.
В типичной микросервисной архитектуре каждый сервис отвечает за собственную модель данных и управляет её изменением через определённые интерфейсы. Это уменьшает прямую зависимость других сервисов от внутренней структуры его базы, но усложняет получение согласованных данных из нескольких источников и выполнение сквозных бизнес-операций.
➔ Если сервисы используют отдельные базы данных, обычный SQL JOIN между их таблицами, как правило, недоступен напрямую в рамках одного запроса к одной СУБД. Межсистемное объединение данных возможно через федеративные запросы, специальные инструменты интеграции или предварительно подготовленные аналитические наборы, но эти подходы требуют дополнительных механизмов и не заменяют автоматически транзакции внутри одной базы.
Чтобы связать информацию из разных баз, инженерам приходится с нуля проектировать и настраивать сложную логику регулярного обмена данными между сервисами. В контур добавляются:
- › программные вызовы межсервисных API;
- › асинхронные бизнес-события;
- › распределённые очереди сообщений;
- › фоновые трансляторы и репликаторы;
- › механизмы согласования данных между сервисами, в том числе модель согласованности в конечном счёте (eventual consistency), если она допустима для конкретного бизнес-процесса.
- › Микросервисы не устраняют инженерную сложность автоматически: они меняют её распределение между компонентами системы.
- › Часть сложности переносится на уровень сетевого взаимодействия, согласованности данных, наблюдаемости и эксплуатации. При удачном разделении доменов это может упростить развитие отдельных компонентов и работу независимых команд, но общие затраты необходимо оценивать для всей системы.
Это одна из самых важных вещей, которую руководству компании стоит детально понимать задолго до принятия решения о переходе на такую архитектуру.
Почему «сразу микросервисы» часто оказывается ошибкой
При планировании ИТ-системы иногда исходят из следующей логики:
«Мы планируем большую и нагруженную систему, поэтому сразу построим её на микросервисах. Так её потом будет намного проще масштабировать».
Проблема в том, что на старте разработки будущие требования к системе известны не полностью.
На старте разработки продукта инженерам и бизнесу практически никогда не понятно, какие доменные границы системы в реальности окажутся правильными. Сегодня кажется логичным выделить изолированный сервис заказов, а через год выясняется, что половина его внутренней логики намертво связана с клиентами и эквайрингом. Границы сущностей начинают размываться.
- › В результате такой поспешной декомпозиции получается не набор независимых, слабосвязанных модулей, а **тяжёлый распределённый монолит**. Только теперь его куски искусственно разнесены по разным физическим серверам.
- › Формально приложения разделены на отдельные сервисы, но фактически остаются тесно связанными: выполнение одной бизнес-операции требует последовательных синхронных вызовов нескольких компонентов. Из-за этого задержка или отказ одного сервиса может нарушить работу всей цепочки.
Это один из самых болезненных, дорогих и неприятных вариантов архитектуры в современной веб-разработке.
Распределённый монолит — худшее из двух миров
При таком подходе компания несёт расходы на микросервисную инфраструктуру, но не получает ожидаемой независимости компонентов.
- › постоянные сетевые вызовы между узлами вместо быстрой связи в памяти;
- › сложные изолированные деплои и версионирование контрактов;
- › необходимость настраивать мониторинг и распределённую трассировку;
- › управление распределёнными очередями сообщений и брокерами;
- › содержание избыточной и сложной серверной инфраструктуры;
- › риск каскадных отказов: недоступность одного компонента может вызвать тайм-ауты, накопление запросов и перегрузку зависимых сервисов;
- › крайне долгая, запутанная и дорогая диагностика возникающих ошибок.
И самое критичное: при наличии всей этой технической обвязки, реальной доменной независимости, ради которой всё это изначально создавалось, у компонентов практически нет.
Поэтому хороший, правильный микросервис — это не просто случайный кусок программного кода, искусственно вынесенный в отдельный Docker-контейнер. У него обязана присутствовать весомая и реальная причина существовать автономно:
- › изолированный, собственный жизненный цикл;
- › выделенная под этот домен отдельная инженерная команда;
- › специфическая, асимметричная нагрузка на бэкенд;
- › потребность в точечном независимом масштабировании;
- › уникальные, повышенные требования к отказоустойчивости узла;
- › полностью самостоятельная бизнес-ответственность направления.
Если у выделяемого компонента нет убедительной причины для автономного развития, независимого масштабирования или отдельного управления надёжностью, его преждевременное выделение в сервис может добавить больше эксплуатационных затрат, чем практической пользы. В таком случае разумнее сохранить его модулем внутри приложения и пересмотреть границы при появлении подтверждённых потребностей.
Когда монолит выглядит разумнее
Монолитная архитектура часто подходит для систем со следующими характеристиками:
- › информационная система создаётся с полного нуля (Greenfield);
- › штатная команда внутренней разработки относительно небольшая;
- › базовая бизнес-логика и сущности ещё активно и часто меняются;
- › количество активных пользователей не измеряется миллионами;
- › входящая нагрузка на серверы относительно предсказуема;
- › подавляющее большинство функций и таблиц тесно логически связано между собой;
- › нет необходимости независимо масштабировать отдельные компоненты;
- › ИТ-инфраструктуру желательно сделать простой и недорогой в сопровождении.
Особенно остро это актуально для внутренних корпоративных систем автоматизации.
Например, если крупной компании требуется собственная закрытая система оперативной обработки заявок, специализированное рабочее место диспетчера, личный кабинет сотрудников, цифровые документы и всего несколько внешних интеграций, совершенно необязательно и вредно искусственно начинать проектирование с пятнадцати микросервисов.
Грамотно спроектированный модульный монолит в такой ситуации часто позволяет решить бизнес-задачу быстрее и с меньшими затратами на разработку и эксплуатацию, чем преждевременный переход к множеству микросервисов.
А когда микросервисы действительно оправданы?
Здесь уже совершенно другая история. Микросервисная архитектура приобретает практический смысл тогда, когда система объективно переросла рамки одного приложения.
- › разные крупные части платформы развиваются и выпускаются независимо друг от друга;
- › в проекте задействовано несколько отдельных, изолированных инженерных команд;
- › функциональные компоненты испытывают существенно разную по характеру нагрузку;
- › отдельные высоконагруженные части необходимо масштабировать точечно и независимо;
- › к разным узлам предъявляются принципиально несвязанные требования к доступности (SLA);
- › изолированные компоненты имеют свой собственный, обособленный жизненный цикл;
- › система одновременно разворачивается и работает в нескольких независимых инфраструктурных контурах;
- › отказ отдельного компонента не должен приводить к остановке всей платформы, если остальные функции могут работать без него; для этого необходимы предусмотренные архитектурой изоляция сбоев, тайм-ауты и механизмы деградации функциональности.
При оценке целесообразности важен далеко не сам физический размер кодовой базы:
— намного важнее реальная организационная и техническая сложность системы.
Именно поэтому стабильное работающее приложение на миллион строк кода может долгие годы оставаться вполне нормальным, чистым модульным монолитом. А в другой ситуации — относительно небольшая по коду, но сильно фрагментированная платформа уже на старте требует изолированного сервисного разделения.
Есть и третий вариант
Между крайностями «всё в одном» и «десятки микросервисов» существует вполне здравый и прагматичный промежуточный подход.
Речь идет о концепции модульного монолита. Внешне на уровне инфраструктуры это остается одним единым приложением. При этом кодовая база разделена на модули с определёнными границами ответственности:
- › Такой подход позволяет сохранить сравнительно простую эксплуатацию единого приложения и при этом поддерживать чёткие границы ответственности между модулями. Для надёжности и доступности приложение при необходимости можно запускать в нескольких экземплярах, не отказываясь от модульной структуры.
- › Если со временем отдельному модулю потребуется независимое масштабирование или выпуск обновлений, его можно будет выделить в отдельный сервис.
То есть ИТ-архитектура предприятия получает возможность плавно и предсказуемо эволюционировать вместе с ростом реальных потребностей самой системы.
Архитектуру нужно выбирать по реальным ограничениям
Перед тем как принимать поспешное решение в плоскости «монолит или микросервисы», гораздо полезнее дать честные ответы на базовые вопросы:
- › Кто будет развивать систему?
Это будет делать одна небольшая команда из пяти человек или над платформой параллельно разворачивается работа двадцати независимых команд? - › Что именно будет масштабироваться?
Вся кодовая база и сервисы нагружаются примерно одинаково или один конкретный компонент забирает на себя 95% всей входящей нагрузки? - › Насколько независимы бизнес-функции?
Можно ли физически и безболезненно отделить один бизнес-процесс от другого или они намертво связаны единой сквозной СУБД-транзакцией? - › Что произойдёт при отказе одного компонента?
Является ли это критичным для всего ландшафта или вполне допустимо, чтобы система продолжала стабильно функционировать частично? - › Насколько сложной может быть эксплуатация?
Есть ли в штате выделенная команда, способная профессионально заниматься распределённым мониторингом, логированием, инфраструктурой и трассировкой сбоев? - › Что произойдёт с продуктом через два года?
Это самый важный вопрос проектирования, поскольку выбранная архитектура обязана учитывать не только текущую конфигурацию, но и разумный сценарий её долгосрочного развития.
Самая дорогая архитектура — не обязательно самая сложная
Иногда компании думают, что действительно серьёзная система обязательно должна выглядеть технически перегруженной.
На архитектурной диаграмме для презентаций всё это выглядит крайне впечатляюще:
- › множество изолированных сервисов;
- › десятки контейнеров;
- › распределённые очереди сообщений;
- › несколько независимых баз данных;
- › отдельные прокси-шлюзы API Gateway;
- › перегруженная схема инфраструктуры.
Но если исходная бизнес-задача спокойно решается одним хорошо спроектированным приложением, вся эта конструкция мгновенно становится чистым дополнительным расходом компании.
Каждый искусственно добавленный элемент влечёт за собой долгосрочные обязательства: инфраструктуру необходимо непрерывно обслуживать, возникающие ошибки — долго искать по логам, сервисы — версионировать и обновлять, данные — реплицировать и синхронизировать, а сетевые коммуникации — постоянно мониторить.
- › **У каждого элемента архитектуры должно быть обоснование: какую задачу он решает и какие преимущества даёт.**
- › Не потому, что «так сейчас принято» в индустрии, не потому, что об этом написано в очередной статье на Хабре, и не потому, что слово «микросервисы» на текущий момент звучит более современно для руководства.
Что мы обычно считаем правильным подходом
При разработке и аудите корпоративных систем мы начинаем с анализа требований, а не с выбора архитектурного шаблона.
Сначала мы анализируем бизнес-процесс:
- › какие типы и массивы данных физически существуют в компании;
- › какие именно операции ежедневно выполняются пользователями и кодом;
- › какие именно системы должны нативно обмениваться информацией;
- › на каких участках критически необходима мгновенная синхронная работа;
- › где технически и логически допустима асинхронная очередь сообщений;
- › что обязано продолжать работать при аварийном отказе отдельного компонента;
- › какие конкретно части системы будут меняться и дорабатываться чаще остальных.
После анализа требований определяются границы компонентов системы:
- › Иногда оптимальным результатом становится классический монолит.
- › Иногда — модульный монолит со штучными внешними сервисами под узкие задачи.
- › Иногда проекту действительно необходима полноценная микросервисная архитектура.
> Архитектура обязана обслуживать систему, а не система — обслуживать архитектуру. И, пожалуй, это главное незыблемое инженерное правило.
Вывод
Монолит не является заведомо плохой архитектурой. Он предсказуемо выигрывает простотой взаимодействия компонентов, высокой скоростью разработки и относительной дешевизной эксплуатации.
Микросервисы не являются автоматически хорошей архитектурой. Они дают независимость релизов, гибкое масштабирование и возможность разделить огромную систему между изолированными командами.
- › Независимость сервисов требует дополнительных затрат на сетевое взаимодействие, мониторинг, отказоустойчивость, согласование данных и диагностику ошибок.
Поэтому зрелый архитектурный вопрос обязан стоять не в плоскости:
— «Что лучше — монолит или микросервисы?»
А в плоскости:
— «Какую степень технической сложности наша ИТ-служба действительно готова себе позволить?»
- › Если система небольшая или средняя — не нужно искусственно и насильно делать её распределённой на серверах.
- › Если система объективно большая — не нужно пытаться удержать все процессы внутри одного монолитного приложения только лишь ради мнимой простоты.
- › Архитектуру следует выбирать с учётом сложности системы, масштаба бизнеса и возможностей команды сопровождать инфраструктуру.
Когда системе нужно масштабирование
Почему «просто добавить функцию» иногда означает переделать полсистемы
Как объединить несколько систем в один контур
Все инженерные материалы и экспертные статьи
Полный алфавитный справочник ИТ-терминов