C# / .NET Kompendium PLEN
.NET / C# / Architektura rozproszona

Zarządzanie danymi referencyjnymi/słownikowymi w architekturze mikroserwisów

Problem - dane słownikowe potrzebne w wielu serwisach

Dane referencyjne (np. lista krajów, statusów zamówień, kategorii produktów, kursy walut) są potrzebne w wielu mikroserwisach naraz - OrderService potrzebuje statusów zamówień, PaymentService potrzebuje kursów walut, ShippingService potrzebuje listy krajów. Pytanie: gdzie te dane powinny "żyć" i jak każdy serwis ma do nich dostęp?

Podejście #1 - dedykowany serwis danych referencyjnych + synchroniczne wywołania

public interface IReferenceDataClient
{
    Task<List<CountryDto>> GetCountriesAsync();
    Task<string> GetCurrencyRateAsync(string code);
}
public class ReferenceDataClient : IReferenceDataClient
{
    private readonly HttpClient _httpClient;

    public async Task<List<CountryDto>> GetCountriesAsync()
    {
        return await _httpClient.GetFromJsonAsync<List<CountryDto>>("api/reference/countries");
    }
}

Zaleta: jedno źródło prawdy (single source of truth) - dane zawsze aktualne, bez ryzyka niespójności między serwisami.

Wada: każde wywołanie wymaga synchronicznego requestu do innego serwisu - jeśli ReferenceDataService jest wolny/niedostępny, wszystkie serwisy zależne od niego są tym obciążone (klasyczny problem kaskadowej awarii w mikroserwisach).

Podejście #2 - lokalna replikacja (caching) danych referencyjnych w każdym serwisie

To jest znacznie częstsze podejście w praktyce - każdy serwis przechowuje własną, lokalną kopię danych referencyjnych, zsynchronizowaną asynchronicznie:

public class OrderService
{
    private readonly IMemoryCache _cache;
    private readonly IReferenceDataClient _referenceDataClient;

    public async Task<List<CountryDto>> GetCountriesAsync()
    {
        return await _cache.GetOrCreateAsync("countries", async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1); // cache na godzinę
            return await _referenceDataClient.GetCountriesAsync();
        });
    }
}

Zaleta: brak zależności synchronicznej od innego serwisu przy każdym requeście - odczyt z lokalnego cache jest natychmiastowy.

Wada: dane mogą być przez chwilę nieaktualne (eventual consistency) - jeśli status "Pending" zmieni nazwę na "Oczekujące", serwisy z cache będą pokazywać starą nazwę do wygaśnięcia cache'a.

Podejście #3 - propagacja przez zdarzenia (Event-Driven Reference Data)

To jest podejście łączące poprzednie dwa, wykorzystujące dokładnie ten sam mechanizm publikowania zdarzeń, o którym mówiliśmy przy Sadze i Outboxie:

// ReferenceDataService publikuje zdarzenie przy KAŻDEJ zmianie danych referencyjnych
public async Task UpdateCountryAsync(int id, string newName)
{
    var country = await _context.Countries.FindAsync(id);
    country.Name = newName;
    await _context.SaveChangesAsync();

    await _eventBus.PublishAsync(new CountryUpdatedEvent(id, newName)); // + Outbox Pattern dla atomowości!
}

// KAŻDY zainteresowany serwis nasłuchuje i AKTUALIZUJE swoją LOKALNĄ kopię
public class CountryUpdatedHandler
{
    public async Task Handle(CountryUpdatedEvent evt)
    {
        var localCountry = await _context.LocalCountryReplicas.FindAsync(evt.CountryId);
        localCountry.Name = evt.NewName;
        await _context.SaveChangesAsync(); // LOKALNA replika, w bazie TEGO serwisu
    }
}

Zaleta: brak synchronicznej zależności między serwisami (odczyt zawsze z lokalnej bazy), a jednocześnie dane są względnie szybko (nie natychmiast, ale sekundy, nie godziny jak przy zwykłym cache TTL) propagowane po zmianie, bez czekania na wygaśnięcie cache'a.

Wada: więcej infrastruktury (broker wiadomości, obsługa zdarzeń w każdym serwisie), oraz każdy serwis duplikuje dane referencyjne we własnej bazie.

Kiedy które podejście

Podejście Kiedy stosować
Synchroniczne wywołania (bez cache) Dane rzadko odpytywane, wymóg absolutnej świeżości, tolerancja na zależność między serwisami
Lokalny cache z TTL Dane zmieniają się rzadko, akceptowalna chwilowa nieaktualność (minuty/godziny)
Propagacja przez zdarzenia + lokalna replika Dane potrzebne bardzo często (każdy request), wymagana niezależność od dostępności innego serwisu, ale też względna świeżość

Ważna zasada - dane referencyjne "właścicielem" jednego serwisu

Niezależnie od podejścia synchronizacji, jeden konkretny serwis powinien być właścicielem (source of truth) danego zestawu danych referencyjnych - inne serwisy czytają (i ewentualnie cache'ują/replikują), ale nie modyfikują tych danych bezpośrednio w swojej bazie. To jest analogiczne do zasady "jeden Bounded Context = jeden właściciel danych" z Domain-Driven Design.

Podsumowanie

W architekturze mikroserwisów dane referencyjne wymagają świadomej decyzji o kompromisie między świeżością danych i niezależnością serwisów. Synchroniczne wywołania dają zawsze aktualne dane, ale tworzą zależność czasową między serwisami. Lokalny cache z TTL eliminuje tę zależność, kosztem chwilowej nieaktualności. Propagacja przez zdarzenia (wykorzystująca ten sam Outbox Pattern, o którym mówiliśmy) daje najlepszy kompromis dla danych często odpytywanych - lokalna replika bez zależności synchronicznej, z względnie szybką propagacją zmian.

Postaw mi kawę