Code review. Dopisujesz do zamówień wysyłkę faktury, a kolega pyta: "Może rozbijmy to na mikroserwisy?" Czujesz, że to przesada, ale trudno to uzasadnić. Moda podpowiada jedno, a w zespole są 4 osoby.
W tym artykule policzymy, ile mikroserwisy naprawdę kosztują: sieć, dane, serwery i ludzie. Zobaczysz, jak wygląda rozproszony monolit, czyli najczęstszy efekt mikroserwisów wprowadzonych bez potrzeby, kiedy podział systemu ma sens i jakie jedno pytanie warto sobie zadać przed taką decyzją. A na koniec pokażę, co zrobić zamiast mikroserwisów w .NET: monolit modularny z twardymi granicami - osobne projekty, osobny DbContext i schemat bazy na moduł oraz test architektury, który pilnuje granic za Ciebie.
Przykład to sklep internetowy Dioda z repozytorium mojego kursu (firma i dane są fikcyjne, kod działa). Fragmenty kodu z monolitem modularnym pochodzą z małego przykładu z kursu, osobnego od repozytorium sklepu.
Stan danych: wrzesień 2026. Czasy wywołań oznaczone jako "u mnie" to pomiary na moim komputerze, ceny serwerów są przykładowe (ok. 70 zł miesięcznie za instancję), a przykład kodu jest skompilowany i przetestowany w .NET 10.
Dioda: 4 programistów, 1 wdrożenie dziennie
Zanim odpowiesz koledze, zacznij od liczb o zespole. Dioda ma 4 programistów. To jeden zespół i jedno wdrożenie dziennie - całego sklepu naraz.
To ważny punkt wyjścia, bo pytanie "monolit czy mikroserwisy?" bardzo rzadko jest pytaniem czysto technicznym. Dużo częściej jest pytaniem o to, ilu ludzi pracuje nad systemem i jak bardzo przeszkadzają sobie nawzajem.
Co dają mikroserwisy
Zacznij uczciwie: mikroserwisy dają prawdziwe korzyści.
• Niezależne wdrożenia. Każda usługa wychodzi na produkcję we własnym tempie.
• Niezależne skalowanie. Instancje dokładasz tylko tam, gdzie jest ruch.
• Izolacja awarii. Problem w jednej usłudze nie musi położyć całego systemu.
• Niezależne zespoły. Każdy ze swoją usługą i swoim rytmem pracy.
Tylko że każda z tych korzyści ma swoją cenę. Policzmy ją.
Cena 1: sieć zamiast wywołania metody
Moduł w tym samym procesie wołasz jak zwykłą metodę. U mnie wywołanie przez interfejs trwa około 3 nanosekund. Albo się udaje, albo rzuca wyjątek.
Po wydzieleniu modułu do osobnej usługi to samo wywołanie idzie przez HTTP. U mnie, na jednym komputerze, bez prawdziwej sieci: mediana 125 mikrosekund, czyli około 40 000 razy dłużej. W centrum danych dochodzi do tego od 0,5 do 1 milisekundy.
| Cecha | W jednym procesie | Po sieci |
| Czas wywołania (u mnie) | ok. 3 ns (metoda przez interfejs) | ok. 125 µs (HTTP na jednym komputerze) |
| W centrum danych | bez zmian | dodatkowo 0,5-1 ms |
| Możliwe wyniki | udaje się albo rzuca wyjątek | także awarie częściowe: odpowiedź wolna albo żadna |
| Transakcja | wspólna | znika, gdy każda usługa ma swoją bazę |
Sam czas to jeszcze nie wszystko. Po sieci pojawiają się awarie częściowe: druga strona odpowiada wolno albo wcale, a Ty musisz zdecydować, co wtedy zrobić - ponowić, poczekać, zwrócić błąd? Do tego dochodzą timeouty, ponowienia i obsługa sytuacji, w której nie wiesz, czy druga strona wykonała operację. A gdy każda usługa ma swoją bazę, znika też wspólna transakcja. Zamówienie i płatność, które wcześniej zapisywały się razem albo wcale, teraz mogą się rozjechać.
Cena 2: wdrożenia i utrzymanie
Weź 6 modułów Diody: katalog, koszyk, zamówienia, płatności, wysyłkę i powiadomienia, i zrób z każdego osobną usługę. Oto co się zmienia w codziennym utrzymaniu:
| Co utrzymujesz | Monolit | 6 usług |
| Pipeline wdrożenia | 1 | 6 |
| Konfiguracja i sekrety | 1 | 6 |
| Monitoring i alerty | 1 | 6 |
| Kontrakty między częściami | sprawdza kompilator | wersje API |
| Dyżur | 1 system | 6 systemów |
6 pipeline'ów zamiast jednego. 6 konfiguracji. 6 miejsc z monitoringiem. Zmianę sygnatury metody w monolicie sprawdza kompilator, a między usługami API musi mieć wersje, bo nie wdrożysz wszystkich naraz.
I dyżur, na którym ktoś musi znać 6 systemów. W Diodzie to te same 4 osoby, które na co dzień piszą funkcje sklepu. Każda godzina spędzona na utrzymaniu infrastruktury to godzina mniej na rozwój produktu.
Cena 3: serwery - 140 zł czy 840 zł?
Policz same serwery, po cenach przykładowych. Założenia:
• instancja kosztuje ok. 70 zł miesięcznie,
• każda usługa ma co najmniej 2 instancje, żeby awaria jednej nie wyłączała całej usługi.
Monolit Diody po poprawkach: 2 instancje, czyli 2 × 70 zł = 140 zł miesięcznie.
6 usług: 6 × 2 × 70 zł = 840 zł miesięcznie.
6 razy więcej - a w tym rachunku nie ma jeszcze osobnych baz, pipeline'ów ani dyżurów. Przy zespole 4 osób, który i tak wdraża cały sklep raz dziennie, trudno wskazać, co te dodatkowe 700 zł miesięcznie by kupiło.
Rozproszony monolit: jak kończą się mikroserwisy bez potrzeby
Jak kończą się mikroserwisy wprowadzone bez potrzeby? Bardzo często tak:
1. Zespół dzieli sklep na usługi: zamówienia, płatności, magazyn.
2. Ale zamówienia wołają płatności, a płatności wołają magazyn. Synchronicznie, w jednym żądaniu klienta. Każda usługa czeka na następną.
3. Do tego wszystkie czytają i zmieniają te same tabele we wspólnej bazie.
Efekt? Zmiana jednej kolumny to wdrożenie 3 usług naraz. To właśnie rozproszony monolit: sieć i kilka wdrożeń jak w mikroserwisach, ale bez niezależności. Płacisz wszystkie ceny, o których była mowa wyżej, i nie dostajesz żadnej z korzyści. Awaria magazynu nadal blokuje zamówienia, a wdrożenia nadal trzeba koordynować - tylko teraz przez sieć.
Kiedy mikroserwisy mają sens
Kiedy więc mikroserwisy naprawdę mają sens? Wtedy, gdy:
• nad jednym systemem pracuje kilka zespołów i blokują sobie wdrożenia. Każdy czeka na testy pozostałych, zanim wypuści swoją zmianę,
• część systemu ma zupełnie inne wymagania: skalowania, technologii albo bezpieczeństwa,
• firma ma już dojrzałą automatyzację wdrożeń i monitoringu. Bez niej każda nowa usługa to ręczna praca.
Zwróć uwagę na kolejność. Najpierw problem organizacji, potem podział systemu. Mikroserwisy rozwiązują przede wszystkim problem wielu zespołów, a nie problem złego kodu. Jeśli kod jest splątany w monolicie, po podziale na usługi będzie splątany przez sieć.
Jedno pytanie o Twój system
Zanim zgodzisz się na podział, zadaj sobie jedno pytanie:
Ile razy w ostatnim miesiącu 2 zespoły zablokowały sobie nawzajem wdrożenie?
Jeśli zero, mikroserwisy nie rozwiążą problemu, którego nie masz. A wszystkie koszty z tego artykułu poniesiesz od pierwszego dnia.
Wielka kula błota czy monolit modularny?
Co więc zamiast mikroserwisów? Monolit ma złą opinię przez jeden wariant: wielką kulę błota (big ball of mud), w której każda klasa sięga po każdą tabelę i wszystko zależy od wszystkiego.
Ale monolit nie musi tak wyglądać. Monolit modularny to ten sam jeden proces i jedno wdrożenie, tylko z modułami, które:
• rozmawiają ze sobą wyłącznie przez kontrakt,
• swoje tabele zmieniają same.
Zostają zalety monolitu (wywołanie metody zamiast sieci, wspólna transakcja, 1 pipeline, 1 dyżur), a znika największa wada: splątanie wszystkiego ze wszystkim. Pokażę Ci, jak takie granice zrobić twardo w .NET - tak, żeby pilnował ich kompilator i test, a nie dobra wola zespołu.
Granica 1: publiczny tylko kontrakt
Najprostsza twarda granica w .NET to osobny projekt na moduł, a z zewnątrz widać tylko kontrakt. Kontrakt modułu Katalog leży w osobnym projekcie:
/* Dioda.Catalog.Contracts - jedyne, co widzą inne moduły */
public interface ICatalogModule
{
Task<ProductPrice?> GetPriceAsync(int productId,
CancellationToken cancellationToken = default);
}
public record ProductPrice(
int ProductId, string Name, decimal Price);
/* Dioda.Catalog - wnętrze modułu */
internal sealed class CatalogModule(CatalogDbContext db)
: ICatalogModule
{
…
}Co tu się dzieje:
• ICatalogModule to interfejs z jedną metodą, GetPriceAsync. Inne moduły pytają Katalog o cenę tylko tędy.
• Odpowiedź to prosty rekord ProductPrice z numerem, nazwą i ceną. Nie encja z bazy - dzięki temu Katalog może zmieniać swoje encje, nie psując nikomu kodu.
• Klasa CatalogModule jest internal, podobnie jak encje i DbContext Katalogu. Inne moduły mają referencję tylko do projektu z kontraktem, więc kompilator nie pozwoli im sięgnąć do środka.
Granica 2: osobny DbContext i schemat bazy
Każdy moduł ma też swój DbContext:
internal sealed class OrdersDbContext(
DbContextOptions<OrdersDbContext> options)
: DbContext(options)
{
public DbSet<Order> Orders => Set<Order>();
protected override void OnModelCreating(
ModelBuilder modelBuilder)
{
modelBuilder.HasDefaultSchema("orders");
…
}
}3 rzeczy warte uwagi:
• OrdersDbContext też jest internal - nikt spoza modułu Zamówień go nie użyje.
• Widzi tylko tabele zamówień. Produktów tu nie ma.
• HasDefaultSchema("orders") sprawia, że wszystkie tabele modułu trafiają do schematu orders. Baza jest jedna, ale każdy moduł ma swój schemat i swoje migracje.
A co, jeśli zamówienie potrzebuje nazwy i ceny produktu? Zamówienie trzyma kopię nazwy i ceny z chwili zakupu, zamiast złączenia z tabelą Katalogu. To zresztą dobre rozwiązanie także biznesowo: cena w zamówieniu nie powinna się zmieniać, gdy ktoś później zmieni ją w katalogu.
Granica 3: test architektury w ArchUnitNET
Granic pilnuje test architektury. Tutaj w darmowej bibliotece ArchUnitNET, która analizuje skompilowany kod:
private static readonly Assembly Orders =
typeof(OrdersModuleExtensions).Assembly;
private static readonly Assembly Catalog =
typeof(CatalogModuleExtensions).Assembly;
…
[Fact]
public void Orders_do_not_depend_on_catalog_internals() =>
Types().That().ResideInAssembly(Orders)
.Should().NotDependOnAny(
Types().That().ResideInAssembly(Catalog))
.Check(Architecture);Pierwsze linie wskazują 2 projekty: Zamówienia i Katalog. Sam test mówi: weź wszystkie typy z projektu Zamówień - nie mogą zależeć od żadnego typu z projektu Katalogu. Kontrakt leży w osobnym projekcie, więc test go dopuszcza.
Sprawdziłem to: gdy ktoś doda referencję i sięgnie po klasę z wnętrza Katalogu, test pada i podaje nazwę tej klasy. Granica przestaje być umową w zespole, a staje się regułą, którą sprawdza każdy build.
Jak odpowiedzieć na code review
Wróćmy do code review. Kolega pyta: "Może rozbijmy to na mikroserwisy?" Możesz odpowiedzieć tak:
"Mamy jeden zespół i jedno wdrożenie dziennie. 6 usług to 840 zł miesięcznie za same serwery i 6 systemów na jednym dyżurze. Najpierw zróbmy twarde granice w monolicie. Gdy pojawi się konkretny powód, wydzielenie modułu z czystą granicą to przeniesienie projektu, a nie przepisywanie."
To odpowiedź z liczbami, a nie przeciw mikroserwisom. Nie zamykasz drogi do podziału - przygotowujesz system tak, żeby podział był tani, kiedy naprawdę będzie potrzebny. Moduł z własnym kontraktem, własnym DbContextem, własnym schematem i testem architektury jest już w połowie drogi do osobnej usługi.
Ściąga: kula błota, monolit modularny czy mikroserwisy?
Na koniec 3 warianty obok siebie, z liczbami z tego artykułu:
| Cecha | Wielka kula błota | Monolit modularny | Mikroserwisy |
| Wdrożenie | 1, cały system | 1, cały system | osobne dla każdej usługi |
| Wywołanie innej części | metoda (u mnie ok. 3 ns) | metoda przez kontrakt (u mnie ok. 3 ns) | HTTP (u mnie ok. 125 µs, w sieci więcej), awarie częściowe |
| Transakcja | wspólna | wspólna (1 baza, osobne schematy) | brak wspólnej, gdy każda usługa ma swoją bazę |
| Granice | brak | kontrakt, internal, test architektury | sieć i API z wersjami |
| Serwery (2 instancje po ok. 70 zł) | 140 zł | 140 zł | 840 zł przy 6 usługach |
| Dyżur | 1 system | 1 system | 6 systemów |
| Kiedy wybrać | nigdy celowo | 1 zespół, wdrożenia się nie blokują | kilka zespołów blokujących sobie wdrożenia, inne wymagania części systemu, dojrzała automatyzacja |
Zwróć uwagę, że monolit modularny bierze od monolitu koszty, a od mikroserwisów porządek. Płacisz tyle, co za 1 system, a granice między modułami są równie twarde jak między usługami - tylko pilnuje ich kompilator i test, a nie sieć.
Podsumowanie
Mikroserwisy rozwiązują przede wszystkim problem wielu zespołów, a każda ich korzyść ma koszt. Zapamiętaj:
• Sieć: ok. 3 ns w procesie wobec ok. 125 µs przez HTTP u mnie, do tego awarie częściowe i brak wspólnej transakcji.
• Utrzymanie: 6 usług to 6 pipeline'ów, konfiguracji, miejsc z monitoringiem i systemów na dyżurze.
• Serwery: 140 zł wobec 840 zł miesięcznie, jeszcze bez baz i dyżurów.
• Rozproszony monolit to najgorsze z obu światów: koszty mikroserwisów bez ich niezależności.
• Najpierw problem organizacji, potem podział systemu. Jeśli zespoły nie blokują sobie wdrożeń, mikroserwisy nie mają czego rozwiązać.
• Monolit modularny w .NET: osobny projekt na moduł, publiczny tylko kontrakt, osobny DbContext i schemat, test architektury.
Takich decyzji - liczbami i na działającym sklepie - uczysz się w moim kursie Szkoła System Design. To 12 modułów: od wymagań, szacowania i skalowania, przez bazę danych, cache, kolejki i odporność na awarie, po architekturę (dzisiejszy temat), produkcję, plan na Black Friday i rozmowę system design na seniora. Razem ponad 20 godzin nauki, 7 laboratoriów i 11 zadań projektowych. Oglądasz lekcję (diagramy, obliczenia i kod w C#), powtarzasz laboratorium u siebie i mierzysz w k6, co się zmieniło, a po każdym module projektujesz system - na przykład wysyłkę faktur do KSeF. Sprawdzasz się checklistą, a potem oglądasz moje omówienie z przykładowym rozwiązaniem. Pytania do swojego rozwiązania wysyłasz mailem i odpowiadam na nie osobiście (pełnej recenzji każdej pracy nie robię - dlatego omówienie pokazuje całe rozwiązanie).
Ostatnie laboratorium to test Black Friday na sklepie przed kursem i po nim: promocja na 500 konsol i awaria bramki SMS w trakcie. U mnie błędy spadły z ponad 10% do 0,03%, złożenie zamówienia z 3,4 s do 319 ms, sklep zamiast ponad 550 konsol (przy 500 na stanie) sprzedał dokładnie 500, a w czasie awarii SMS przeszły wszystkie zamówienia zamiast mniej niż połowy. Kurs jest dla Ciebie, jeśli programujesz komercyjnie od około roku, celujesz w mida albo seniora albo budujesz własny SaaS. Nie jest, jeśli dopiero uczysz się programować albo chcesz robić laboratoria na macOS lub Linuksie - przygotowałem je tylko pod Windows. Prowadzę go ja: od ponad 15 lat tworzę oprogramowanie w .NET, jestem CTO firmy FindSolution i mam 5 własnych aplikacji SaaS. Dostęp jest dożywotni, a przez 14 dni możesz kurs sprawdzić bez ryzyka - jeśli uznasz, że to nie dla Ciebie, oddaję 100% wpłaty.
Szczegóły znajdziesz tutaj: modestprogrammer.pl/szkola-system-design. Zapisy otwieram tylko na tydzień - jeśli akurat są zamknięte, zostaw tam e-mail na liście oczekujących, a dam Ci znać o następnej edycji.
A ile razy w ostatnim miesiącu Twoje zespoły zablokowały sobie wdrożenie? :)