Rebus - lekki Service Bus dla .NET
Co to jest - filozofia "dumb pipes, smart endpoints"
Rebus to open-source'owa biblioteka .NET do komunikacji asynchronicznej między serwisami - koncepcyjnie w tej samej kategorii co MassTransit i NServiceBus (o którym mówiliśmy przy Sadze/Kafce), ale zaprojektowana jako znacznie prostsza i "leaner" - mniej magii, mniej zależności, prostsza konfiguracja.
Rebus realizuje zasadę, którą ThoughtWorks nazwał w 2010 roku "message bus without smarts" - sama biblioteka nie próbuje być inteligentna (routing, orkiestracja, transformacje) - to logika biznesowa w Twoich handlerach ma być "smart", a sam transport ma być maksymalnie prosty i przewidywalny ("dumb pipes, smart endpoints").
Podstawowa konfiguracja i użycie
using var activator = new BuiltinHandlerActivator();
// Rejestracja handlera - podobnie jak Handler w MediatR, o którym mówiliśmy przy CQRS
activator.Handle<OrderPlacedEvent>(async message =>
{
Console.WriteLine($"Otrzymano zamówienie: {message.OrderId}");
await ProcessOrderAsync(message);
});
Configure.With(activator)
.Transport(t => t.UseRabbitMq("amqp://localhost", "order-queue"))
.Options(o => o.SetNumberOfWorkers(5)) // liczba równoległych wątków przetwarzających wiadomości
.Start();
var bus = activator.Bus;
// Publikacja zdarzenia - dokładnie ten sam wzorzec co IEventBus z rozmowy o Sadze/Outboksie
await bus.Publish(new OrderPlacedEvent(orderId: 5));
// Wysłanie komendy do KONKRETNEGO odbiorcy (point-to-point, nie broadcast)
await bus.Send(new ReserveStockCommand(orderId: 5));
Integracja z kontenerem DI (Microsoft.Extensions.DependencyInjection)
services.AddRebus(configure => configure
.Transport(t => t.UseRabbitMq("amqp://localhost", "order-queue"))
.Routing(r => r.TypeBased().Map<ReserveStockCommand>("inventory-queue"))
);
// Handler jako zwykła klasa rozwiązywana przez DI - constructor injection, jak wszędzie
public class OrderPlacedHandler : IHandleMessages<OrderPlacedEvent>
{
private readonly IOrderRepository _repository;
public OrderPlacedHandler(IOrderRepository repository) => _repository = repository;
public async Task Handle(OrderPlacedEvent message)
{
await _repository.MarkAsPlacedAsync(message.OrderId);
}
}
To wygląda bardzo podobnie do rejestracji IRequestHandler<T> w MediatR - IHandleMessages<T> to interfejs analogiczny, tylko dla wiadomości przychodzących z zewnątrz (przez broker), nie wywoływanych bezpośrednio w procesie.
Pluggable transporty - jedna linia konfiguracji
Kluczowa zaleta Rebusa - transport jest całkowicie wymienny, logika handlerów się nie zmienia:
.Transport(t => t.UseRabbitMq(connectionString, "my-queue"))
.Transport(t => t.UseAzureServiceBus(connectionString, "my-queue"))
.Transport(t => t.UseSqlServer(connectionString, "my-queue")) // KOLEJKA jako tabela SQL - bez brokera!
.Transport(t => t.UseInMemoryTransport(network, "my-queue")) // do testów jednostkowych/integracyjnych
UseSqlServer jako transport jest szczególnie praktyczne dla mniejszych systemów - eliminuje potrzebę wdrażania osobnego brokera (RabbitMQ/Kafka), kolejka po prostu żyje jako tabela w tej samej bazie SQL Server, którą już masz. To nawiązuje do Outbox Pattern, o którym rozmawialiśmy - Rebus z transportem SQL Server w praktyce realizuje podobną ideę "natywnie".
Wbudowana obsługa Sagi
To jest bardzo praktyczne odniesienie do wcześniejszej rozmowy o Saga Pattern - Rebus ma natywny mechanizm sag (Orchestration), bez potrzeby sięgania po zewnętrzną bibliotekę:
public class OrderSaga : Saga<OrderSagaData>,
IAmInitiatedBy<OrderPlacedEvent>,
IHandleMessages<StockReservedEvent>,
IHandleMessages<PaymentFailedEvent>
{
protected override void CorrelateMessages(ICorrelationConfig<OrderSagaData> config)
{
config.Correlate<OrderPlacedEvent>(m => m.OrderId, d => d.OrderId);
config.Correlate<StockReservedEvent>(m => m.OrderId, d => d.OrderId);
config.Correlate<PaymentFailedEvent>(m => m.OrderId, d => d.OrderId);
}
public async Task Handle(OrderPlacedEvent message)
{
Data.OrderId = message.OrderId;
await Bus.Send(new ReserveStockCommand(message.OrderId));
}
public async Task Handle(StockReservedEvent message)
{
await Bus.Send(new ChargePaymentCommand(message.OrderId));
}
public async Task Handle(PaymentFailedEvent message)
{
await Bus.Send(new ReleaseStockCommand(message.OrderId)); // KOMPENSACJA
MarkAsComplete();
}
}
CorrelateMessages to mechanizm mówiący Rebusowi, jak dopasować przychodzącą wiadomość do konkretnej instancji stanu sagi (przez OrderId) - to jest ten sam problem, o którym mówiliśmy przy MassTransit State Machine (InstanceState), tylko inaczej nazwany.
Retry i Error Queue - "z pudełka"
.Options(o => o.RetryStrategy(maxDeliveryAttempts: 5, errorQueueName: "error-queue"))
Jeśli handler rzuci wyjątek, Rebus automatycznie ponawia próbę (zgodnie z ustawioną liczbą prób) - a po przekroczeniu limitu, wiadomość trafia do dedykowanej kolejki błędów, gdzie można ją później zdiagnozować/ręcznie przetworzyć, zamiast bezpowrotnie zgubić. To jest wbudowany odpowiednik tego, co przy Kafce musieliśmy budować ręcznie (logika retry + idempotencja w konsumencie).
Rebus vs MassTransit vs NServiceBus - kiedy które
| Rebus | MassTransit | NServiceBus | |
|---|---|---|---|
| Filozofia | Minimalizm, mało "magii" | Bogatszy, więcej wbudowanych wzorców | Najbardziej "enterprise", kompleksowy |
| Krzywa nauki | Niższa | Średnia/wyższa | Wyższa |
| Licencja | W pełni darmowa (open source) | Darmowa (część funkcji płatna w nowszych wersjach) | Płatna (poza małymi projektami) |
| Ekosystem/community | Mniejszy, ale aktywny | Największy w .NET, "mainstream" | Duży, komercyjne wsparcie |
| Sagi | Wbudowane, proste (Saga<TState>) |
Wbudowane, rozbudowane (state machine) | Wbudowane, bardzo rozbudowane |
| Transport SQL Server bez brokera | ✅ Tak | Ograniczone | Ograniczone |
Kiedy wybrać Rebus w praktyce
Rebus ma sens, gdy chcesz prostoty i przewidywalności ponad bogactwo funkcji - mniejsze/średnie systemy, zespoły, które nie chcą inwestować czasu w naukę złożonego frameworka, albo sytuacje, gdzie transport SQL Server jako kolejka (bez wdrażania RabbitMQ/Kafki) jest wystarczający. Dla dużych, złożonych architektur mikroserwisowych z wieloma zespołami, MassTransit ma zwykle przewagę dzięki większemu ekosystemowi i społeczności - ale sama koncepcja (publikowanie zdarzeń, handlery, sagi, retry) jest niemal identyczna między wszystkimi trzema bibliotekami, więc znajomość jednej łatwo przenosi się na pozostałe.
Podsumowanie
Rebus to lekka alternatywa dla MassTransit/NServiceBus w .NET, realizująca te same fundamentalne wzorce, o których mówiliśmy przy Sadze i Kafce - publikowanie/konsumowanie zdarzeń, retry z error queue, i wbudowane sagi do orkiestracji rozproszonych transakcji - ale z filozofią "dumb pipes, smart endpoints" kładącą nacisk na prostotę konfiguracji i minimalną liczbę zależności, aż do możliwości użycia zwykłej tabeli SQL Server jako transportu, bez potrzeby wdrażania osobnego brokera wiadomości.
Pełny przykład - Serwer i Klient
Poniżej kompletny, działający przykład: biblioteka ze wspólnymi kontraktami, serwer (konsument) i klient (nadawca), komunikujące się przez RabbitMQ.
Wspólne kontrakty wiadomości
namespace RebusDemo.Messages;
// Komenda wysyłana przez klienta do serwera (point-to-point, przez bus.Send)
public record PlaceOrderCommand(Guid OrderId, string CustomerName, decimal Amount);
// Zdarzenie publikowane przez serwer po przetworzeniu zamówienia (przez bus.Publish)
public record OrderPlacedEvent(Guid OrderId, DateTime PlacedAtUtc);
Serwer (konsument) - Program.cs
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Rebus.Bus;
using Rebus.Config;
using Rebus.Handlers;
using Rebus.Retry.Simple;
using Rebus.ServiceProvider;
using RebusDemo.Messages;
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddRebus(configure => configure
// Transport - ta kolejka to "adres" tego serwera; klient wysyła TU wiadomości
.Transport(t => t.UseRabbitMq("amqp://guest:guest@localhost:5672", "orders-queue"))
.Options(o => o.SetNumberOfWorkers(4))
// Retry - po 5 nieudanych próbach wiadomość trafia do kolejki błędów.
// Uwaga: metoda nazywała się SimpleRetryStrategy() do Rebus 7.x,
// od Rebus 8.0.0 nazywa się RetryStrategy() (identyczna funkcjonalność).
.Options(o => o.RetryStrategy(errorQueueAddress: "orders-error", maxDeliveryAttempts: 5))
);
// Automatyczna rejestracja WSZYSTKICH IHandleMessages<T> znalezionych w tym assembly
builder.Services.AutoRegisterHandlersFromAssemblyOf<Program>();
var host = builder.Build();
// Rebus.ServiceProvider rejestruje bus jako zwykły IHostedService - NIE trzeba
// (i nie da się) go "startować" żadnym UseRebus(); host.RunAsync() poniżej
// odpali wszystkie hosted services, w tym Rebusa, samo.
Console.WriteLine("Nasłuchuję na kolejce 'orders-queue'. Ctrl+C aby zakończyć.");
await host.RunAsync();
// Handler wywoływany AUTOMATYCZNIE przez Rebus, gdy przyjdzie PlaceOrderCommand
public class PlaceOrderHandler : IHandleMessages<PlaceOrderCommand>
{
private readonly IBus _bus;
public PlaceOrderHandler(IBus bus) => _bus = bus; // zwykłe DI, jak wszędzie
public async Task Handle(PlaceOrderCommand message)
{
Console.WriteLine($"[SERWER] Odebrano zamówienie {message.OrderId} od '{message.CustomerName}' na {message.Amount:C}");
await Task.Delay(300); // symulacja przetwarzania (zapis do bazy, walidacja itd.)
// Publikacja zdarzenia - każdy zainteresowany subskrybent mógłby je odebrać,
// dokładnie tak jak przy Kafce/Sadze, o których mówiliśmy wcześniej
await _bus.Publish(new OrderPlacedEvent(message.OrderId, DateTime.UtcNow));
}
}
Klient (nadawca) - Program.cs
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Rebus.Bus;
using Rebus.Config;
using Rebus.Routing.TypeBased;
using Rebus.ServiceProvider;
using RebusDemo.Messages;
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddRebus(configure => configure
// Klient NIE ma własnej kolejki wejściowej - "one-way client",
// bo tylko WYSYŁA wiadomości, nigdy nie odbiera
.Transport(t => t.UseRabbitMqAsOneWayClient("amqp://guest:guest@localhost:5672"))
// Routing - mówimy Rebusowi: "PlaceOrderCommand wysyłaj do kolejki 'orders-queue'"
// (czyli tam, gdzie nasłuchuje Serwer)
.Routing(r => r.TypeBased().Map<PlaceOrderCommand>("orders-queue"))
);
var host = builder.Build();
// Klient nie wywołuje host.RunAsync() (potrzebuje interaktywnej pętli), więc
// musi jawnie wystartować hosted services (w tym Rebusa) przez StartAsync(),
// i zamknąć je StopAsync() na końcu - nie ma tu żadnego UseRebus().
await host.StartAsync();
var bus = host.Services.GetRequiredService<IBus>();
Console.WriteLine("Wpisz nazwę klienta i Enter, aby wysłać zamówienie (albo 'exit').");
while (true)
{
Console.Write("Nazwa klienta: ");
var name = Console.ReadLine();
if (string.IsNullOrWhiteSpace(name) || name.Equals("exit", StringComparison.OrdinalIgnoreCase))
break;
var command = new PlaceOrderCommand(Guid.NewGuid(), name, Random.Shared.Next(10, 500));
// bus.Send() = wiadomość point-to-point, trafia do JEDNEJ konkretnej kolejki,
// zgodnie z mapowaniem Routing() ustawionym wyżej
await bus.Send(command);
Console.WriteLine($"[KLIENT] Wysłano zamówienie {command.OrderId} ({command.Amount:C}) -> orders-queue");
}
await host.StopAsync(); // poprawne zamknięcie hosted services (w tym Rebusa)
Co się dzieje "pod spodem"
KLIENT RabbitMQ SERWER
| bus.Send(PlaceOrderCommand) | |
|------------------------------->| kolejka "orders-queue" |
| |----------------------------->|
| | Handle(PlaceOrderCommand)
| | |
| | bus.Publish(OrderPlacedEvent)|
| |<-----------------------------|
bus.Send(command)(klient) - wiadomość point-to-point, trafia do jednej konkretnej kolejki wskazanej przezRouting().TypeBased().Map<T>(...).bus.Publish(event)(serwer) - wiadomość broadcastowa, trafi do każdego, kto się na nią zasubskrybuje (await bus.Subscribe<OrderPlacedEvent>()w subskrybencie).IHandleMessages<T>- handler wywoływany automatycznie przez Rebus; rejestracja przezAutoRegisterHandlersFromAssemblyOf<T>().
Uruchomienie
# 1. Broker (RabbitMQ) w Dockerze
docker run -d --hostname my-rabbit --name rebus-rabbit -p 5672:5672 -p 15672:15672 rabbitmq:3-management
# 2. Serwer (pierwszy terminal)
cd RebusDemo.Server && dotnet run
# 3. Klient (drugi terminal)
cd RebusDemo.Client && dotnet run
Panel administracyjny RabbitMQ (podgląd kolejek i wiadomości w locie) dostępny pod http://localhost:15672 (login/hasło: guest/guest).