К содержимому
Войти

Python Road Map

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

Микросервисы — это способ собрать систему из нескольких небольших приложений, каждое со своим процессом, своим деплоем и своими данными. Монолит — одно приложение, которое деплоится целиком. Выбор между ними определяет, как команда будет релизить, падать и чинить, поэтому «что такое микросервисы, какие у них плюсы и минусы» — один из самых частых вопросов архитектурной части собеседования Go-разработчика. От кандидата ждут не определения, а цены: что получаешь, чем платишь и когда монолит честно лучше

🧠 Что считается микросервисом

Классическое определение дали Джеймс Льюис и Мартин Фаулер в 2014 году. Если пересказать своими словами, у микросервиса четыре признака:

  • свой процесс — сервис общается с другими по сети: HTTP, gRPC или через брокер
  • независимый деплой — новую версию выкатывают, не трогая соседей и не согласовывая релиз
  • свои данные — к таблицам сервиса ходит только он сам, остальные спрашивают через его API
  • граница по бизнес-возможности — «заказы», «оплата», «склад», а не «слой контроллеров» и «слой базы»

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

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

МонолитМодульный монолитМикросервисы
ДеплойОдин артефактОдин артефактКаждый сервис отдельно
Вызов между частямиФункцияФункция через публичный API модуляСетевой запрос или сообщение
ДанныеОбщая база, любые joinОбщая база, таблицы закреплены за модулямиБаза на сервис
Если упала одна частьПадает всёПадает всёОстальное работает, если так задумано
Транзакция через две частиОбычная begin/commitОбычная begin/commitSaga, outbox, компенсации
Кому подходитНовый продукт, одна командаРастущий продукт, несколько командМного команд, разные требования к нагрузке

💸 Чем платят за микросервисы

Фаулер называет это microservice premium — накладные расходы, которые появляются в первый же день и не зависят от того, нужны ли тебе плюсы. Главная из них — сеть

На Go это легко замерить. Вызов функции занимает 2,5 наносекунды, HTTP-запрос к серверу на том же ноутбуке с переиспользованием соединения — 72 микросекунды, примерно в 30 тысяч раз дольше. Между машинами в дата-центре добавятся настоящая сеть, TLS и сериализация. Если запрос пользователя проходит цепочку из пяти сервисов, это пять таких надбавок и пять мест, где что-то может сломаться

Go · Замер: вызов в процессе против HTTP на localhost

package bench

import (
	"io"
	"net/http"
	"net/http/httptest"
	"testing"
)

//go:noinline
func charge(amount int) int { return amount * 2 }

func BenchmarkInProcess(b *testing.B) {
	for b.Loop() {
		_ = charge(1990)
	}
}

func BenchmarkHTTPLocalhost(b *testing.B) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	}))
	defer srv.Close()
	for b.Loop() {
		resp, err := http.Get(srv.URL)
		if err != nil {
			b.Fatal(err)
		}
		io.Copy(io.Discard, resp.Body)
		resp.Body.Close()
	}
}

Запуск go test -bench . -benchtime 2s на Go 1.27, Apple M-серии: BenchmarkInProcess около 2,5 ns/op, BenchmarkHTTPLocalhost около 72 000 ns/op

Задержка — самая безобидная часть. Остальное дороже:

  1. Частичные отказы. Функция либо вернула результат, либо упала с паникой. Сетевой вызов может не дойти, дойти и не вернуть ответ, вернуть ответ после таймаута. Каждый вызов требует таймаута, ретраев и решения, что делать без ответа. Об этом страница «Таймауты, ретраи и circuit breaker»
  2. Нет общей транзакции. Списать деньги в одном сервисе и создать заказ в другом одной commit нельзя. Появляются saga, outbox и состояние «оплата прошла, заказа ещё нет»
  3. Контракты. Поменять сигнатуру функции в монолите — рефакторинг на полчаса, компилятор найдёт всех вызывающих. Поменять поле в API сервиса — версия контракта, период совместимости и договорённость с командой-потребителем
  4. Наблюдаемость. Ошибка пользователя размазана по пяти сервисам и пяти лентам логов. Без сквозного trace id и распределённой трассировки её не найти
  5. Инфраструктура. Каждому сервису нужен CI, деплой, мониторинг, алерты, секреты и дежурный, который понимает, что это за сервис

Взамен получаешь то, чего монолит не даёт:

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

Последний пункт часто решающий. Закон Конвея (1968) говорит, что структура системы повторяет структуру коммуникаций в организации. Пока команда одна и сидит в одном чате, границы сервисов ничего ей не дают. Когда команд десять, общий монолит превращается в очередь на релиз и в споры, чей тест сломал сборку

🧱 Модульный монолит

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

Так сделал Shopify. Их приложение на Rails — одна из крупнейших кодовых баз на этом фреймворке, за десять с лишним лет над ним поработали больше тысячи разработчиков. К 2016 году правка в налогах ломала тесты расчёта доставки, а новичку приходилось изучать полкода, прежде чем выпустить фичу. В 2017 году они начали делить код без распила на сервисы: разложили около 6 тысяч классов по компонентам вроде «заказы», «доставка», «биллинг» и написали инструмент Wedge, который на CI ищет вызовы в обход публичного API компонента

В Go границы модуля держит сам компилятор. Пакет внутри каталога internal может импортировать только код из родительского каталога, поэтому чужой модуль до него не дотянется:

shop/
  cmd/shop/main.go       // собирает модули вместе
  orders/
    orders.go            // публичный API: orders.Service, orders.Payer
    internal/store/      // хранилище заказов, снаружи не видно
  billing/
    billing.go           // billing.Service с методом Charge

