Forem: George Papadopoulos

RabbitMQ vs Kaleidoscope: How the new broker achieves 12x message throughput (1100% speedup)

George Papadopoulos — Wed, 12 Jun 2024 09:03:21 +0000

In today's data-driven world, a fast and efficient message broker is essential for building efficient and scalable applications. In this blog post, we'll delve into a comparison between RabbitMQ, a well-established message broker, and Kaleidoscope, a new high-performance broker from the Phoesion Glow framework. We'll take a close look at their benchmark results to see how they perform in real-world scenarios.
 

Overview of RabbitMQ and Kaleidoscope

RabbitMQ is one of the most popular message brokers available.
It implements the Advanced Message Queuing Protocol (AMQP) and is renowned for its reliability, robustness, and extensive feature set, making it a staple in many production environments.

Kaleidoscope, is a new transient message broker, written entirely in .NET 8.0. It is engineered to deliver high performance as it was designed to be the backbone of Phoesion Glow, a cloud backend service development and cluster management solution. In peer-to-peer (P2P) mode, the Kaleidoscope broker acts as the routing authority, sending peer/routing updates to the clients, while the clients form a P2P mesh and can send data directly to each other, thus removing significant resource overhead (cpu/memory/networking) from the broker and improving throughput and latency for the clients.

Benchmark Results

The benchmark tests yielded the following results:

Broker	Message Throughput	Latency
Kaleidoscope (Normal)	140,000	0ms
Kaleidoscope (P2P)	710,000	0ms
RabbitMQ - Direct exchange	60,000	80ms
RabbitMQ - Topic exchange	40,000	80ms

Message Throughput: messages per second (higher is better)
Latency: time (milliseconds) for the first message to arrive

Charts

Another chart without Kaleidoscope P2P mode, comparing the performance using the same topology

These results highlight a significant performance advantage for Kaleidoscope, especially in P2P mode.

Benchmark Setup

To provide a fair comparison, both RabbitMQ and Kaleidoscope were tested under the same conditions:

Hosting: Both broker service and benchmark client run on the same machine, using the loopback interface (127.0.0.1) to ensure networking consistency.
Hardware: The same hardware setup and machine were used for both tests to ensure consistency.
Metrics: The primary metric was message throughput, measured in messages per second. The latency of the first message was also measured as a secondary metric.
Scope: The scope of the benchmark includes both broker and client libraries (as they would be used in a real-world application). For RabbitMQ the "RabbitMQ.Client" library is used.

Machine specifications:

CPU: Intel Core i7-7700K @ 4.20GHz
Memory: 32.0 GB @ 2133 MHz
OS: Windows 10 (22H2)

Benchmark design:

OS Processes: We have one broker process and one benchmark-app process.
Benchmark-app: will have 2 connections to the broker, one for the producer and one for the consumer.
Producer: spawns 40 concurrent C# Tasks that will flood-send messages to the broker.
Consumer: counts the received messages and once all messages are received the benchmark is completed.
Payload: 250 byte-array (pre-serialized) message.

Broker setup:

The brokers will have one exchange, with a binding to one queue. The queue must NOT be exclusive since in a real-world scenario there will be multiple consumers (future benchmark).
For RabbitMQ, both 'Topic' and 'Direct' exchange types were tested, while Kaleidoscope uses only a 'Topic'-like exchange.
Both brokers use transient queues and messages

Constraints:

No messages are allowed to be lost, so Acknowledgments must be enabled in both brokers.
No duplicate messages are allowed.

Performance Analysis

P2P mode

Kaleidoscope: Achieving an impressive 710,000 messages/second, making it highly suitable for applications requiring rapid, low-latency communication between endpoints.
RabbitMQ: P2P mode is not supported.

Normal mode

Kaleidoscope: Even in normal mode, Kaleidoscope's throughput of 140,000 messages/second more than doubles RabbitMQ's performance, indicating its efficiency in handling standard messaging tasks.
RabbitMQ: Handles 40.000 to 60,000 messages/second, which, while solid, is outpaced by Kaleidoscope.

Exchange type

Kaleidoscope: Only supports 'Topic' exchange
RabbitMQ: The 'Direct' exchange type, with its reduced overhead, offers better performance than the 'Topic' exchange but is suited for more specific scenarios

Use cases

While both brokers can be used similarly, each is uniquely designed with specialized features tailored to their specific use cases.

