Монолит или микросервисы?

 

 

 

АРХИТЕКТУРА // ARCHITECTURAL_CHOICE

МЕЖДУ ДВУХ ПОДХОДОВ

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

Когда компания начинает разработку новой системы, вопрос архитектуры часто звучит почти автоматически:

[ ARCHITECTURE_QUESTION ]
«Делаем монолит или сразу микросервисы?»

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

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

МОНОЛИТЕдиный контексти общая памятьСЕРВИС АСЕРВИС БМИКРОСЕРВИСЫ
СРАВНЕНИЕ // ARCHITECTURAL_SPECTRUM
  • › Для небольшой или средней системы хороший структурированный монолит нередко оказывается значительно более разумным и экономным решением, чем десятки отдельных распределённых сервисов.
  • › Для большой платформы попытка искусственно удержать все бизнес-процессы в рамках одного приложения может, наоборот, превратиться в серьёзное инфраструктурное ограничение.
КРИТЕРИИ_ВЫБОРА // REAL_METRICS

Поэтому архитектуру имеет смысл выбирать не по текущей моде и не по красивой абстрактной схеме на презентации. Необходимо детально оценивать следующие факторы:

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

 

АРХИТЕКТУРА // TYPICAL_MONOLITH

Сначала представим обычную систему

Допустим, компания заказывает разработку собственной информационной системы.

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

ПользователиПРИЛОЖЕНИЕ (Условный монолит)· заявки· пользователи· документы· отчёты· бизнес-логика· интеграцииБАЗА ДАННЫХ

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

РАЗБОР_ЗАБЛУЖДЕНИЙ // MONOLITH_MISCONCEPTIONS
  • › Услышав термин «монолит», многие представляют устаревшую программу, которую сложно сопровождать и масштабировать.
  • › Но монолитная архитектура сама по себе ничего подобного не означает. Хорошо спроектированный монолит состоит из модулей с понятными границами ответственности и организованной кодовой базой.
КРИТИЧЕСКИЙ_ЛОКАЛЬНЫЙ_СБОЙ // MODULAR_DEGRADATION

Инженерная деградация проекта начинается далеко не тогда, когда ядро приложения классифицируется как монолит:

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

 

АРХИТЕКТУРА // MICROSERVICES_TRANSITION

А что меняется с микросервисами?

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

ПользовательAPI / GatewayЗаявкиService[ DB ]ПользователиService[ DB ]ДокументыService[ DB ]Очередь / брокер

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

ИНФРАСТРУКТУРНАЯ_ПЛАТА // ARCHITECTURAL_TAX

Но вместе с независимостью в архитектуре неизбежно появляется кое-что ещё:

> При этом появляются дополнительные компоненты инфраструктуры, которые нужно настраивать и сопровождать.

 

ОБВЯЗКА // DISTRIBUTED_OVERHEAD

Микросервисы добавляют не только возможности

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

РИСКИ_ОБМЕНА // NETWORK_DEPENDENCIES
  • › В ландшафте появляются постоянные сетевые взаимодействия;
  • › Один сервис вынужден постоянно вызывать по API другой;
  • › Целевой компонент системы может быть временно недоступен;
  • › Любой межсервисный запрос может завершиться сетевой ошибкой;
  • › Асинхронное сообщение рискует зависнуть или застрять в очереди;
  • › Одна простая бизнес-операция затрагивает несколько сервисов сразу.

При этом возникает другой архитектурный вопрос:

— «Как разбить монолитное приложение на несколько изолированных частей?»

Вопрос переходит на следующий уровень:

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

Это усложняет разработку, диагностику и эксплуатацию системы.

 

ПРАКТИКА // MONOLITH_BENEFITS

Монолит проще — но не всегда

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

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

