Asynchronous communication using queues, topics, and events to decouple services and enable scalable, resilient architectures.

What delivery guarantees exist?

At-most-once, At-least-once, and Exactly-once; each has trade-offs in latency, complexity, and potential duplicates.

When should I use messaging?

When you need decoupling, async processing, event-driven flows, or load leveling. Avoid messaging if simple RPC suffices or strict real-time consistency is required.

messaging

skill

npx machina-cli add skill Fujigo-Software/f5-framework-claude/messaging --openclaw

Files (1)

SKILL.md

3.8 KB

Messaging Skills

Overview

Asynchronous communication patterns for building scalable, decoupled distributed systems. Messaging enables services to communicate without direct coupling, improving reliability and scalability.

Messaging Types

Type	Description	Use Case	Examples
Point-to-Point	One sender, one receiver	Task distribution	RabbitMQ, SQS
Pub/Sub	One sender, many receivers	Event broadcasting	Kafka, Redis Pub/Sub
Request/Reply	Synchronous over async	RPC-style calls	RabbitMQ RPC
Event Streaming	Ordered, replayable log	Event sourcing	Kafka, Kinesis

Delivery Guarantees

Guarantee	Description	Trade-off
At-most-once	Fire and forget	May lose messages
At-least-once	Retry until acknowledged	May have duplicates
Exactly-once	Deduplicated delivery	Complex, higher latency

When to Use Messaging

Use Messaging For

Decoupling services
Async task processing
Event-driven architectures
Load leveling and buffering
Cross-service communication

Avoid Messaging When

Simple request/response is sufficient
Strong consistency is required
Real-time response is critical
System complexity isn't justified

Quick Reference

Message Broker Comparison

Feature	RabbitMQ	Kafka	SQS	Redis
Model	Queue	Log	Queue	Queue/Pub-Sub
Ordering	Per-queue	Per-partition	FIFO option	Per-queue
Persistence	Durable	Always	Always	Optional
Replay	No	Yes	No	No
Throughput	High	Very High	High	Very High
Latency	Low	Low	Medium	Very Low

Common Patterns

Producer → Queue → Consumer (Point-to-Point)
Producer → Exchange → Queue → Consumer (RabbitMQ)
Producer → Topic → Partition → Consumer Group (Kafka)
Publisher → Channel → Subscribers (Pub/Sub)

Integration with F5

# In f5-config.yaml
messaging:
  broker: rabbitmq
  queues:
    - name: orders
      durable: true
      dlq: orders-dlq
  events:
    - topic: order.placed
      retention: 7d

Related Skills

Architecture - System design patterns
Database - Transactional outbox
DevOps - Message broker deployment

Source

git clone https://github.com/Fujigo-Software/f5-framework-claude/blob/main/plugins/f5-core/skills/messaging/SKILL.mdView on GitHub

Overview

Messaging enables services to communicate asynchronously, decoupling components to improve reliability and scalability. It covers point-to-point queues, pub/sub, request/reply, and event streaming to handle different workloads and guarantees.

How This Skill Works

Producers publish messages to brokers, which route to consumers via queues, topics, or channels. Delivery guarantees such as at-most-once, at-least-once, and exactly-once govern re-delivery and deduplication, while patterns like the Outbox and retry strategies help manage failures across distributed components.

When to Use It

Decoupling services for resilience and scalability
Async task processing and background jobs
Event-driven architectures and real-time event broadcasting
Load leveling and buffering between services
Cross-service communication with loose coupling

Quick Start

Step 1: Identify message types (commands, events, queries) and business events
Step 2: Choose a messaging model (Point-to-Point, Pub/Sub, or RPC-like) and determine delivery guarantees
Step 3: Prototype with a broker (e.g., RabbitMQ, Kafka, SQS), define queues/topics, and implement producers/consumers

Best Practices

Design messages with stable schemas and careful versioning
Implement robust error handling, retries, and dead-letter queues
Monitor latency, throughput, and failure modes with observability
Ensure idempotent consumers to safely reprocess messages
Choose delivery guarantees and ordering based on use case and complexity

Example Use Cases

RabbitMQ-based task queues for background processing
Kafka-based event streaming for event sourcing
Redis Pub/Sub for simple broadcast patterns
AWS SQS for managed queuing in cloud apps
Outbox pattern to guarantee reliable event publishing