Blog Dla Programistów C#/.NET

Kiedy mikroserwisy mają sens? Rachunek dla zespołu 4 programistów i twarde granice modułów w .NET

czwartek, 19 listopada 2026 Tagi: C#/.NETProgramowanieSystem Design

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.

Kiedy mikroserwisy mają sens? Rachunek dla zespołu 4 programistów i twarde granice modułów w .NET

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.

CechaW jednym procesiePo sieci
Czas wywołania (u mnie)ok. 3 ns (metoda przez interfejs)ok. 125 µs (HTTP na jednym komputerze)
W centrum danychbez zmiandodatkowo 0,5-1 ms
Możliwe wynikiudaje się albo rzuca wyjątektakże awarie częściowe: odpowiedź wolna albo żadna
Transakcjawspólnaznika, 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 utrzymujeszMonolit6 usług
Pipeline wdrożenia16
Konfiguracja i sekrety16
Monitoring i alerty16
Kontrakty między częściamisprawdza kompilatorwersje API
Dyżur1 system6 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:

CechaWielka kula błotaMonolit modularnyMikroserwisy
Wdrożenie1, cały system1, cały systemosobne dla każdej usługi
Wywołanie innej częścimetoda (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
Transakcjawspólnawspólna (1 baza, osobne schematy)brak wspólnej, gdy każda usługa ma swoją bazę
Granicebrakkontrakt, internal, test architekturysieć i API z wersjami
Serwery (2 instancje po ok. 70 zł)140 zł140 zł840 zł przy 6 usługach
Dyżur1 system1 system6 systemów
Kiedy wybraćnigdy celowo1 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? :)

Autor artykułu:
Kazimierz Szpin
Kazimierz Szpin
CTO & Founder - FindSolution.pl
Programista C#/.NET. Specjalizuje się w Blazor, ASP.NET Core, ASP.NET MVC, ASP.NET Web API, WPF oraz Windows Forms.
Autor bloga ModestProgrammer.pl
Dodaj komentarz
© Copyright 2026 modestprogrammer.pl | Sztuczna Inteligencja | Regulamin | Polityka prywatności. Design by Kazimierz Szpin. Wszelkie prawa zastrzeżone.