ОПТИМИЗАЦИЯ // REDUCED_COMPLEXITY
  • › Не нужно формировать сетевой запрос и сериализовать данные для передачи по сети.
  • › Не нужно думать о таймаутах на транспортном уровне.
  • › Не нужно решать сложную задачу изоляции сбоев при недоступности второго сервиса.
  • › Не нужен отдельный кастомный механизм повторных запросов (retries).
  • › Не требуется сквозная распределённая трассировка (tracing) только ради того, чтобы понять, в каком именно месте сети потерялся вызов метода.
МАСШТАБ // КОМАНДНЫЙ_КОНТЕКСТ
  • › Для системы, которую поддерживает одна команда и используют несколько сотен или тысяч сотрудников, это упрощает разработку и сопровождение.
  • › При таком раскладе разработчики тратят драгоценное рабочее время не на инфраструктурное обслуживание распределенной сложной архитектуры, а на прямое развитие продуктовых функций бизнеса.

 

ОГРАНИЧЕНИЯ // SCALABILITY_LIMITS

Но у монолита тоже есть предел

Представим другую архитектурную ситуацию, характерную для крупной компании.

Несколько независимых продуктовых команд одновременно и параллельно развивают совершенно разные функциональные направления единой платформы:

НАПРАВЛЕНИЯ // PLATFORM_DOMAINS
  • › отдельно развивается биллинг;
  • › отдельно — товарный каталог;
  • › отдельно — складская логистика;
  • › отдельно — сервис авторизации;
  • › отдельно — сквозная аналитика.

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

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

ПЛАТФОРМАКАТАЛОГ10 инстансов[DB]ЛОГИСТИКА4 инстанса[DB]БИЛЛИНГ2 инстанса[DB]
РЕЗУЛЬТАТ // TARGETED_SCALING
  • › Распределение изолированных компонентов по самостоятельным сервисам начинает приносить реальную пользу бизнесу: каждый сервис можно масштабировать с учётом его нагрузки.

В таких условиях микросервисная архитектура позволяет независимо масштабировать компоненты с разной нагрузкой.

 

ЭКСПЛУАТАЦИЯ // OPERATIONAL_COMPLEXITY

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

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

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

  • › Если у вас один сервер приложения: Локализовать, воспроизвести и оперативно разобраться с возникшей технической проблемой в кодовой базе относительно просто.
  • › Если у вас двадцать сервисов: Развернута асинхронная очередь сообщений, несколько разнородных баз данных, API Gateway, балансировщики нагрузок и десятки скрытых сетевых взаимодействий — банальный поиск первопричины ошибки превращается в отдельную комплексную задачу.
ПользовательGatewayService AService BQueueService CDatabase ✘результат ✘

На интерфейсе конечный пользователь видит лишь сухую абстрактную плашку:

[ UI_ERROR ] > «Не удалось выполнить операцию».

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

ТРАССИРОВКА // DISTRIBUTED_DIAGNOSTICS
  • › дошёл ли исходный HTTP-запрос от клиента до API Gateway;
  • › успешно ли Gateway проксировал и передал его сервису A;
  • › смог ли сервис A корректно и без таймаутов вызвать B;
  • › успел ли сервис B успешно записать событие в брокер;
  • › приняла ли асинхронная очередь это сообщение без потерь;
  • › вычитал ли и получил ли сервис C данную задачу;
  • › была ли целевая база данных доступна в момент транзакции;
  • › была ли операция отклонена проверкой бизнес-правил;
  • › критическая ошибка произошла сразу или после серии повторных автоматических попыток (retries).

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

 

ДАННЫЕ // DATA_ISOLATION_LIMITS

Есть ещё одна важная вещь — данные

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

[ Общая БД в Монолите ]

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

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

[ Изоляция в Микросервисах ]

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

➔ Если сервисы используют отдельные базы данных, обычный SQL JOIN между их таблицами, как правило, недоступен напрямую в рамках одного запроса к одной СУБД. Межсистемное объединение данных возможно через федеративные запросы, специальные инструменты интеграции или предварительно подготовленные аналитические наборы, но эти подходы требуют дополнительных механизмов и не заменяют автоматически транзакции внутри одной базы.

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

