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

Apache Kafka - podstawy

Co to jest Kafka - rozproszony log zdarzeń

Kafka to platforma do przesyłania strumieni zdarzeń (event streaming), działająca jako rozproszony, trwały log (append-only log) - w przeciwieństwie do tradycyjnego brokera wiadomości (jak RabbitMQ), gdzie wiadomość jest usuwana po odebraniu, Kafka przechowuje wiadomości przez skonfigurowany czas (retencję), niezależnie od tego, czy zostały już odebrane.

To jest właśnie technologia, którą naturalnie wykorzystałbyś do implementacji IEventBus z przykładów Sagi/Outboxa, o których mówiliśmy wcześniej.

Kluczowe pojęcia

Topic - kanał, do którego publikujesz wiadomości

Topic: "order-events"

Analogicznie do tabeli w bazie danych albo kolejki w RabbitMQ - logiczna kategoria zdarzeń o podobnym charakterze (np. wszystkie zdarzenia dotyczące zamówień).

Partycje - jak Kafka skaluje przepustowość

Każdy topic jest podzielony na partycje - niezależne, uporządkowane logi, które mogą być rozmieszczone na różnych serwerach (brokerach) w klastrze:

Topic: "order-events" (3 partycje)
├── Partition 0: [msg1, msg4, msg7, ...]
├── Partition 1: [msg2, msg5, msg8, ...]
└── Partition 2: [msg3, msg6, msg9, ...]

Kluczowa właściwość - kolejność zachowana TYLKO wewnątrz jednej partycji. Kafka gwarantuje porządek wiadomości w ramach jednej partycji, ale nie między różnymi partycjami tego samego topicu.

// Klucz partycjonowania decyduje, do KTÓREJ partycji trafi wiadomość
await producer.ProduceAsync("order-events", new Message<string, string>
{
    Key = order.Id.ToString(), // wszystkie zdarzenia dla TEGO SAMEGO orderId trafią do TEJ SAMEJ partycji
    Value = JsonSerializer.Serialize(orderEvent)
});

To jest praktyczna konsekwencja dla Sagi - jeśli chcesz, żeby zdarzenia dotyczące jednego zamówienia były przetwarzane w kolejności (np. OrderPlaced przed PaymentCompleted), musisz użyć orderId jako klucza partycjonowania - Kafka zagwarantuje, że wszystkie zdarzenia z tym samym kluczem trafią do tej samej partycji, a więc zostaną przetworzone w kolejności publikacji.

Consumer Groups - jak wiele instancji dzieli pracę

var config = new ConsumerConfig
{
    GroupId = "inventory-service-group", // WSZYSTKIE instancje InventoryService należą do tej samej grupy
    BootstrapServers = "localhost:9092"
};

Kluczowa zasada: wewnątrz jednej consumer group, każda partycja jest przypisana do TYLKO JEDNEGO konsumenta w danym momencie - to jest naturalny mechanizm równoważenia obciążenia (load balancing) między wieloma instancjami tego samego serwisu.

Topic "order-events" (3 partycje), Consumer Group "inventory-service-group" (3 instancje InventoryService)

Partition 0 → Consumer Instance A
Partition 1 → Consumer Instance B
Partition 2 → Consumer Instance C

Jeśli uruchomisz więcej instancji InventoryService niż partycji, dodatkowe instancje pozostają bezczynne (idle) - to jest praktyczne ograniczenie, o którym trzeba pamiętać przy planowaniu skalowania: liczba partycji ograniczą maksymalny równoległy przepustowość wewnątrz jednej consumer group.

Wiele różnych consumer groups może czytać ten sam topic niezależnie - to jest przydatne, gdy zarówno InventoryService, jak i AnalyticsService chcą przetwarzać te same zdarzenia order-events, ale niezależnie od siebie:

Topic "order-events"
├── Consumer Group "inventory-service-group" - czyta i przetwarza dla logiki magazynowej
└── Consumer Group "analytics-service-group" - czyta te SAME zdarzenia, niezależnie, do raportowania

Producer - publikowanie wiadomości

