Frequently Asked Questions

This guide answers common questions about VibeMQ.

General Questions 

What is VibeMQ?

VibeMQ is a simple but reliable message broker for .NET applications. It supports:

Publish/subscribe (pub/sub)
Queues with delivery guarantees
Automatic reconnections
Token-based authentication
TLS/SSL encryption
Health checks for orchestrators

How is VibeMQ different from RabbitMQ/Kafka?

VibeMQ vs RabbitMQ:

VibeMQ is simpler to configure and use
Does not require external dependencies (databases, etc.)
Written in C# for .NET ecosystem
Less functionality, but sufficient for most scenarios

VibeMQ vs Kafka:

VibeMQ is not a distributed event log
Does not support persistent storage (in current version)
Simpler to deploy and use
Better suited for task queues and real-time notifications

When to use VibeMQ?

Good scenarios:

Task queues for background processing
Notifications between microservices
Real-time updates
Event-driven architecture
Distributed systems on .NET

Not suitable for:

Storing large volumes of data
Real-time streaming (use Kafka)
Complex message routing (use RabbitMQ)
Transactional messages

What .NET versions are supported?

.NET 8.0 (main target platform)
.NET 10.0 (support planned)

Technical Questions 

How does delivery guarantee work?

VibeMQ uses acknowledgment (ACK) mechanism:

Broker sends message to subscriber
ACK wait timer starts
Subscriber processes message and sends ACK
If ACK not received — retry delivery
After exhausting attempts — Dead Letter Queue

What happens when server restarts?

Current version:

Messages in queues are lost (in-memory storage)
Connections must be restored

Planned:

Persistence layer for message storage
State recovery after restart

How to scale VibeMQ?

Horizontal scaling:

Run multiple server instances
Use load balancer
Clients connect to nearest server

Vertical scaling:

Increase limits (MaxConnections, MaxQueueSize)
Add resources (CPU, RAM)

Planned:

Clustering for automatic scaling

How to ensure security?

Authentication:

.UseAuthentication("my-secret-token")

TLS encryption:

.UseTls(options => {
    options.Enabled = true;
    options.CertificatePath = "/path/to/cert.pfx";
})

Rate limiting:

.ConfigureRateLimiting(options => {
    options.Enabled = true;
    options.MaxConnectionsPerIpPerWindow = 100;
})

What delivery modes are supported?

Round-robin — to each subscriber in turn
Fan-out with ACK — to all with acknowledgment
Fan-out without ACK — to all without acknowledgment
Priority-based — by priority

How does Dead Letter Queue work?

DLQ stores messages that could not be delivered. Enable it when creating a queue (server queue defaults do not include DLQ options):

await client.CreateQueueAsync("my-queue", new QueueOptions {
    EnableDeadLetterQueue = true,
    MaxRetryAttempts = 3
});

Reasons for DLQ:

Exceeded delivery attempt count
Message TTL expired
Deserialization error
Exception in handler

Deployment 

How to run in Docker?

Dockerfile:

FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
EXPOSE 2925 2926
COPY . .
ENTRYPOINT ["dotnet", "VibeMQ.Server.dll"]

Run:

docker build -t vibemq-server .
docker run -p 2925:2925 -p 2926:2926 vibemq-server

How to use with Kubernetes?

Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vibemq
spec:
  replicas: 3
  selector:
    matchLabels:
      app: vibemq
  template:
    spec:
      containers:
      - name: vibemq
        image: vibemq-server:latest
        ports:
        - containerPort: 2925
        - containerPort: 2926
        livenessProbe:
          httpGet:
            path: /health/
            port: 2926
          initialDelaySeconds: 10
          periodSeconds: 10

How to configure for production?

Recommendations:

