Монолит или микросервисы: что действительно нужно вашему бизнесу
Архитектуру часто обсуждают так, будто есть «современные» и «устаревшие» подходы. Монолит — старый. Микросервисы — современно. На практике всё сложнее. Монолит может быть отличным решением для продукта с десятками тыс…
Архитектуру часто обсуждают так, будто есть «современные» и «устаревшие» подходы. Монолит — старый. Микросервисы — современно. На практике всё сложнее. Монолит может быть отличным решением для продукта с десятками тысяч пользователей. А микросервисная архитектура может сделать молодой проект дороже, медленнее и сложнее без какой-либо бизнес-выгоды. Поэтому правильный вопрос звучит не: Что технологичнее? А: Какая архитектура соответствует масштабу нашей проблемы? Именно здесь начинается зрелое инженерное решение. Большинству молодых проектов микросервисы не нужны
Это полезный тезис, потому что микросервисы часто выбирают слишком рано. Команда только запускает продукт. Пользователей немного. Бизнес-логика ещё меняется каждую неделю. Но архитектура уже состоит из:
- нескольких сервисов;
- message broker;
- API gateway;
- service discovery;
- распределённого logging;
- отдельных deployment pipelines.
В результате команда начинает обслуживать инфраструктуру раньше, чем у неё появилась проблема, которую эта инфраструктура должна решать. Микросервисы могут быть очень полезны. Но только когда возникают реальные причины платить за их сложность. Что такое монолит Монолит — это приложение, в котором основные части системы разворачиваются вместе как единый продукт. Например, в одном приложении могут находиться:
- пользователи;
- каталог;
- заказы;
- CRM;
- CMS;
- аналитика;
- административная панель.
Это не означает, что код обязательно должен быть хаотичным. Хороший монолит может быть модульным. Например: users orders payments content analytics Каждый модуль имеет свои границы, но приложение остаётся единым с точки зрения deployment. Это важное различие. Монолит — не синоним плохой архитектуры. Почему монолит часто выигрывает на старте У монолита есть несколько практических преимуществ.
Проще разработка
Разработчику проще поднять один проект локально. Не нужно запускать десять сервисов, брокер сообщений, gateway и несколько баз данных. Это снижает порог входа в проект. Особенно для небольшой команды.
Проще deployment
У монолита обычно один pipeline. Собрали. Протестировали. Задеплоили. Если сервисов десять, появляется десять независимых release-процессов. Это полезно при определённом масштабе. Но на раннем этапе это дополнительная сложность.
Проще debugging
Ошибка произошла внутри одного приложения. Логи находятся рядом. Стек вызовов понятнее. Можно пройти путь запроса от начала до конца. В распределённой системе один пользовательский запрос может пройти через пять сервисов. Тогда debugging уже требует:
- correlation ID;
- distributed tracing;
- централизованных logs.
Меньше infrastructure cost
Монолиту обычно нужно меньше инфраструктуры. Не требуется отдельно поддерживать:
- service discovery;
- mesh;
- множество containers;
- отдельные pipelines;
- сложный monitoring.
Для небольшого бизнеса это напрямую означает меньшую стоимость владения. Монолит быстрее меняется на раннем этапе Это особенно важно для MVP. На ранней стадии продукта бизнес ещё выясняет:
- что действительно нужно клиенту;
- какие функции важны;
- какие процессы стоит автоматизировать;
- какие сущности вообще должны существовать.
Архитектура тоже меняется. В монолите изменить связь между двумя модулями обычно проще. В микросервисах это может потребовать:
- новый API contract;
- migration;
- versioning;
- обновление нескольких сервисов;
- coordination deployment.
Когда предметная область ещё нестабильна, такая архитектурная жёсткость может мешать развитию. Что микросервисы дают взамен Если микросервисы сложнее, зачем они вообще нужны? Потому что при определённом масштабе они решают реальные проблемы. Главное преимущество — независимость частей системы. Например: Payments можно обновлять отдельно от: Catalog А: Search можно масштабировать отдельно от: CRM Система начинает состоять из самостоятельных сервисов со своими обязанностями. Это полезно, когда единый deployment уже становится ограничением.
Когда появляются реальные причины для microservices Есть несколько признаков, что архитектура действительно начинает перерастать монолит. 1. Разные части системы масштабируются независимо Представим ecommerce. Большую часть времени нагрузка распределена относительно равномерно. Но поиск получает: 10 000 запросов в минуту. Панель администратора: 100 запросов в минуту. Если всё находится в одном приложении, приходится масштабировать целиком весь монолит. Даже если узкое место только в search. При микросервисной архитектуре можно отдельно увеличить количество экземпляров Search Service.
Это уже реальная экономическая причина. 2. Несколько независимых команд Пока над продуктом работает пять человек, разделять систему на десять сервисов часто бессмысленно. Но представим организацию:
- команда Payments;
- команда Search;
- команда CRM;
- команда Identity;
- команда Analytics.
У каждой:
- свой roadmap;
- свои релизы;
- своя ответственность.
Если все работают в одном большом приложении, начинают появляться конфликты. Одно изменение блокирует другое. Release calendar становится общим. Тогда сервисные границы могут отражать организационные границы команд. 3. Разные SLA Не все компоненты одинаково критичны. Например: Payment должен иметь очень высокую доступность. А внутренний: Report Generator может быть временно недоступен без серьёзных последствий. Если оба компонента находятся в одной tightly coupled системе, сбой второстепенной функции способен повлиять на критическую.
Разделение сервисов позволяет по-разному проектировать надёжность. Например: Payments:
- отдельный monitoring;
- отдельный scaling;
- отдельная база;
- более строгий SLA.
Reports:
- более простая инфраструктура.
4. Разные технологические требования Иногда отдельной задаче действительно лучше подходит другой инструмент. Например: основной backend работает на Python. Но высоконагруженный streaming-сервис удобнее реализовать на другом стеке. Или: основное приложение работает с PostgreSQL. А search требует специализированного search engine. В монолите такие различия могут усложнить архитектуру. В сервисной модели каждый компонент может использовать наиболее подходящий инструмент. Но это не означает: Каждый сервис должен быть на своём языке.
Технологическое разнообразие тоже увеличивает стоимость поддержки. Оно должно быть оправдано. 5. Требуется независимый deployment Это одна из самых сильных причин. Представим: команда Payments хочет выпустить небольшое исправление. Но весь продукт состоит из одного большого монолита. Для исправления приходится:
- собирать весь проект;
- прогонять весь regression;
- выкатывать весь продукт.
Если релизы становятся дорогими и рискованными, сервисное разделение может помочь. Payments можно выпускать независимо. Это уменьшает blast radius изменения. Что микросервисы делают сложнее Важно смотреть не только на преимущества. Микросервисы создают новые категории проблем. Network становится частью архитектуры В монолите один модуль вызывает другой напрямую. В микросервисах между ними сеть. А сеть может:
- тормозить;
- быть недоступной;
- возвращать timeout;
- дублировать запросы.
То, что раньше было обычным вызовом функции, теперь становится распределённым взаимодействием. Появляется проблема consistency Представим: Order Service создал заказ. Payment Service провёл оплату. CRM Service должен создать клиента. Что произойдёт, если последний сервис временно недоступен? В монолите часть подобных операций можно выполнить внутри одной транзакции. В микросервисах приходится проектировать:
- retries;
- queues;
- eventual consistency;
- idempotency;
- компенсационные операции.
Это уже другой уровень сложности. Deployment становится независимым — но инфраструктура сложнее Фраза: Каждый сервис можно выкатывать отдельно звучит отлично. Но значит также:
- отдельные pipelines;
- версии;
- конфигурации;
- secrets;
- health checks;
- monitoring.
Один deployment стал проще. Управление всей системой — сложнее. Observability становится обязательной В монолите ошибка может иметь один stack trace. В микросервисах запрос идёт: Gateway ↓ Orders ↓ Payments ↓ CRM ↓ Notifications Если пользователь говорит: Заказ оформляется восемь секунд, нужно понять, где потеряно время. Без distributed tracing сделать это сложно. Поэтому вместе с microservices обычно необходимы:
- централизованные logs;
- metrics;
- traces;
- alerts;
- correlation IDs.
Observability перестаёт быть приятным дополнением. Она становится условием нормальной эксплуатации. Infrastructure cost растёт Микросервисная архитектура часто означает больше:
- containers;
- серверов;
- pipelines;
- monitoring;
- storage;
- networking;
- cloud services.
Кроме прямой стоимости инфраструктуры появляется ещё один расход: время команды. Кто-то должен:
- поддерживать Kubernetes;
- разбираться с networking;
- обновлять инфраструктуру;
- расследовать распределённые ошибки.
Поэтому сравнивать нужно не только server bill. Нужно считать Total Cost of Ownership. Микросервисы не исправляют плохую архитектуру автоматически Есть опасная идея: Монолит сложно поддерживать. Давайте разобьём его на микросервисы. Если границы системы не понятны, результатом могут стать: distributed monolith. Формально сервисов много. Но они:
- постоянно вызывают друг друга;
- зависят от общей базы;
- должны релизиться одновременно;
- ломаются вместе.
То есть команда получает всю сложность microservices без их преимуществ. Поэтому перед разделением важно сначала найти правильные domain boundaries. Хороший монолит можно подготовить к будущему разделению Выбор монолита сегодня не означает: Мы навсегда останемся монолитом. Хороший подход — модульный монолит. Например: Users module CRM module Billing module Content module Analytics module Границы существуют уже сейчас. Но deployment пока один. Если через два года Billing действительно понадобится:
- независимо масштабировать;
- отдельно релизить;
- передать другой команде;
его будет проще вынести в отдельный сервис. Это обычно безопаснее, чем начинать с десятков микросервисов «на будущее». Пример: молодой SaaS Представим SaaS с командой из шести человек. Есть:
- users;
- billing;
- tasks;
- documents;
- analytics.
Трафик умеренный. Все разработчики работают над несколькими частями системы. В этой ситуации модульный монолит может быть идеальным выбором. Он даёт:
- быстрые релизы;
- простую разработку;
- понятный debugging;
- низкую infrastructure cost.
Microservices здесь скорее увеличат скорость инфраструктурной работы, а не скорость продукта. Пример: растущая платформа Через несколько лет ситуация изменилась. Есть:
- 15 команд;
- миллионы запросов;
- тяжёлый search;
- отдельный payment domain;
- mobile;
- partners;
- AI;
- разные SLA.
Search масштабируется в десять раз сильнее остальных компонентов. Payment команда выпускает изменения независимо. Analytics использует другую инфраструктуру. Теперь отдельные сервисы начинают иметь экономический смысл. Архитектура изменилась не потому, что microservices стали модными. Изменился масштаб задачи. Сигналы, что монолит пока стоит оставить Не стоит спешить с разделением, если:
- команда небольшая;
- deployment пока не является проблемой;
- нагрузка умеренная;
- части приложения масштабируются одинаково;
- domain boundaries ещё меняются;
- нет ресурсов на сложную observability;
- инфраструктурная команда отсутствует.
В такой ситуации microservices могут просто увеличить TCO. Сигналы, что пора рассматривать выделение сервисов И наоборот, повод появляется, если:
- разные части системы имеют сильно разную нагрузку;
- несколько команд мешают друг другу в одном codebase;
- release одной функции требует полного deployment;
- критические и некритические компоненты имеют разные SLA;
- отдельный домен требует другой инфраструктуры;
- один модуль становится bottleneck;
- сервис можно чётко отделить по бизнес-ответственности.
Важно слово: рассматривать. Не обязательно сразу переписывать весь продукт. Не нужно мигрировать всё сразу Переход к микросервисам может быть постепенным. Например, сначала выделить: Notifications Потом: Search Затем, если есть причина: Payments Остальная система продолжает работать как монолит. Такой подход снижает риск. Команда получает возможность проверить, действительно ли сервисное разделение приносит пользу. Как выбрать первый сервис Хороший кандидат обычно:
- имеет чёткую ответственность;
- слабо связан с остальным кодом;
- имеет собственный профиль нагрузки;
- часто меняется независимо;
- способен иметь собственные данные.
Плохой кандидат: Давайте вынесем половину User-модуля, но оставим таблицы и логику в старом приложении. Так появляется сильная связность через сеть. Монолит против микросервисов в одной таблице КритерийМонолитМикросервисыСтарт разработкиПрощеСложнееЛокальный запускПрощеСложнееDeploymentОдинНесколько независимыхDebuggingОбычно прощеТребует observabilityInfrastructure costНижеВышеНезависимое scalingОграниченоСильная сторонаРабота множества командМожет стать сложнойУдобнее при хороших границахNetwork complexityНизкаяВысокаяConsistencyПрощеСложнееНезависимый technology stackОграниченВозможен
Ни одна колонка не является «победителем». Это разные компромиссы. Архитектура должна решать конкретную проблему Хорошее архитектурное решение должно отвечать на вопрос: Какую проблему бизнеса или разработки мы решаем? Например: Search не выдерживает нагрузку и должен масштабироваться отдельно. Это причина. У всех сейчас микросервисы. Не причина. Или: Payment-команда должна выпускать релизы независимо от основного продукта. Причина. Микросервисная архитектура выглядит современнее в презентации. Не причина. Architecture Decision Record
Полезная практика — фиксировать архитектурные решения. Например: Решение Оставить модульный монолит. Почему Команда 7 человек. Один release cycle. Общая нагрузка. Нет потребности в independent scaling. Когда пересмотреть
- Search > 60% нагрузки;
- появится отдельная payment team;
- deployment станет bottleneck.
Теперь архитектура — не вопрос веры. Есть условия, при которых решение будет пересмотрено. Что дороже: монолит или микросервисы Нельзя ответить без контекста. Для небольшого продукта микросервисы почти наверняка дороже. Для большой платформы слишком связанный монолит может стать значительно дороже из-за:
- медленных release cycles;
- coordination overhead;
- сложного scaling;
- большого blast radius изменений.
Поэтому нужно смотреть на TCO: development infrastructure operations observability support cost of change Архитектура экономична только относительно масштаба бизнеса. Подход VERB В VERB мы не считаем microservices признаком зрелости сами по себе. Зрелость — это способность выбрать минимально достаточную архитектуру. Для одного продукта это может быть: server-rendered monolith Для другого: modular monolith + API Для третьего: несколько выделенных services Для большой платформы: distributed architecture Важно не количество сервисов. Важно, насколько архитектура:
- понятна;
- тестируема;
- наблюдаема;
- экономична;
- масштабируема под реальные требования.
Главный тезис Архитектура должна соответствовать масштабу проблемы, а не моде. Большинству молодых проектов микросервисы не нужны. Хороший монолит даёт:
- более простую разработку;
- более простой deployment;
- более простой debugging;
- меньшую infrastructure cost.
Microservices становятся полезны, когда появляются реальные причины:
- независимое scaling;
- несколько автономных команд;
- разные SLA;
- разные технологические требования;
- independent deployment.
Не раньше. И не позже, если текущая архитектура уже действительно ограничивает бизнес.
Не знаете, нужно ли делить вашу систему на сервисы?
VERB может провести архитектурный аудит и определить:
- где находятся реальные bottlenecks;
- что стоит оставить внутри монолита;
- какие модули уже имеют самостоятельные границы;
- где нужен independent scaling;
- сколько будет стоить дополнительная инфраструктура;
- какая observability понадобится;
- какие сервисы имеет смысл выделять первыми.
На выходе — не рекомендация «перейти на микросервисы» , а карта архитектурных решений с аргументацией и стоимостью компромиссов. Пришлите архитектуру или описание продукта — поможем выбрать сложность, которая действительно нужна вашему бизнесу.