ИНСТРУМЕНТЫ_ОБМЕНА // INTER_SERVICE_COMMUNICATION
  • › программные вызовы межсервисных API;
  • › асинхронные бизнес-события;
  • › распределённые очереди сообщений;
  • › фоновые трансляторы и репликаторы;
  • › механизмы согласования данных между сервисами, в том числе модель согласованности в конечном счёте (eventual consistency), если она допустима для конкретного бизнес-процесса.
ЗАКОН_СОХРАНЕНИЯ_СЛОЖНОСТИ // COMPLEXITY_CONSERVATION
  • › Микросервисы не устраняют инженерную сложность автоматически: они меняют её распределение между компонентами системы.
  • › Часть сложности переносится на уровень сетевого взаимодействия, согласованности данных, наблюдаемости и эксплуатации. При удачном разделении доменов это может упростить развитие отдельных компонентов и работу независимых команд, но общие затраты необходимо оценивать для всей системы.

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

 

ПРОЕКТИРОВАНИЕ // PREMATURE_DISTRIBUTION

Почему «сразу микросервисы» часто оказывается ошибкой

При планировании ИТ-системы иногда исходят из следующей логики:

[ FALSE_ARCH_PARADIGM ]
«Мы планируем большую и нагруженную систему, поэтому сразу построим её на микросервисах. Так её потом будет намного проще масштабировать».

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

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

Сервис AСервис BСервис CСервис Dциклическая зависимость транзакций⚠️ РАСПРЕДЕЛËННЫЙ МОНОЛИТ
АНАЛИЗ_СБОЯ // COUPLING_ANTI_PATTERN
  • › В результате такой поспешной декомпозиции получается не набор независимых, слабосвязанных модулей, а **тяжёлый распределённый монолит**. Только теперь его куски искусственно разнесены по разным физическим серверам.
  • › Формально приложения разделены на отдельные сервисы, но фактически остаются тесно связанными: выполнение одной бизнес-операции требует последовательных синхронных вызовов нескольких компонентов. Из-за этого задержка или отказ одного сервиса может нарушить работу всей цепочки.

Это один из самых болезненных, дорогих и неприятных вариантов архитектуры в современной веб-разработке.

 

АНТИПАТТЕРН // ARCHITECTURAL_DEAD_END

Распределённый монолит — худшее из двух миров

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

ПОЛНЫЙ_СТЕК_ПРОБЛЕМ // OVERHEAD_MANIFEST
  • › постоянные сетевые вызовы между узлами вместо быстрой связи в памяти;
  • › сложные изолированные деплои и версионирование контрактов;
  • › необходимость настраивать мониторинг и распределённую трассировку;
  • › управление распределёнными очередями сообщений и брокерами;
  • › содержание избыточной и сложной серверной инфраструктуры;
  • › риск каскадных отказов: недоступность одного компонента может вызвать тайм-ауты, накопление запросов и перегрузку зависимых сервисов;
  • › крайне долгая, запутанная и дорогая диагностика возникающих ошибок.

И самое критичное: при наличии всей этой технической обвязки, реальной доменной независимости, ради которой всё это изначально создавалось, у компонентов практически нет.

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

ОБОСНОВАНИЕ_ВЫДЕЛЕНИЯ // VALID_MICROSERVICE_DRIVERS
  • › изолированный, собственный жизненный цикл;
  • › выделенная под этот домен отдельная инженерная команда;
  • › специфическая, асимметричная нагрузка на бэкенд;
  • › потребность в точечном независимом масштабировании;
  • › уникальные, повышенные требования к отказоустойчивости узла;
  • › полностью самостоятельная бизнес-ответственность направления.

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

 

ПРИМЕНИМОСТЬ // MONOLITH_VALID_CASES

Когда монолит выглядит разумнее

Монолитная архитектура часто подходит для систем со следующими характеристиками:

КРИТЕРИИ // RATIO_CHECK
  • › информационная система создаётся с полного нуля (Greenfield);
  • › штатная команда внутренней разработки относительно небольшая;
  • › базовая бизнес-логика и сущности ещё активно и часто меняются;
  • › количество активных пользователей не измеряется миллионами;
  • › входящая нагрузка на серверы относительно предсказуема;
  • › подавляющее большинство функций и таблиц тесно логически связано между собой;
  • › нет необходимости независимо масштабировать отдельные компоненты;
  • › ИТ-инфраструктуру желательно сделать простой и недорогой в сопровождении.
ПРИМЕР // ENTERPRISE_INTERNAL_SYSTEMS

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

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

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

 

ПРИМЕНИМОСТЬ // MICROSERVICES_VALID_CASES

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

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

КРИТЕРИИ // ARCHITECTURAL_TRIGGERS
  • › разные крупные части платформы развиваются и выпускаются независимо друг от друга;
  • › в проекте задействовано несколько отдельных, изолированных инженерных команд;
  • › функциональные компоненты испытывают существенно разную по характеру нагрузку;
  • › отдельные высоконагруженные части необходимо масштабировать точечно и независимо;
  • › к разным узлам предъявляются принципиально несвязанные требования к доступности (SLA);
  • › изолированные компоненты имеют свой собственный, обособленный жизненный цикл;
  • › система одновременно разворачивается и работает в нескольких независимых инфраструктурных контурах;
  • › отказ отдельного компонента не должен приводить к остановке всей платформы, если остальные функции могут работать без него; для этого необходимы предусмотренные архитектурой изоляция сбоев, тайм-ауты и механизмы деградации функциональности.
МЕТРИКА_СЛОЖНОСТИ // COMPLEXITY_VS_VOLUME

При оценке целесообразности важен далеко не сам физический размер кодовой базы:

— намного важнее реальная организационная и техническая сложность системы.

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

 

АРХИТЕКТУРА // MODULAR_MONOLITH_PATTERNS

Есть и третий вариант

Между крайностями «всё в одном» и «десятки микросервисов» существует вполне здравый и прагматичный промежуточный подход.

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

APPLICATION_COREЗаявкиКлиентыДокументыОтчётыПлатежиИнтеграцииDatabase
РАЦИОНАЛЬНОСТЬ // BALANCED_ARCHITECTURE
  • › Такой подход позволяет сохранить сравнительно простую эксплуатацию единого приложения и при этом поддерживать чёткие границы ответственности между модулями. Для надёжности и доступности приложение при необходимости можно запускать в нескольких экземплярах, не отказываясь от модульной структуры.
  • › Если со временем отдельному модулю потребуется независимое масштабирование или выпуск обновлений, его можно будет выделить в отдельный сервис.

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

 

ПРОЕКТИРОВАНИЕ // REAL_CONSTRAINTS

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

Перед тем как принимать поспешное решение в плоскости «монолит или микросервисы», гораздо полезнее дать честные ответы на базовые вопросы:

АУДИТ_ОГРАНИЧЕНИЙ // ARCHITECTURAL_QUESTIONS
  • › Кто будет развивать систему?
    Это будет делать одна небольшая команда из пяти человек или над платформой параллельно разворачивается работа двадцати независимых команд?
  • › Что именно будет масштабироваться?
    Вся кодовая база и сервисы нагружаются примерно одинаково или один конкретный компонент забирает на себя 95% всей входящей нагрузки?
  • › Насколько независимы бизнес-функции?
    Можно ли физически и безболезненно отделить один бизнес-процесс от другого или они намертво связаны единой сквозной СУБД-транзакцией?
  • › Что произойдёт при отказе одного компонента?
    Является ли это критичным для всего ландшафта или вполне допустимо, чтобы система продолжала стабильно функционировать частично?
  • › Насколько сложной может быть эксплуатация?
    Есть ли в штате выделенная команда, способная профессионально заниматься распределённым мониторингом, логированием, инфраструктурой и трассировкой сбоев?
  • › Что произойдёт с продуктом через два года?
    Это самый важный вопрос проектирования, поскольку выбранная архитектура обязана учитывать не только текущую конфигурацию, но и разумный сценарий её долгосрочного развития.

 