Если billing попробует импортировать хранилище заказов, сборка упадёт с use of internal package shop/orders/internal/store not allowed

Go · Модуль заказов зависит от оплаты через свой интерфейс

package orders

import (
	"context"
	"fmt"

	"shop/orders/internal/store"
)

// Payer — то, что модулю заказов нужно от оплаты. Интерфейс объявлен здесь, у потребителя
type Payer interface {
	Charge(ctx context.Context, orderID string, amount int) error
}

type Service struct {
	store *store.Memory
	payer Payer
}

func New(p Payer) *Service { return &Service{store: store.New(), payer: p} }

func (s *Service) Create(ctx context.Context, id string, total int) error {
	if err := s.payer.Charge(ctx, id, total); err != nil {
		return fmt.Errorf("оплата заказа %s: %w", id, err)
	}
	s.store.Save(store.Order{ID: id, Total: total})
	return nil
}

В main.go модуль собирается так: orders.New(billing.Service{}). Если оплату когда-нибудь вынесут в отдельный сервис, в main.go вместо billing.Service{} подставят gRPC-клиент с тем же методом Charge, а код модуля заказов не изменится

Цена модульного монолита в дисциплине. Пока границы держит только договорённость, через год их не будет. Поэтому их проверяет машина: internal в Go, линтер импортов вроде depguard, правило «у каждой таблицы один модуль-владелец»

✂️ Как делить на сервисы

Делят по тому, что делает бизнес, а не по техническим слоям. Сервис «заказы» владеет заказами целиком, от API до таблиц. Сервис «база данных» или «валидация» — признак ошибки: любое изменение фичи затронет их все

Рабочие ориентиры:

  • меняется вместе — живёт вместе. Если две части почти всегда правятся в одной задаче, разнесённые по двум сервисам, они дадут двойной деплой и согласование контракта на каждую задачу
  • граница там, где меняется язык предметной области. В DDD это bounded context: «товар» для каталога означает описание и фото, а для склада место на полке и вес. Это два разных понятия и, скорее всего, два сервиса
  • сервис под одну команду. В microservices.io ориентир — команда «на две пиццы», 6–10 человек, которая выкатывает свой сервис без согласования с другими
  • данные не делятся. Если двум сервисам нужна одна таблица, граница проведена неверно или один из них должен спрашивать другого через API

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

🔙 Когда возвращаются обратно

Обратный переход случается, и о нём полезно знать пару историй

Segment в 2018 году рассказал, как отправку событий в сотню с лишним внешних API они держали в 140 с лишним микросервисах, по репозиторию на каждый. Версии общих библиотек разъехались, обновление означало тестировать и выкатывать десятки сервисов, три инженера почти всё время поддерживали систему на плаву. Они собрали всё в один сервис в одном репозитории. Теперь один инженер выкатывает его за минуты. Заплатили изоляцией отказов: сбой в коде одного партнёра может уронить отправку всем

Prime Video в 2023 году описал сервис мониторинга качества видеопотоков. Распределённая версия на serverless-компонентах упёрлась в предел масштабирования примерно на 5% от ожидаемой нагрузки, а стоимость компонентов на такой нагрузке оказалась неприемлемой. Всё собрали в один процесс внутри одной задачи ECS, и стоимость упала на 90%. Это один сервис внутри большой системы, а не отказ Prime Video от микросервисов. Пример полезен как раз этим: размер сервиса выбирают под конкретную нагрузку

⚠️ Где ошибаются

  • Начинают новый продукт с десятка сервисов. Границы на старте часто проведены неверно, а переносить их между сервисами дороже, чем между пакетами. Фаулер в «Monolith First» пишет, что успешные микросервисные системы обычно вырастали из монолита, который стал слишком большим
  • Общая база на все сервисы. Сервисы деплоятся отдельно, но миграция одной таблицы ломает троих соседей. Это распределённый монолит
  • Цепочки синхронных вызовов. Запрос идёт A → B → C → D, и доступность цепочки равна произведению доступностей. Четыре сервиса по 99,9% дают около 99,6%, то есть почти три часа простоя в месяц вместо 43 минут. Часть таких вызовов лучше заменить событиями, об этом следующая страница «Как сервисы общаются»
  • Делят по слоям. «Сервис пользователей» с CRUD, через который ходят все остальные, становится узким местом и точкой отказа для всей системы
  • Выносят сервис без наблюдаемости. Первый же инцидент превращается в поиск по пяти лентам логов без общего идентификатора запроса

🎯 Вопросы с собеседований

Что такое микросервисная архитектура?

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

Какие плюсы и минусы у микросервисов?

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

Когда монолит лучше микросервисов?

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

Что такое модульный монолит?

Одно приложение с одним деплоем, но код поделён на модули по бизнес-областям. У модуля есть публичный API, остальное скрыто, и каждая таблица принадлежит одному модулю. В Go границы удобно держать через каталоги internal, компилятор не даст импортировать чужие внутренности. Такой монолит потом легче распилить: модуль уже общается с соседями через интерфейс

Как решить, где провести границы сервисов?

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

Что такое распределённый монолит?

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

Как перевести монолит на микросервисы?

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

Как микросервисы связаны с законом Конвея?

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

📚 Что почитать

  • Microservices — статья Льюиса и Фаулера, откуда пошло определение и девять признаков стиля
  • Monolith First — короткий довод, почему новый продукт стоит начинать с монолита
  • Deconstructing the Monolith — как Shopify делал модульный монолит вместо распила
  • Goodbye Microservices — Segment о том, почему 140 сервисов собрали обратно в один и чем за это заплатили