Apache Kafka i Architektura Wywoływana Zdarzeniami: Dlaczego Powtarzanie Historii Jest Wyróżniającym Siłą

Log, a nie kolejka

Klasyczne systemy wiadomości, takie jak RabbitMQ lub ActiveMQ, implementują model odbierania i usuwania: wiadomość jest opublikowana, konsument ją odbiera, konsument potwierdza jej odbiór, a kolejka usuwa ją. Po odbiorze wiadomość zniknie. Ten model działa dobrze w klasycznej sytuacji użycia, polegającej na rozprowadzaniu prac do wykonania dokładnie raz — zadanie dla zadań wykonywanych w tle jest przykładem textbook — ale strukturalnie nie może wspierać drugiego konsumenta, który chciałby później zobaczyć wszystko, co się stało, ponieważ zadaniem kolejki jest właśnie usunięcie wiadomości po ich obsłużeniu.

Decyzja podstawowa wdrażana przez Kafka polega na modelowaniu magazynu wiadomości jako append-only, niezmiennego dziennika z podziałem na grupy brokerów, gdzie wiadomości (Kafka nazywa je rekordami) są przechowywane przez określony czas — najczęściej siedem dni, ale często ustawiane do tygodni, miesięcy lub nawet bez ograniczeń dla krytycznych strumieni zdarzeń — niezależnie od tego, czy którykolwiek konsument je przeczytał. Konsumenty nie usuwają rekordów z dziennika podczas odczytu; zamiast tego każdy konsument samodzielnie śledzi swoją pozycję odczytu (offset) w każdej grupie, i może cofnąć ten offset do przeczytania historii lub przesunąć go naprzód, aby skoczyć dalej, całkowicie niezależnie od tego, co inni konsumenty robią. Ta jedna architektoniczna decyzja — traktowanie magazynu wiadomości jako trwałego, powtarzalnego dziennika zamiast tymczasowego kolejki pracy — jest korzeniem większości właściwości, które odmiń Kafka od klasycznego systemu wiadomości. Warto być jasnym: model Kafka stanowi prawdziwe compromisowe rozwiązanie: wymaga większej ilości miejsca na przechowywanie (przechowujesz dane, które inne systemy by zrzucały) i przesuwa odpowiedzialność za śledzenie pozycji odczytu na konsumenta, w zamian za możliwości, których nie można oferować żadnej kolejce usuwającej wiadomości po odczytaniu.

Dlaczego powtarzalność jest kluczowym elementem

Praktyczne korzyści wynikające z modelu opartego na dzienniku pojawiają się w chwili, gdy coś dalszego potrzebuje historii, której kolejka usunięta przy odczytaniu już nie zachowa. Jeśli nowa drużyna analizująca dołączy do firmy i chce zbudować panel statystyczny na podstawie sześciu miesięcy zdarzeń zamówień, temat Kafka przechowujący tę historię pozwala im tylko na uruchomienie nowej grupy odczytawców i przeczytanie od początku dziennika — nie ma potrzeby przewidzieć istnienia tego odczytawcy, gdy zdarzenia były pierwotnie wygenerowane. Jeśli odczytawca dalszego ma błąd, który uszkodzi jego dane pochłannicze dla ostatnich trzech dni, naprawa polega na cofnięciu grupy odczytawców offsetu o trzy dni i pozwoleniu mu ponownie przetworzyć te same zdarzenia z dziennika, prawidłowo tym razem, zamiast konieczności użycia osobnego mechanizmu kopii zapasowej i powtarzalnej dodanego później. Jeśli firma chce przyjąć nowy usługi — na przykład model wykrywania fałszywych transakcji, który musi być treningowy i testowany na podstawie historii zdarzeń transakcyjnych przez rok przed wdrożeniem, zdarzenia nadal są przechowywane w dzienniku (lub w długoterminowej hierarchicznej pamięci podręcznej Kafka), gotowe do odczytania na potrzeby nowego usługi, całkowicie odłączone od przepływającego w czasie rzeczywistym ruch produkcji nadal przechodzącego przez ten sam temat.

Ta powtarzalność jest również przyczyną, dla której Kafka naturalnie stanowi ramka do architektury źródła zdarzeń, gdzie dziennik zdarzeń traktowany jest jako główny źródło prawdy i dowolny widok bazy danych (aktualna bilans klienta, aktualny status zamówienia) jest rozumiany jako projekcja, która w teorii może zawsze zostać odtworzona przez powtarzanie dziennika zdarzeń od początku. Traditionalny kolejka wiadomości nie może wspierać tego wzoru wcale, ponieważ do chwili, gdy zauważasz konieczność odtworzenia projekcji, podstawowe wiadomości, które ją pierwotnie tworzyły, już są stracone.