public class KafkaEventBus : IEventBus
{
    private readonly IProducer<string, string> _producer;

    public async Task PublishAsync<T>(T @event) where T : class
    {
        var topic = typeof(T).Name.ToLower(); // np. "orderplacedevent"
        var payload = JsonSerializer.Serialize(@event);

        await _producer.ProduceAsync(topic, new Message<string, string>
        {
            Key = Guid.NewGuid().ToString(),
            Value = payload
        });
    }
}

Consumer - pętla nasłuchująca

public class InventoryEventConsumer : BackgroundService
{
    private readonly IConsumer<string, string> _consumer;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _consumer.Subscribe("order-events");

        while (!stoppingToken.IsCancellationRequested)
        {
            var result = _consumer.Consume(stoppingToken); // BLOKUJE, dopóki nie przyjdzie wiadomość

            try
            {
                var orderEvent = JsonSerializer.Deserialize<OrderPlacedEvent>(result.Message.Value);
                await ProcessEventAsync(orderEvent); // idempotentna logika, jak omawialiśmy przy Sadze/Outboksie

                _consumer.Commit(result); // potwierdzenie przetworzenia - "offset" przesunięty
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Błąd przetwarzania wiadomości");
                // BRAK Commit() - ta sama wiadomość zostanie dostarczona PONOWNIE
            }
        }
    }
}

Offset - "zakładka" mówiąca, gdzie konsument skończył czytać

Partition 0: [msg1, msg2, msg3, msg4, msg5]
                              ↑
                    Consumer offset = 3 (przetworzył msg1, msg2, msg3)

Kafka zapamiętuje, jaki offset (pozycję) osiągnął dany consumer group w każdej partycji - jeśli konsument padnie i wróci, kontynuuje od zapamiętanego offsetu, nie od początku. To jest mechanizm dający "at-least-once delivery" (dokładnie ta sama gwarancja, o której mówiliśmy przy Outbox Pattern) - jeśli konsument przetworzył wiadomość, ale padł przed zatwierdzeniem (Commit) nowego offsetu, ta sama wiadomość zostanie dostarczona ponownie po restarcie.

Retencja - dlaczego Kafka to nie tylko "kolejka"

Konfiguracja topicu: retention.ms = 604800000 (7 dni)

W przeciwieństwie do RabbitMQ (gdzie wiadomość jest usuwana po odebraniu przez konsumenta), Kafka przechowuje wiadomości przez skonfigurowany okres niezależnie od tego, czy zostały odebrane. To umożliwia: - Replay - nowy konsument (albo nowa consumer group) może "odtworzyć" historię zdarzeń od początku - Wielu niezależnych konsumentów czytających te same dane w różnym tempie

Kafka vs tradycyjny broker wiadomości (RabbitMQ) - kiedy który

Kafka RabbitMQ
Model Rozproszony log (retencja czasowa) Kolejka (usuwanie po odebraniu)
Przepustowość Bardzo wysoka (miliony wiadomości/s) Wysoka, ale niższa niż Kafka
Replay historii ✅ Tak (dane trzymane przez okres retencji) ❌ Nie (wiadomość usunięta po odebraniu)
Złożoność routingu Prostsza (topic + partycje) Bogatsza (exchanges, routing keys, bindings)
Typowe zastosowanie Event streaming, event sourcing, duże wolumeny logów/zdarzeń Klasyczne kolejkowanie zadań, RPC między serwisami

Podsumowanie - relacja do Sagi/Outboxa

Kafka jest naturalną technologią implementującą IEventBus w architekturze Choreography Sagi - partycjonowanie po kluczu (np. orderId) gwarantuje kolejność zdarzeń dotyczących tego samego zamówienia, consumer groups dają równoważenie obciążenia między wieloma instancjami tego samego serwisu, a mechanizm offsetów + brak automatycznego usuwania wiadomości wspiera dokładnie ten typ gwarancji dostarczenia ("at-least-once"), którego wymagaliśmy od Outbox Pattern - z koniecznością, żeby każdy konsument był idempotentny, bo ta sama wiadomość może zostać dostarczona więcej niż raz.

Postaw mi kawę