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ą
IEventBusw 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.