# Чому ви, ймовірно, не повинні використовувати мікросервіси?

<!--category-- Architecture, Microservices, Opinion -->
<datetime class="hidden">2025-12-29T20:00</datetime>

Микросервіси стали по замовчуванню.

Якщо ви хочете звучати "" дорослою "", то маєте на увазі served meshes, event buses, distributed tracking, independent deployability. Якщо хочете виглядати як підприємець, то -, ready, ,, ви малюєте коробки, аж поки діаграма не виглядає як чашка спаґетті, яку хтось кинув на білий стіл,

Але тут - МСК0 - найкоррективніший молодший - МSK1 - не отримують

**Мікросервіси - це не оновлення прикладної архітектури.**

Якщо ви не маєте', то у вас вже немає організаційної болю, яку вони розв 'язують,, а їх рано застосовування не зробить вас майбутнім '

Це не теорійний аргумент. МСК1, МСК2 - це технічна торгівля. МSK3, МSK4 і, як і будь-яка інша торгівля, - МСК5, , - вона має сенс лише тоді, коли ви розумієте, яку подару ви платите, і що ви отримаєте взамін

Я був такою ж винною, як і будь-хто, хто займався "" мікросервисами "", """, не вкорінно усвідомлюючи організаційні витрати, які вони спричиняють. "" МSK3 "". "" Ми легко заплутаємось у словнику і забуваємо, що справжньою проблемою є управління складністю між командами та системами "".

Врешті-решт, ми дійшли до найдавнішої моделі програмного забезпечення: **КISS** - тримай це просто , дурниці МSK2

[TOC]

## Міф про мікросервіси

Мікросервіси продаються як стандартна архітектура, тому що розповідь є спокусливою

* Малі послуги: "чистшийM SK1
* Дистрибовані системи: "модерніM SK1
* Автономія - "бесплатнаM SK1
* Ви можете " масштабувати пізнішеM SK1, тому що ви почали "право"

Цей кадр - назад.

Микросервіси - це не лише структура коду, а й **хто може змінити що, без розмови з ким, і як часто**.

Якщо у вас немає

* Мількома командами
* Конфліктні пріоритети
* Розбіжності у координації
* Заперечення щодо використання
* Об 'єкти права власності

… тоді ви ' не розв 'язуєте організаційної проблеми МSK2 Ви МСК3 купуєте один М СК4

Архітектура має на меті не рухати коробок навколо людей.

## Діаграма, яка повинна бути попереджувальним ярликом

Ви бачили діаграму на LinkedIn, яка рекламує курс Microservices з усіма цими: 'vM SK2 API gateway , асоціація з випадковими кінцевими точками і т.д.

> Примітка: У мене був справжній знімок з нього, але для мене було нестерпним використовувати його, тому це

Це не є "прикладна архітектура для копіювання

Курси часто викладають мікросервіси як діаграми, тому що діаграмі легші, ніж навчання оперативної відповідальності.

Важливим перекресленням є те, що ця діаграма не є об 'єктом **вартість поверхні**.

Кожна коробка - це зобов 'язання

* Час запуску для операції
* Розгортання для управління
* Контракт на версію
* Ви маєте режим провалу
* Розповідь про дзвінок на -, яку ви можете не ігнорувати

стрілки виглядають вражаючими. Вони також приховують реальністьM SK1

Тому що кожен стрілок - ":".

* Тривалість
* Почастий провал
* Переходи
* Перерви
* Прослідкувати поширення контексту
* "Работи на фабриціM SK1 лежить

Якщо архітектура потребує цього на перший день, ви не будуєте продуктM SK1 Ви будуєте платформу.

## Модель прихованої вартості мікросервисів

Як і всі рішення в галузі архітектури, мікросервіси **налог на складність** (гляньте [Гра з кодом: complexity tax](/blog/playing-with-code-efficient-agile). Різниця в тому, що цей налог зростає через кожну межу служби , кожен поміщування МSK2 і кожен режим невдачі

Ці витрати рідко виражені.

### Операційні витрати

Кожна служба хоче:

* Його власний конвеєр
* Його власну конфігурацію
* Його власні спостереження та попередження
* Його власні журналування, панелі керуванняM SK1 runbooks
* Його власній безпеціальний стан ( tajні , authM SK2 вхід)

Якщо команда не може зробити це комфортно, то вона не має мікрослужб. **розподілений моноліт з додатковими кроками**.

### Перемноження тривалості і невдачі

У моноліті, дзвінок є функціонним дзвінком.

У мікросервисах "" МСК0 "", "" МСК1 "", СМС2 "", це переговорний перемир 'я між ":".

* мережі
* Завантаження балансувальників
* TLS
* Auth middleware
* Серіалізація
* Перерви
* Переходи
* Взагальним тиском

Перемноження режимів провалу:

* Один вниз - повільний → потоки вгорі нарощуються
* Відступає збільшувати навантаження → ви politely DDoS себе
* → три сервіси погіршуються " випадково МSK2

Ви більше не розв 'язуєте ошибок't **системи**.

### Налог на серіалізацію про який ніхто не говорить

Тут - це ціна, яку майже ніколи не обговорювали в адвокатстві про мікросервіси. **серіалізація і десеріалізацію (SerDeM SK1 головна**.

Кожна служба має значення:

```csharp
// Monolith: direct object reference
var user = _userService.GetUser(userId);  // < 1μs
var tier = user.Tier;                      // Memory access

// Microservices: serialize → network → deserialize
var json = JsonSerializer.Serialize(user);        // ~50μs for a complex object
var bytes = Encoding.UTF8.GetBytes(json);         // ~10μs
// ... send over network ...
var responseJson = await response.Content.ReadAsStringAsync();  // ~20μs
var user = JsonSerializer.Deserialize<User>(responseJson);      // ~70μs
var tier = user.Tier;                                           // Finally
```

**За один дзвінок – МСК0, що – МSK1, МSK2,μs чистої об 'єму процесора перед тим, як мережа взагалі залучена.**

Тепер помножте це на ланцюг дзвінків

* Заказова служба зниралізує запит (150μsM SK1
* Серіалізація замовлення Запрос на службу користувача (150μsM SK1
* Служба користувачів відієризує запит (150μsM SK1
* Служба користувачів серіалізує реагування (150μsM SK1
* Сервіалізація замовлення десеріалізує відгук користувача (150μsM SK1
* Серіалізація замовлення Запрос на склад (150μsM SK1
* … і так далі

**В 5-ланцюзі послуг , ви МSK2 витрачаєте МSK3м лише на SerDe** - і те, що

Так, ви можете зменшити це за допомогою таких методів, як [генерація джерела JSON в .NET](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/source-generation):

```csharp
[JsonSerializable(typeof(User))]
internal partial class UserJsonContext : JsonSerializerContext { }

// ~30-40% faster than reflection-based serialization
var json = JsonSerializer.Serialize(user, UserJsonContext.Default.User);
```

Але ви - МСК0 - все ще ведете сеrialізацію. МСК1 - Ви - МSK2 - щойно зробили налоги трохи дешевшими. МSK3 - У моноліті - МКС4 - налоги нульові

#### Справжній приклад: СерDe катастрофа

Одного разу я проаналізував систему пошуку адресів з цією архітектурою (все в контейнерах Kubernetes ):

```
ASP.NET API → Go Service (fan-out) → ASP.NET Search Service → Elasticsearch
```

Служба Go обробляла вентиляцію- через кілька джерел даних та згенеровані результатиM SK1 Кожна просьба означала, що багатосерйалізація перестрибує через кордони контейнерів.

**Розділ типового пошуку адресів:**

* ASP.NET APIM SK1 Серіалізувати пошуковий запит → JSON (80μsMSC4
* Мережа: ASPM SK1NET → Go (varies by cluster load
* Go Service: Десеріалізувати запит (40μsM SK2
* Go Service: Вимкніть вентилятор M SK1 Серіалізуйте запити на кілька засадників (60μs МSK3 N засадники )
* Мережа: Перейти M SK1 ASP.NET пошук (variesMSC4
* Служба пошуку: Десеріалізувати запит M SK1μs)
* Поискова служба: Збудувати гнучкий пошуковий запитM SK1 Серіалізувати МSK2μs)
* Мережа: Поиск M SK1 Elasticsearch (varies)
* Elasticsearch: Серіалізувати пошукM SK1 виконати, послідовнити результати MSC3 актуальний пошук ~5msMska5 SerDe МSK6μsM Ska7
* Мережа: Elasticsearch M SK1 Search (varies)
* Поискова служба: Серіалізувати ES реагування M SK1μs), мапу до доменного моделіMSC3 Сериалізувати (180 μsМSK5
* Мережа: Поиск M SK1 Перейти (varies)
* Go Service: Серіалізувати відповіді з усіх заданих ланцюгів M SK1μs × N), AggregatМSK4 Сериалізовувати МSK5μ sMSC6
* Мережа: Go → ASPM SK2NET (variesMSC4
* ASP.NET APIM SK1 Десеріалізувати кінцевий відгук (120μs)

**Для вентилятора 3-зазадної частиниM SK1назовніМSK2**

* Об 'ємSerDe надрахунків: M SK1м до того, як почалася Elasticsearch
* Мережа підключення між контейнерами: M SK1ms
* Фактичне пошуку + бізнес-логіка

**Ми витрачали майже стільки часу на SerDe, скільки на реальні пошуки.**

Ціна була: "'", Go service itself - , вентилятор, - . Це було зрозуміло для користувача. **обмеження служби**. Кожна межа контейнера означала серійизацію МSK1 мережі МSK2 серійізацію .

У моноліті, який робить той самий вентилятор

* Те ж саме питання Elasticsearch
* Така ж логіка agregaції
* Нульний інтерфейс-сервіс SerDe M SK1регулярні методові дзвінки)
* ~40% менше загальної затримки

Це коштує

* Скала з складністю об 'єктів (непотрібні об' єктиМSK1 колекціїM SK2 поліморфізм)
* Компоненти з глибиною дзвінків (ланцюги послугM SK1
* Вигоряє процесор на кожному запиті (можливо'не залишає його в пам 'яті
* Збільшує тиск GC.
* **Він швидко збільшується, коли ви робите сотні запитів за секунду**

У моноліті, ця ціна є нульовоюМSK1 Об 'єкт вже в пам' ятіM SK2

### Миф про ефективність: пропускна спроможність протиM SK1 Скалабельність

Тут: "" МСК0 "" є загальноприйнятою рекламною концепцією. ":", "" МСК2 "". "" Мікросервіси покращують ефективність "".

**Це зворотній підхід.**

Мікросервіси **повільніше** для тих самих обчислювальних ресурсів

**Пропуск** (запроси за секунду за ядро процесораM SK1

- **Моноліт**: Вищий - нуль SerDe, нулі підключення до мережіM SK3 прямі методи дзвінків
- **Мікросервіси**: нижчий МSK1 SerDe надрахунковийM SK2 затримка мережевого потоку , оркестрування контейнерів

**Скалабельність** ( здатність виконувати більшу кількість запити, додаючи ресурсиM SK1

- **Моноліт**: Ограничено вертикальним масштабуванням
- **Мікросервіси**: Горизонтальний - додавати більше прикладів послуг з вузьким розривом

Мікросервіси дозволяють вам **масштабувати незалежно**. Якщо ваша служба запасів потребує МSK1x ресурсів, але ваша служба користувачів не потребуєM SK2t, ви можете масштабувати їх окремо **коли вам це потрібно**.

Але це не оптимізація ефективності. Це **стратегії масштабування**. І він приходить з подачей .

#### Сучасні моноліти можуть масштабувати також

Аргумент " покращення масштабу мікросервисів " мав більший сенс в МSK2, коли сервери мали МSK3 ядра

Нові сервери мають ядро 32-128

Якщо ваш моноліт збудований з сучасними одночасними схемами виконання, він може виконувати величезну пропускну спроможність на одному застосуванніM SK1 Наприклад, використовуючи такі схеми, як [тимчасові координатори виконання](/blog/ephemeral-execution-library), ви можете

```csharp
// Process thousands of concurrent operations in a monolith
services.AddEphemeralWorkCoordinator<TranslationRequest>(
    async (request, ct) => await TranslateAsync(request, ct),
    new EphemeralOptions { MaxConcurrency = Environment.ProcessorCount * 4 });

// Bounded, observable, efficient concurrent processing
// No network overhead, no SerDe, no container orchestration
// Can handle 10k+ req/sec on a single machine
```

Це дає вам:

- **Паралелізм**: Работа працює одночасно по всіх ядрах
- **Обсервабельність**: Тракторія ще не запущена
- **Взагальним тиском**: Ограничені черги запобігають вичерпанню пам 'яті
- **Нуль накладних витрат**: Без серіалізації , без мережі МSK2 без розподіленого відстеження

Коли ви **зробити** потрібно масштабувати більше, ніж одна машина, ви можете

1. Використовуйте багато інстанцій за балансувальником навантаження (нестательне горизонтальне масштабуванняM SK1
2. Використовуйте шаблон поштової скриньки для асинкового розподілу роботи
3. Різниця по ключі (ID клієнтаM SK1зонаМSK2 і т.д.

Ви still running a monolith . You' you just deployed it multiple times

**Помітка**: Don' не розділяється на мікросервіси для "подібностіM SK3 розділяються, коли **незалежне масштабування конкретних компонентів** виправдовує операційні витрати

### Когнітивний навантаження

Мікросервіси не зменшують складності. Вони перерозподіляють їх.

"проста служба" досі потребує контекстуM SK2

* Хто це називає?
* Що означає "правильнийM SK1?
* Що відбувається, коли показники знижуються?
* Яким є план відхилення?
* Що це за графік залежності?

Люди недооцінюють це, тому що діаграми його приховують.

### Версію та контрактний дрейф

Кожна межа стає контрактом  
Кожен контракт стає МСК0 .

* Правила версії
* Гарантії здатності
* Структурні обмеження еволюції
* Ви прикидалися, що не маєте координації

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

Це МСК0 , - ось мета. МСК1, якщо ви розмістите все разом, МSK2, ви створили моноліт. МSK3, просто гірший

### Набір інструментів перед значением

Перші витрати завжди однакові

* Дослідження послуг
* Менеджмент секретів
* Розповсюджене відстеження
* Центральна лісозаготівля
* Метріка та попередження
* Шаблони CI/CD
* локальна історія dev, яка не болить
* Керування залежністю
* Спосіб керувати всім, не плакаючи

Жоден з цих кораблів не має цінності.

І більшість команд робить це перед тим, як довести, що продукт заслуговує на складність.

Це головна помилка. **ви платите церемоніальний налог до того, як ви**. Як [щоденні стендапи, які витрачають час без налагодження](/blog/agile-standups-ceremony-tax), мікросервіси можуть стати ритуальною архітектурою

Якщо порівняти, ці витрати не зникають. МСК2 зростає. МSK3 зростають, незважаючи на те, чи організація потребує мікросервисів чи ні.

## Людей та команди

Архітектура існує, щоб допомогти групам людей безпечно змінювати програмне забезпечення.

Не вражати інших інженерів  
Не задовольнити діаграму.  
Не виправдовувати команду, яку ви не маєте

Розмір команди та cadence мають більше значення, ніж каталог моделей.

* Якщо одна команда має цілу дорожну карту, то моноліт зазвичай швидший і безпечніший.
* Якщо ви все ще розумієте конце системи, то мікросервіси зменшать цю чіткість.
* Якщо у вас немає стабільних границь власності, то мікросервіси змушують координувати роботу через API. МSK2 - найповільніший наявний механізм координації

**Конвей - це закон, який є неопційним, а фізикою.**

Ваша архітектура відображатиме вашу комунікаційну структуру, подобається вона вам чи ні.

Мікросервіси не створюють автономії. Вони потребують її.

## У захисті модульного моноліту

Більшість систем мають починати як монолітні. Але не сліпіM SK1

А **модульний моноліт** is:

* Одна дислокація
* Один робочий час
* Одне місце для розладів
* Один послідовний погляд на стан
* Але з реальними внутрішніми межами

Це означає:

* Доменні модулі з явною залежністю
* Зчистити права власності в коді
* Ні "все вказує на всеM SK1
* Контракти, що діють всередині кодової бази

Суть в тому, щоб не залишатися монолітним назавжди **заробляти кордони перед тим, як зробити їх віддаленими**.

Модулярний моноліт змушує вас вивчити вміння, які мікросервіси намагаються розв 'язати.

* Моделювання доменів (реальні кордониM SK1 не папкові кордони
* Різниця у занепокоєннях (не МSK1 ми зробили послугу МSK2
* Тестованість
* Зміна дисципліни
* Знаючи, що насправді робить ваша система

**Якщо ви можете побудувати чистий модульний моноліт, то мікросервіси виграють. Ми не врятуємо вас. Вони просто розповсюдять хаос.**

### Хороший дизайн моноліту: Patterns That Scale Later

Правильний дизайн моноліту дозволяє вам **відкладати рішення про мікросервіси** без замкнутись в ".".

#### Модель скриньки ззовні: Асинк без розподілу

Одним із найкращих прикладів є **шаблон поштової скриньки** - спосіб досягти кінцевої послідовності та асинкового обробки *всередині* моноліт, з чистим шляхом до розподілу пізнішеM SK1

Замість:

```csharp
// Tightly coupled synchronous code
public async Task PlaceOrder(Order order)
{
    await _orderRepo.Save(order);
    await _emailService.SendConfirmation(order);  // Blocks on external service
    await _inventoryService.Reserve(order.Items); // Blocks on another service
}
```

Ви пишете:

```csharp
// Outbox pattern: write events to a table
public async Task PlaceOrder(Order order)
{
    await using var transaction = await _db.Database.BeginTransactionAsync();
    
    // Save order
    await _orderRepo.Save(order);
    
    // Write events to outbox table (same transaction)
    _db.OutboxMessages.Add(new OutboxMessage
    {
        EventType = "OrderPlaced",
        Payload = JsonSerializer.Serialize(order),
        CreatedAt = DateTime.UtcNow
    });
    
    await _db.SaveChangesAsync();
    await transaction.CommitAsync();
    
    // Background worker picks up outbox events and publishes them
}
```

**Що це вам дасть:**

* **Транзакційна послідовність**: Мери та дані об 'єднуються або взагалі не об' єднуються
* **Відокремлення**: E-mail / логіка запасів працює асинкумно МSK2 не блокує створення замовлення
* **Надежність**: Впливи тривають, навіть якщо системи вниз
* **Чисти шлях виділення**: Пізніше , замінити робота надшвидкувальника на КафкуM SK2RabbitMQ без зміни логіки порядку

І [Зразок проекту SegmentCommerce](/blog/zero-pii-customer-intelligence-part2) демонструє це в процесі виробництва:

```csharp
// Mostlylucid.SegmentCommerce/Services/Queue/PostgresOutbox.cs
public class PostgresOutbox
{
    public async Task PublishAsync<T>(string eventType, T payload)
    {
        var message = new OutboxMessage
        {
            EventType = eventType,
            Payload = JsonSerializer.Serialize(payload),
            CreatedAt = DateTime.UtcNow
        };
        
        _db.OutboxMessages.Add(message);
        // Caller commits transaction
    }
}

// Background service
public class OutboxProcessor : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var pending = await _db.OutboxMessages
                .Where(m => !m.Processed)
                .OrderBy(m => m.CreatedAt)
                .Take(100)
                .ToListAsync();
                
            foreach (var message in pending)
            {
                await ProcessMessage(message);
                message.Processed = true;
            }
            
            await _db.SaveChangesAsync();
            await Task.Delay(1000, stoppingToken);
        }
    }
}
```

Це працює в одній програмі сьогодні. Коли вам потрібно масштабуватиM SK1

1. Заміняйте кваліфікованого працівника на споживача автобусу повідомлень
2. Публикація подій із поштової скриньки в Kafka/RabbitMQ замість локального обробки
3. **Код місця замовлення не змінюється**

Ви – МСК0 – створили мікросервіси, МСК1 – забезпечили достатню інфраструктуру без витрат на дистрибуцію, МSK2 –

#### Інші моделі, які варто робити на ранній стадії

* **CQRS (легкийM SK1**: Отдельно читатиM SK1 писати моделі, навіть якщо вони мають DB
* **Оборудування подій ( selektywne )**: Для аудиту
* **Флаги**: Розгортання розриву від релізу
* **Взагалішні завдання**: Don't блокування запитиM SK2 процес асинк

Жоден з них не потребує розподілу.

## Коли мікросервіси дійсно мають сенс

Мікросервіси мають сенс, коли обмеження реальні

Найважливішим питанням є: "" Чи можна використовувати мікросервіси? "" **чи переваги переважають операційний налог?**

Як вибір між [невеликі локальні моделі та LLM на кордоні](/blog/small-models-not-budget-option), це про те, щоб зрозуміти, до чого належить складність і які види невдачі ви можете собі дозволити

### Хороші триггери

* **Заперечення команди можна виміряти**: Команди блокують один одного щотижня
* **Невід 'ємні部署и необхідні**: Каденція випуску відрізняється залежно від домена
* **Шкала нерівна**: Одна підсистема потребує 10x ресурсів та ізоляції
* **Проблеми ізоляції невдачі**: Одна компонента не повинна знищувати решту
* **Регуляція/ ізоляція даних обов 'язкова**: кордони не піддатні переговорам
* **Структура орг вже мульти-команд**: Властство існує і є стабільним

### Погані триггери

* " Можемо масштабуватиM SK1
* "Netflix робить цеM SK1
* " Найкраща практикаM SK1
* МSK0 Це ' виглядатиме добре "
* МСК0 Наш моноліт заплутаний , тож ми ' виправимо його, розділяючи

**Якщо ваша причина містить слова *сила*, *врешті-решт*, або *майбутнє-просте*, це ' це, мабуть, не причина**

## Технологічна реальність: Яка насправді вартість мікросервисів

Дозвольте отримати бетон. Ось що міняється, якщо розділити моноліт на послуги.

### Телефонні ланцюги та тривалість

**Монолит:**

```csharp
public async Task<Order> PlaceOrder(OrderRequest request)
{
    var user = await _userService.GetUser(request.UserId);
    var inventory = await _inventoryService.CheckStock(request.Items);
    var price = _pricingService.Calculate(request.Items, user.Tier);
    
    var order = new Order { /* ... */ };
    await _orderRepository.Save(order);
    await _emailService.SendConfirmation(order);
    
    return order;
}
```

Кількість затримувань: M SK1ms (in-процесові дзвінки

**Мікросервіси:**

```csharp
public async Task<Order> PlaceOrder(OrderRequest request)
{
    // HTTP call to User Service (network + TLS + serialization)
    var user = await _httpClient.GetAsync<User>($"http://user-service/users/{request.UserId}");
    
    // HTTP call to Inventory Service
    var inventory = await _httpClient.PostAsync<StockResult>(
        "http://inventory-service/check", request.Items);
    
    // HTTP call to Pricing Service
    var price = await _httpClient.PostAsync<PriceResult>(
        "http://pricing-service/calculate", 
        new { items = request.Items, tier = user.Tier });
    
    // HTTP call to Order Service
    var order = await _httpClient.PostAsync<Order>(
        "http://order-service/orders", request);
    
    // Event published to message bus
    await _messageBus.Publish(new OrderPlaced { OrderId = order.Id });
    
    return order;
}
```

У реальному середовищі загальна затримка: M SK1ms ( навіть оптимістична

**Що ти отримав:**

* Кожна служба може діяти незалежно
* Інвестория та Ціни можуть масштабуватись окремо від Заказів
* Невипрацьовність в E-mail не блокує створення замовлення (async event)

**Що ви заплатили:**

* ~8x збільшення затримки
* 4 нові точки невдачі МSK1 будь-яка служба може зазнати краху МSK2повільне )
* Мережа, DNS, Перерахунки TLS на кожному дзвінку
* **Серіалізація/сериалізація над głową** (patrz попередній розділ
* Потреба в повторній логіці, розривники схемиМSK1 вимкнення часу
* Розповсюджене відстеження до невдач у розв 'язанні

### Помилка під час обробки вибуху

**Обладнання помилками моноліту:**

```csharp
try
{
    var order = await PlaceOrder(request);
    return Ok(order);
}
catch (InsufficientStockException)
{
    return BadRequest(new { error = "Out of stock" });
}
catch (Exception ex)
{
    _logger.LogError(ex, "Order placement failed");
    return StatusCode(500);
}
```

**Микросервісні помилки**

```csharp
try
{
    // Call User Service
    var user = await _httpClient.GetAsync<User>($"http://user-service/users/{request.UserId}");
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    return NotFound(new { error = "User not found" });
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.ServiceUnavailable)
{
    // Retry with exponential backoff?
    // Circuit breaker opened?
    // Fail fast or degrade gracefully?
    _logger.LogWarning("User service unavailable, retrying...");
    await Task.Delay(TimeSpan.FromMilliseconds(100));
    // ... retry logic ...
}
catch (TaskCanceledException ex)
{
    // Timeout - was the request processed? Do we retry?
    _logger.LogError("User service timeout");
    return StatusCode(503, new { error = "Service temporarily unavailable" });
}

try
{
    var inventory = await _httpClient.PostAsync<StockResult>(
        "http://inventory-service/check", request.Items);
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.BadRequest)
{
    // Business error from remote service
    var errorDetails = await ex.Content.ReadAsAsync<ErrorResponse>();
    return BadRequest(new { error = errorDetails.Message });
}
catch (HttpRequestException ex)
{
    // Which service failed? Network issue? Service down?
    // Do we have a fallback? Cached data? Fail fast?
    _logger.LogError(ex, "Inventory service failed");
    // Maybe try a backup instance?
    // ... more retry logic ...
}

// And repeat for every service call...
```

Кожен телефонний дзвінок представляє собою:

* сценарії вимкнення часу
* Перешкоди в мережі
* Недоступність послуг
* Частичні похибки (запрос відправленийM SK1 відповідь не отримана )
* Знову спробувати збільшення ( ваша спроба може призвести їх до повторної спробиM SK1
* Маргарет розподілених транзакцій

### Розподіл координації

**Розгортання моноліту:**

```bash
# Build
dotnet publish -c Release

# Run migrations
dotnet ef database update

# Deploy
docker push myapp:v1.2.3
kubectl set image deployment/myapp myapp=myapp:v1.2.3

# Rollback if needed
kubectl rollout undo deployment/myapp
```

**Розгортання мікрослужб:**

Ви – МСК0 – змінюєте структуру замовлення – МSK1 – Зараз `Order` включає `UserTier` безпосередньо (ненормализоване для продуктивностіM SK1

```bash
# 1. Deploy Pricing Service v2 (understands both old and new Order format)
kubectl set image deployment/pricing-service pricing-service=pricing:v2.0.0

# 2. Wait for rollout and monitor
kubectl rollout status deployment/pricing-service
# Check metrics - is v2 working with old order format?

# 3. Deploy Order Service v2 (starts sending new format)
kubectl set image deployment/order-service order-service=order:v2.0.0

# 4. Monitor for errors
# If Pricing v2 has a bug, you can't just rollback Order service
# You have to rollback both in reverse order

# 5. Deploy User Service v2 (stops including tier in response)
# But wait - old Order Service instances might still be running!
# Need zero-downtime rollout or maintain backward compat

# 6. Eventually clean up old code paths in Pricing Service v3
# (6 months later because you're scared to remove backward compat)
```

З мікросервисами, кожна зміна перетинає багато послугM SK1 Потрібна еволюція контракту:

* Відхилення від комп 'ютера
* Флаги різних служб
* Координовані запуски
* Поширені матриці тестування (Сервис А vM SK1 + Сервис Б vМSK3 Сервіс Аv2 | | МSK5 Сервис Б v | 1, і т.д.

Ніхто з цього неможливе МСК0 Але це вимагає дисципліни МSK1 інструментарію , і досвіду, який більшість команд заробляє лише після років болю.

### Усвідомлення розладів

**Monolith @ info bug report status** "Заказ failed for premium usersM SK1

```csharp
// Set breakpoint in PlaceOrder
// Step through each call
// User tier is null - ah, there's the bug
// Fix, test, deploy
```

**Microservices - звіт про помилку:** "Заказ failed for premium usersM SK1

```bash
# 1. Check logs - which service failed?
kubectl logs -l app=order-service --tail=100

# 2. Oh, it's calling Pricing service. Check those logs
kubectl logs -l app=pricing-service --tail=100

# 3. Grep for correlation ID across all services
stern -l app=order-service,app=pricing-service,app=user-service \
  | grep "correlation-id-xyz"

# 4. Reconstruct the call chain from distributed traces
# Open Jaeger/Zipkin, find the trace
# User service returned 200 OK
# Pricing service returned 400 Bad Request
# Error: "user.tier is required"

# 5. Check User service - did it send tier?
# Look at schema version - ah, User v1.2 stopped sending tier
# When did that deploy? Was Pricing service updated?

# 6. Check API contracts
# Pricing expects tier, User stopped sending it
# Who approved this change?

# 7. Fix requires coordinating two teams
# Can't just deploy a fix - need contract negotiation
```

Це реальність. **помилки, які були 5-minute fixes, стають moniM SK1team investigations**.

Якщо це звучить екстремально,

## Як безпечно розвиватися: Монолит M SK1 Мікросервіси

Мікросервіси - це одна двері.

Безпека виглядає нудно:

### 1. Спершу довести межі

Якщо ви можете ' не намалювати межу всередині моноліту ( з наказовими віддаленнями

Зробіть шви локально першими.

### 2. Вирізання читається перед записами

Читання легше:

* Менше інваріантів
* Менші вимоги до послідовності
* Менше нічних жахів

Переміщуємо читані моделі першими, якщо вам потрібна відокремлення.

### 3. Prefer Async Before Sync

Синхронні дзвінки на службу створюють ланцюги залежності.

Асинхове повідомлення створює:

* Буферування
* Реsiliентність
* Ви відокремлюєте, і ви можете вижити

Почнемо з відокремлення подій та фактів, а не з розрізу кінцевих точокM SK1

### 4. StrangleM SK1 Don't Заново записати

Немає великого вибуху.  
Ні. " ми ' я перепишу це правильноM SK2

Розрізайте кордон. МСК0, вимірюйте його. МSK1, володійте ним. ,, і продовжуйте.

**Якщо ви можете пояснити, чому служба існує незалежно,**

## Мікросервіси платять лише за те, якщо ви розумієте торгівлю

Мікросервіси не є початковою точкою.

**Потрібно отримати складність.** Дистрибовані системи - це не значок.

Теорема Handel - off проста

```
Microservices Value = (Team Autonomy + Independent Scaling + Failure Isolation)
                     - (Latency Tax + SerDe Tax + Operational Overhead + Coordination Cost)
```

Для більшості команд - особливо в ранній стадії МSK1 стадія або одиночный МSK2набірні продукти - правильний бік домінує мSK4 Ви платите величезні витрати за переваги, які вам не потрібні M' ще не потрібно МСК6

Але коли ви маєте

* 5+ команди, що стають один на одного
* Кільзи розгортання виміряні впродовж днів
* Субсистеми з дуже різними потребами масштабування
* Регуляційні вимоги щодо ізоляції даних

МSK0 тоді ліва сторона починає виграти. Налог стає обґрунтованимM SK2

### Cadу для прийняття рішень

Задайте ці питання в порядку:

1. **Чи може одна команда володіти цим кінцім?**  
   МСК0 ТакМSK1 залишатися монолітнимМСК2 Ні МСК3 обмірковувати поділМ СК4

2. **Команди блокуються одна від одної.**  
   МСК0 ТакМSK1 Мікросервіси можуть допомогтиММК2 НіММСК3 координація працюєМПСК4

3. **Чи маємо ми оперативні м 'язи для запуску розподілених систем?**  
   → Ні : збудувати його першими МSK2 Так M SK3 рухатись обережно .

4. **Чи можемо ми відслідковувати, розв 'язання вад, і розробити численні послуги без героїчностіM SK2**  
   МSK0 Ні МSK1 ти МСК2 ти не готовий М СК3 так

5. **Ми перевірили межі у коді першими?**  
   → Ні : виправити вашу монолітну структуру МSK2 Так M SK3 видобуток безпечніший .

Якщо ви не можете' відповісти на минуле питання 3 з впевненістю(M SK2), то ви(МSK3) не готові до мікросервисів. **Архітектура Boring є конкурентною перевагою.**

Найуспішніші продукти були збудовані як моноліти першими.

Ваша робота - це не будувати найбільш вражаючу архітектуру, а deliver value while minimising accidental complexity

І жоден клієнт ніколи не заплатив додатково, тому що ваша система використовувала Kafka.

Іноді це означає мікросервіси.