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

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 przez Routing().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 przez AutoRegisterHandlersFromAssemblyOf<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).

Postaw mi kawę