RabbitMQ: Better queuing features like persistence, dead-letter handling, and job-scheduling
Kaleidoscope: Faster messaging/RPC throughput with low latency, orchestrating clients in p2p to reduce (CPU/network) overhead, tunneling and streaming as a service-bus for cloud backend.

Topology

These diagrams show how data move in different setups:

RabbitMQ using Topic/Direct exchanges. \
Kaleidoscope in Normal mode. \
Kaleidoscope in P2P mode.\

Conclusion

These benchmarks suggest that while RabbitMQ remains a reliable and feature-rich option, Kaleidoscope offers substantial performance benefits, particularly for high-throughput applications. The higher message throughput can lead to more responsive systems and better utilization of resources, which is crucial for modern, data-intensive applications.

Kaleidoscope is not available (documented/supported) as a standalone product, but instead, it serves as the backbone of the Phoesion Glow framework by interconnecting all cloud components/services, providing significant performance benefits with its high message throughput and low latency.

As always, it's important to consider your specific requirements and test in your environment to determine the best fit for your needs. If you have any questions or insights based on your experiences with these message brokers, feel free to share them in the comments below!

More benchmarks are needed to get the full picture. Some benchmarks planned for the future include:

Test on Linux OS
Test using multiple machines with producer, broker and consumer each running on a separate machine
Test using multiple consumers.
Test clustering

Stay tuned for more insights and benchmarks as we continue to explore the capabilities of the latest messaging technologies!

Source Code

Source code is available at https://github.com/gepa21/broker_benchmark

More info about getting started with Phoesion Glow

Getting started with Phoesion Glow, the backend service development solution for human beings

George Papadopoulos — Wed, 05 Jun 2024 09:25:53 +0000

Phoesion Glow is a cloud-native framework designed for dotnet (micro-)services with features like service-bus, load-balancing, scaling, logging/tracing, monitoring and cluster management, service-to-service discovery/communication and more. It also includes a lot of GUI/CLI developer tools (eg. aspire-like dashboards) and build-in Distributed application services like persistent key-value storage (caching), Mutexes, Job-Scheduling, State-Machines, FeatureFlags etc.

To get started without installing ANY tools, you can give it as quick try using docker containers, by :

Downloading the "hello world" sample code

Start the Reactor service container using :

docker run --name reactor-2.x -d -p 80:80 -p 443:443 -p 15000-15010:15000-15010 -p 16000:16000 phoesion/phoesion.glow.reactor-dev

Run the sample (using Visual Studio)
Open http://localhost/HelloWorld/Greeter/SayHello and you should see a "Hello World" response.

What happened behind the scenes to produce that response?

The ingress/mediator service (running in container) received the http request and, using the service-bus (also in container), made an RPC call to your service (running in visual studio), that handled it and returned the response. All this happened automatically, without needing to configure any of them! and it's because all components were build from the ground-up to work together as part of a complete (opinionated) solution

To get the full developer experience, including developer dashboard, i recommend installing the tools:

Stop/Delete the reactor container from docker (it will not be needed anymore)
Close Visual Studio (so new templates can be installed)
Download and install the tools (Blaze)

Now, open up the sample code again in Visual Studio and run the service. The developer dashboard will pop-up giving your visibility to you service metrics, structured logging, tracing and more. Your are now fully setup to start developing services using Phoesion Glow!

There a lot of samples demonstrating the capabilities of Glow, have a look and try them out!

Some notable samples include :

1_REST : a lot of examples for creating your web APIs
2_Interop : service to service communication.
10_AspHosting : running ASP services in Glow
0b_Logging : structured logging sample
27_* - 31_* (AppXXX services) : distributed application services like job scheduling, state machines, mutexes and caches.

If you find it interesting and would like to know more information and how to run/deploy your services in your cloud or on-premises let me know.

Screenshots

This is a screenshot of the developer dashboard

This is a screenshot of Blaze, the service cluster management dashboard

Create JSON Web Tokens for development and testing

George Papadopoulos — Wed, 26 Apr 2023 16:32:03 +0000

It can be challenging to test an API that requires authentication through a JSON Web Token (JWT). To obtain a valid access token that can be used with your API, you typically need to setup/use an entire identity and access management system.

Using the dotnet-devjwt tool you can simplify this process. It allows you to generate custom JSON Web Tokens that can be used during development and (system) testing of your JWT-Protected API endpoints.