var broker = BrokerBuilder.Create()
    .UsePort(2925)
    .UseAuthentication(Environment.GetEnvironmentVariable("VIBEMQ_TOKEN"))
    .UseMaxConnections(5000)
    .ConfigureQueues(options => {
        options.DefaultDeliveryMode = DeliveryMode.FanOutWithAck;
        options.MaxQueueSize = 100_000;
    })
    .ConfigureRateLimiting(options => {
        options.Enabled = true;
        options.MaxConnectionsPerIpPerWindow = 100;
        options.MaxMessagesPerClientPerSecond = 5000;
    })
    .UseTls(options => {
        options.Enabled = true;
        options.CertificatePath = "/etc/ssl/vibemq.pfx";
    })
    .ConfigureHealthChecks(options => {
        options.Enabled = true;
        options.Port = 2926;
    })
    .Build();

Performance 

What is VibeMQ performance?

Benchmarks:

10,000+ messages/sec on single node
Latency < 10ms for 95% of messages
Support for 1000+ simultaneous connections

Factors affecting performance:

Message size
Number of subscribers
Delivery mode
Network latency

How to optimize performance?

On server:

.UseMaxConnections(5000)  // Increase limit
.ConfigureQueues(options => {
    options.MaxQueueSize = 100_000;  // Larger queue
})
// OverflowStrategy is set per-queue when creating with QueueOptions

On client:

new ClientOptions {
    KeepAliveInterval = TimeSpan.FromSeconds(60),  // Less frequent PING
    CommandTimeout = TimeSpan.FromSeconds(5)  // Lower timeout
}

General recommendations:

Use batching for publishing
Optimize message handlers
Monitor performance metrics

Security 

How secure is token authentication?

Recommendations:

Use complex tokens (32+ characters)
Store tokens in secure location (Key Vault, Secrets Manager)
Rotate tokens periodically
Use different tokens for different environments

Warning

Token authentication is suitable for internal security. For public APIs use OAuth2/OIDC.

Do I need to use TLS?

Yes, if:

Messages contain sensitive data
Network is untrusted
Security compliance required

No, if:

All services in trusted network
TLS terminates at load balancer level

How to protect against DDoS?

Rate limiting:

.ConfigureRateLimiting(options => {
    options.Enabled = true;
    options.MaxConnectionsPerIpPerWindow = 50;
    options.MaxMessagesPerClientPerSecond = 100;
})

Additionally:

Use firewall
Limit number of connections
Monitor anomalies

Integration 

How to use with ASP.NET Core?

using VibeMQ.Server.DependencyInjection;
using VibeMQ.Client.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Server
builder.Services.AddVibeMQBroker(options => {
    options.Port = 2925;
});

// Client
builder.Services.AddVibeMQClient(settings => {
    settings.Host = "localhost";
    settings.Port = 2925;
});

var app = builder.Build();
await app.RunAsync();

How to use with Worker Service?

using VibeMQ.Client.DependencyInjection;

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services => {
        services.AddHostedService<Worker>();
        services.AddVibeMQClient(settings => {
            settings.Host = "localhost";
            settings.Port = 2925;
        });
    })
    .Build();

await host.RunAsync();

Can I use with other languages?

Current version: Only .NET clients

Planned:

Clients for Java, Python, Node.js
AMQP/MQTT protocol support

Troubleshooting 

Why are messages lost?

Causes:

Server restarted (in-memory storage)
Message TTL expired
Queue size exceeded

Solution:

// Server defaults: limit queue size
.ConfigureQueues(options => {
    options.MaxQueueSize = 100_000;
})
// When creating queues: use QueueOptions with EnableDeadLetterQueue, MessageTtl

Why high latency?

Causes:

Server overload
Slow handlers
Network issues

Solution:

Optimize handlers
Increase server resources
Check network

Why frequent disconnections?

Causes:

Network issues
Keep-alive timeout
Server restarting

Solution:

new ClientOptions {
    ReconnectPolicy = new ReconnectPolicy {
        MaxAttempts = 50,  // Increase attempts
        UseExponentialBackoff = true
    },
    KeepAliveInterval = TimeSpan.FromSeconds(30)  // Check keep-alive
}

Next Steps 

Quick Start — quick start
Troubleshooting — troubleshooting
Examples — usage examples