Podział i uporządkowanie: mechanizm za tą wysoką przepustowością Kafky

Kafka osiąga swoją wysoką przepustowość poprzez podzielenie każdego tematu na wiele partycji, każda z których jest niezależnym, uporządkowanym dziennikiem logów rozproszonym po klastrze serwerów. Producent piszący do tematu przypisuje każdego rekordu do partycji, zwykle poprzez hashowanie klucza rekordu (np. identyfikatora klienta lub zamówienia), co gwarantuje, że wszystkie rekordy dzielące się tym samym kluczem zawsze upadają w tej samej partycji i są zatem zawsze czytane w porządku, względem siebie. Jest to ważny i często niezrozumiały szczegół: Kafka gwarantuje uporządkowanie wewnątrz partycji, a nie na całym temacie. Dwa rekordy o różnych kluczach upadające w innych partycjach nie przekazują żadnej gwarancji uporządkowania względem siebie, co jest świadomą kompromisem — całe uporządkowanie na poziomie całego tematu wymagałoby przepływu każdego zapisu przez pojedynczy sekwencyjny dziennik logów, co dokładnie jest blokadą przepustowością, której podział ma usunąć.

To dlatego wybór klucza jest jednym z najważniejszych decyzji projektowych w systemie opartym na Kafce: wyborzanie klucza o identyfikatorze klienta zapewnia, że każdy zdarzenie dla danego klienta jest przetwarzane w prawidłowym porządku względem dowolnego konsumera obsługującego tę partycję, podczas gdy nieprawidłowy wybór klucza (lub brak klucza, który powoduje rozdział partycji na podstawie rotacji) przekazuje gwarancje uporządkowania, o które aplikacja może naprawdę zależeć. Na stronie konsumpcji grupy konsumentów rozszerzają tę samą logikę podziału: wielu wystąpień konsumera może dołączyć do grupy i Kafka automatycznie dzieli partycje tematu między nimi, więc temat o 12 partycjach i grupa konsumera z 4 wystąpieniami daje każdemu wystąpieniu 3 partycje do przetworzenia niezależnie i w paralelu. Ta alokacja balansuje się automatycznie, jeśli wystąpienie zderzy się lub nowe wystąpienie dołączy, co daje Kafce skalowalność poziomu konsumpcji oraz automatyczną przełączanie w przypadku awarii bez żadnej logiki koordynacji na poziomie aplikacji.

Gdzie pasuje Kafka, a gdzie nie

Nie jestem universalnym zastępcą tradycyjnych kolejek, i rozumienie trade-offa jest kluczowe dla poprawnego wyboru. Model usuwania elementów z kolejki przy odczytaniu jest prostszy do zrozumienia w przypadku pureskryptów zadaniowych, gdzie nigdy nie będzie potrzebny historii i koszt przechowywania rzeczywiście ma znaczenie, a tradycyjne kolejki oferują bogatsze semantyki routingu na poziomie wiadomości (kolejniki priorytetowe, skomplikowane zasady routingu oparte na treści wiadomości), które model podziału i grup konsumentów Kafka nie bezpośrednio dostarcza. Kafka wprowadza również rzeczywistą złożoność operacyjną — prowadzenie i dostosowywanie rozproszonych, podzielonych, powtarzalnych klastrów dzienników jest cięższy obciążenie operacyjne niż uruchomienie jednej instancji RabbitMQ, a niepoprawny wybór liczb podziałów, zasad przechowywania i kluczy może stworzyć problemy (za mało podziałów ogranicza równoległość; za dużo powoduje obciążenie brokera; złe wybranie klucza tworzy "gorące podziały", gdzie obciążenie jest nieprawidłowo rozłożone po klastrze), które są trudne do naprawienia po już istniejącym znacznym ruchu produkcyjnym w temacie.

Pattern, który zaczął się formować w większości architektur danych na skalę, polega na użyciu Kafka jako konkretnego stabilnego i powtarzalnego podklatku łączącego wiele niezależnych producentów i konsumentów — nerwowej systemu przez który przepływa do każdego systemu potrzebującego, w tym bezpośrednio do frameworków stream-processingowych jak Kafka Streams lub Flink dla rzeczywistego agregowania, oraz do wektorowych baz danych, magazynów cech i magazynów danych pokrytych w innych sekcjach tego stosu infrastruktury — podczas zachowywania prostszych kolejek wiadomości do zadań skupionych na optymalizacji, gdzie powtarzalność i rozproszenie wielu konsumentów nigdy nie byłyby potrzebne w pierwszej kolejności.

Często zadawane pytania