Let's go through the steps of using this new tool.
 

Getting started

Let's create a small ASP.NET Core application, configured to use JTW Bearer authentication:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication()
                .AddJwtBearer(o =>
                {
                    o.Authority = "https://login.microsoftonline.com/common";
                    o.Audience = "myApi";
                });

builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthorization();

app.MapGet("/protected", (ClaimsPrincipal user) => $"Hello {user.FindFirst(ClaimTypes.Email)?.Value}")
   .RequireAuthorization();

app.Run();

To test our endpoint we would need a valid token from our authority (in this case login.microsoftonline.com). Getting this token is not always easy or even possible. This becomes even more difficult when we want to run isolated system tests in different environments.

Let's use the DevJwt lib/tool to create a token for local development.
 

Using Phoesion.DevJwt

Install the dotnet tool

dotnet tool install --global phoesion.devjwt.cli

Generate token using

dotnet devjwt create myApi --email user@mail.com

Configure your service appsettings.Development.json

"Authentication": {
   "Schemes": {
      "Bearer": {
         "ValidIssuer": "phoesion.devjwt",
         "SigningKeys": [
          {
             "Issuer": "phoesion.devjwt",
             "Value": "c29tZV9kZWZhdWx0X2tleV9mb3JfZGV2cw=="
          }
         ]
      }
   }
}

Now we can call our API by passing the generated JWT token:
curl -i -H "Authorization: Bearer {token}" http://localhost:5256/protected

You can find more samples here

If you want to learn more, check out the project documentation

Happy Coding!

Join Discord Group

Running microservices using Reactor container - Phoesion Glow

George Papadopoulos — Mon, 24 Apr 2023 10:40:29 +0000

What is Phoesion Glow

Phoesion Glow is a framework for developing cloud microservices using c#. It offers out-of-the-box API-Gateway, Service-bus, service hosts, Kubernetes operators and more! All components have been designed to work together seamlessly and provide a uniform and streamlined experience for developing, deploying and managing your cloud services.

What is Phoesion Glow Reactor

Phoesion Glow Reactor is a standalone meta-app that includes all entities needed to run a Glow cloud setup, inside a single process/app. This includes the Prism (API Gateway), the Kaleidoscope (Service-Bus), Lighthouse (Command-and-Control) and Firefly (business logic service host/supervisor). Using Reactor you can easily develop your services locally without setting up a bunch of components.

Using Containers

Normally, when you install Phoesion Glow Blaze the Reactor is also installed as a system service. This is great most of the time but in many cases, when you want to evaluate the samples, run services in a non-developer PC, or just use a different version of Reactor, docker and containers come to the rescue. With one simple command, you can have the Reactor container up and running on your machine so your services can connect to it and attach on the service bus (to start handling incoming requests).

To start a Phoesion Glow Reactor container run :

docker run --name reactor -d -p 80:80 -p 443:443 -p 15000-15010:15000-15010 -p 16000:16000 phoesion/phoesion.glow.reactor-dev

This will start the reactor and expose the appropriate ports (http(s) and service-bus)

Running a sample

Now that our container is up and running, we can run some samples!

1. Clone the GitHub sample repo :

git clone https://github.com/Phoesion/Glow-Samples.git

2. Start the 1_Rest sample that demonstrates basic web api concepts/capabilities :

Open the solution 1_REST\Sample_1_REST.sln
Start Foompany.Services.SampleService1 and Foompany.Services.SampleService2 projects (our two microservices)

3. Test our services using the URLs :

Summary

In this post, we saw how easy it is to create a Glow setup that includes the api-gateway, service-bus and more using Reactor and docker containers. With the Reactor container running we can launch our services locally for developing/testing/debugging or just evaluating them, without installing all the Phoesion Glow tools on our system.

For more information about Phoesion Glow, you can check out :

Happy coding!

Part 2 - Deploy your services

George Papadopoulos — Tue, 28 Mar 2023 07:45:35 +0000

Learn how to setup a Linux server and deploy your cloud services

In this 20 minute video tutorial, you will learn how to :

Setup a Linux server with Phoesion Glow
Deploy your services
Manage and Monitor their health and performance
Setup SSL using let's encrypt

Phoesion Glow is a framework for developing cloud microservices using c#. It offers out-of-the box Mediators/Gateway, Service-bus, service hosts, Kubernetes operators and more! All components have been designed to work together seamlessly and provide a uniform and streamlined experience for developing, deploying and managing your cloud services.