ЭКОНОМИКА // ARCHITECTURAL_COSTS

Самая дорогая архитектура — не обязательно самая сложная

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

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

СТЕК_УСЛОЖНЕНИЙ // INFRASTRUCTURE_OVERHEAD
  • › множество изолированных сервисов;
  • › десятки контейнеров;
  • › распределённые очереди сообщений;
  • › несколько независимых баз данных;
  • › отдельные прокси-шлюзы API Gateway;
  • › перегруженная схема инфраструктуры.

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

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

АКСИОМА_ПРОЕКТИРОВАНИЯ // REASON_TO_EXIST
  • › **У каждого элемента архитектуры должно быть обоснование: какую задачу он решает и какие преимущества даёт.**
  • › Не потому, что «так сейчас принято» в индустрии, не потому, что об этом написано в очередной статье на Хабре, и не потому, что слово «микросервисы» на текущий момент звучит более современно для руководства.

 

ИТОГ // ARCHITECTURAL_METRICS

Что мы обычно считаем правильным подходом

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

Сначала мы анализируем бизнес-процесс:

АНАЛИЗ_КОНТУРА // SYSTEM_ANALYSIS_CHECKLIST
  • › какие типы и массивы данных физически существуют в компании;
  • › какие именно операции ежедневно выполняются пользователями и кодом;
  • › какие именно системы должны нативно обмениваться информацией;
  • › на каких участках критически необходима мгновенная синхронная работа;
  • › где технически и логически допустима асинхронная очередь сообщений;
  • › что обязано продолжать работать при аварийном отказе отдельного компонента;
  • › какие конкретно части системы будут меняться и дорабатываться чаще остальных.

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

ВАРИАНТЫ_РЕШЕНИЙ // ARCHITECTURAL_OUTPUTS
  • › Иногда оптимальным результатом становится классический монолит.
  • › Иногда — модульный монолит со штучными внешними сервисами под узкие задачи.
  • › Иногда проекту действительно необходима полноценная микросервисная архитектура.
ГЛАВНАЯ_ДОГМА // THE_CORE_RULE

> Архитектура обязана обслуживать систему, а не система — обслуживать архитектуру. И, пожалуй, это главное незыблемое инженерное правило.

 

РЕЗЮМЕ // CONCLUSION_SUMMARY

Вывод

[ MONOLITH_STATUS ]

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

[ MICROSERVICES_STATUS ]

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

ИНФРАСТРУКТУРНАЯ_ЦЕНА // DECENTRALIZATION_TAX
  • › Независимость сервисов требует дополнительных затрат на сетевое взаимодействие, мониторинг, отказоустойчивость, согласование данных и диагностику ошибок.

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

— «Что лучше — монолит или микросервисы?»

А в плоскости:

— «Какую степень технической сложности наша ИТ-служба действительно готова себе позволить?»

СТРАТЕГИЯ // ARCHITECTURAL_PRAGMATISM
  • › Если система небольшая или средняя — не нужно искусственно и насильно делать её распределённой на серверах.
  • › Если система объективно большая — не нужно пытаться удержать все процессы внутри одного монолитного приложения только лишь ради мнимой простоты.
ДИАГНОЗ // ARCHITECTURAL_FIT
  • › Архитектуру следует выбирать с учётом сложности системы, масштаба бизнеса и возможностей команды сопровождать инфраструктуру.

 

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

Когда системе нужно масштабирование

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

Почему «просто добавить функцию» иногда означает переделать полсистемы

 
[ Модуль // АРХИТЕКТУРА ]

Как объединить несколько систем в один контур

 
[ EXPERTISE JOURNAL ]

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

 
[ CORE GLOSSARY ]

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

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