aminofox/robust repository overview

⁠Robust - Distributed Message Queue & Streaming Platform

⁠Welcome to Robust! 👋

Robust is a modern Distributed Message Queue and Streaming Platform, designed to handle millions of messages with low latency, high reliability, and flexible scalability.

⁠🎯 What is Robust?

Robust is a message broker that enables applications to communicate with each other through sending and receiving messages. Built with Go, Robust provides:

• Message Queue: Message queuing with guaranteed delivery
• Pub/Sub: Publish-Subscribe pattern for real-time streaming
• Consumer Groups: Parallel processing with automatic load balancing
• Message Persistence: Long-term message storage with replay capability
• Distributed Architecture: Runs on clusters with replication and fault tolerance

⁠✨ Key Features

⁠🚀 High Performance

• Low Latency: 1-20ms end-to-end latency
• High Throughput: Millions of messages per second
• Zero-copy: Optimized network and disk I/O
• Batch Processing: Send/receive multiple messages at once

⁠🔒 Reliable & Durable

• Replication: Multi-replica for high availability
• Durability: Messages persisted to disk
• Acknowledgment: Ensures messages are processed successfully
• Automatic Failover: Automatic node switching on failure

⁠📊 Easy to Manage

• Built-in Metrics: Prometheus metrics out-of-the-box
• Health Checks: HTTP endpoints for monitoring
• Grafana Dashboards: Visualize metrics and performance
• Simple Config: Easy-to-understand JSON configuration

⁠🛠️ Developer-friendly

• Go SDK: Full-featured, production-ready SDK
• Simple API: Easy to use, easy to learn
• Type-safe: Strongly-typed messages
• Context Support: Cancellation and timeouts

⁠🏗️ Architecture

Robust uses a distributed broker architecture with key components:

┌─────────────────────────────────────────────┐
│           Robust Cluster                    │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │  Broker  │  │  Broker  │  │  Broker  │  │
│  │  Node 1  │  │  Node 2  │  │  Node 3  │  │
│  └──────────┘  └──────────┘  └──────────┘  │
│       │             │             │         │
│       └─────────────┴─────────────┘         │
│              Replication                    │
└─────────────────────────────────────────────┘
         ▲                      │
         │                      ▼
  ┌─────────────┐        ┌─────────────┐
  │  Producers  │        │  Consumers  │
  └─────────────┘        └─────────────┘

Core Concepts:

• Topics: Logical channels to categorize messages
• Partitions: Divide topics for parallelization
• Producers: Applications that send messages
• Consumers: Applications that receive and process messages
• Consumer Groups: Groups of consumers processing in parallel

⁠💡 Use Cases

Robust is suitable for many scenarios:

⁠📱 Event-Driven Architecture

• User actions, system events
• Audit logs, activity streams
• Real-time notifications

⁠🔄 Data Integration

• Microservices communication
• Data pipelines between services
• CDC (Change Data Capture)

⁠📊 Real-time Analytics

• Click stream analysis
• IoT sensor data processing
• Real-time dashboards

⁠⚙️ Background Processing

• Async task queues
• Email/SMS sending
• Image/video processing

⁠📖 Documentation

⁠Getting Started with Robust

1. What is Robust?⁠ - Platform details
2. Key Features⁠ - Highlight features
3. Architecture⁠ - System design
4. Use Cases⁠ - Usage scenarios

⁠Using Go SDK

• SDK Installation⁠ - Setup and configuration
• Producer Guide⁠ - Send messages
• Consumer Guide⁠ - Receive messages
• Admin Client⁠ - Manage topics and cluster

⁠Real-world Examples

• Simple Producer⁠ - Send messages
• Simple Consumer⁠ - Receive and process messages

⁠🌐 Go SDK (Open Source)

Robust Go SDK is open source and free to use:

go get github.com/aminofox/robust-go-sdk

Repository: github.com/aminofox/robust-go-sdk⁠

⁠🌐 Other Languages

📙 Tiếng Việt⁠ - Vietnamese Documentation