The series, aims to teach the basic concepts, setups and tools of Phoesion Glow.

New video tutorial series - Phoesion Glow basics

George Papadopoulos — Wed, 22 Mar 2023 12:22:33 +0000

The first video of the new "Phoesion Glow basics" series is up!
Learn how to create your first C# web API micro-service!

Watch it now at Youtube!

Phoesion Glow is a new framework for developing cloud microservices using C#. It offers out-of-the box Mediators/Gateway, Service-bus, service hosts, Kubernetes operators and more! All components have been designed from the ground up to work together seamlessly and provide a uniform and streamlined experience for developing, deploying and managing your cloud services.

The series, aims to teach the basic concepts, setups and tools of Phoesion Glow. Playlist available at Youtube!

Using ASP.Net Core in Phoesion Glow

George Papadopoulos — Tue, 14 Mar 2023 11:14:46 +0000

Phoesion Glow is a microservice development framework that offers a complete solution for creating, deploying, and managing your microservices. While Phoesion Glow offers a glow-native SDK for writing services, many times we need to use ASP.Net specific features or add a service that is already written in ASP.Net.

In this article, we will focus on creating Glow microservices using the ASP.Net framework.

Prerequisites / Preparation

For developing Phoesion Glow services we need a Windows machine with Visual Studio 2019/2022 and Phoesion Glow Blaze for Windows installed

Creating a new service

1. Create a new Solution

Create a new solution using Visual Studio with a Firefly ASP.NET Core Service Project project.

[NOTE]
If you can't find the Firefly ASP.NET Core Service Project template, make sure you have Phoesion Glow Templates visual studio extension installed. If not you can get it from the Visual Studio Marketplace

2. Configure new Project

Name your new project and solution :

Project name : Foompany.Services.MyAspService
Location : <Set your location>
Solution name : Foompany.Services

The `AspFireflyService` class

Notice that your ServiceMain class now derives from AspFireflyService instead of the basic FireflyService.
The AspFireflyService class provides the necessary IServer implementations that will hook into the ASP.Net framework and host the ASP.Net stack on top of Phoesion Glow.
Think of it like a replacement of Kestrel, that instead of handling requests from sockets, it handles request from the Phoesion Glow framework.

Test your services

To test that your services are up and running open a browser and go to one of the following :

Changing the Service name (base path)

As a part of the Phoesion Glow project, your microservice MUST have a service name so the API Gateway system can route the request to the proper service.
Like native Firefly Services this can be specified using the [ServiceName("XXX")] attribute on the ServiceMain.cs class.
Change this to your desired name, for example just MyAspService (without the full assembly namespace that was added by the templates)

Run the project again and test using the following :

Summary

In this article, we demonstrated how easy it is to create a new ASP.NET microservice that can be deployed/hosted in our Phoesion Glow setup.
We can now take full advantage of Phoesion Glow including the out-of-the-box Mediator, API Gateway, Service-Bus and Deployment/Managing/Monitoring capabilities.

For more information, you can dive into the documentation and sample repo.

Forem: George Papadopoulos

RabbitMQ vs Kaleidoscope: How the new broker achieves 12x message throughput (1100% speedup)

Overview of RabbitMQ and Kaleidoscope

Benchmark Results

Charts

Benchmark Setup

Machine specifications:

Benchmark design:

Broker setup:

Constraints:

Performance Analysis

P2P mode

Normal mode

Exchange type

Use cases

Topology

Conclusion

Source Code

Getting started with Phoesion Glow, the backend service development solution for human beings

Screenshots

Create JSON Web Tokens for development and testing

Getting started

Using Phoesion.DevJwt

Running microservices using Reactor container - Phoesion Glow

What is Phoesion Glow

What is Phoesion Glow Reactor

Using Containers

Running a sample

1. Clone the GitHub sample repo :

2. Start the 1_Rest sample that demonstrates basic web api concepts/capabilities :

3. Test our services using the URLs :

Summary

Part 2 - Deploy your services

New video tutorial series - Phoesion Glow basics

Using ASP.Net Core in Phoesion Glow

Prerequisites / Preparation

Creating a new service

1. Create a new Solution

2. Configure new Project

The AspFireflyService class

Test your services

Changing the Service name (base path)

Summary

The `AspFireflyService` class