Understanding CQRS Pattern in Microservices: Examples and Practical Use Cases

The Command Query Responsibility Segregation (CQRS) pattern is a powerful architectural approach that separates the operations that modify data (Commands) from those that read data (Queries). In the context of microservices, CQRS facilitates better data sharing and synchronization between services, while also improving scalability and performance.

This article explores how to apply CQRS to share data between two microservices, such as an Order Service and a Product Service, and provides practical examples to illustrate its use.

1. Understanding CQRS in Microservices

Core Concept

• Command Side: Handles requests that create, update, or delete data. This side focuses on maintaining consistency when performing write operations.
• Query Side: Optimized for read operations and often uses a separate data model tailored for querying.

In a microservices architecture, each service can implement its own CQRS pattern to manage internal data while sharing data with other services through events, queries, or replicated views.

2. Examples of Sharing Data Between Microservices Using CQRS

Scenario: Order Service and Product Service

Imagine you have two microservices:

1. Order Service: Manages orders and contains data like Order ID and Product ID.
2. Product Service: Manages product details such as Product Name and Description.

When retrieving orders, you need to include the product name and description. Here's how CQRS can help:

2.1 Using Events for Data Synchronization

Setup

• Order Service:
• Product Service:

Workflow

1. When a product is updated in the Product Service, an event (ProductUpdated) is published to an event bus (e.g., RabbitMQ, Kafka).
2. The Order Service subscribes to this event and updates a local copy of the product data (e.g., name and description) in its Read Model.
3. When retrieving orders, the Order Service reads the product details from its local database.

.NET Example

// Product Service: Publishing an Event
public class ProductUpdatedEvent
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
}

public class ProductService
{
    public void UpdateProduct(Product product)
    {
        // Update product logic
        var productUpdatedEvent = new ProductUpdatedEvent
        {
            ProductId = product.Id,
            Name = product.Name,
            Description = product.Description
        };
        _eventBus.Publish(productUpdatedEvent);
    }
}

// Order Service: Subscribing to the Event
public class ProductUpdatedEventHandler : IEventHandler<ProductUpdatedEvent>
{
    public void Handle(ProductUpdatedEvent @event)
    {
        // Update local read model
        _orderService.UpdateProductDetails(@event.ProductId, @event.Name, @event.Description);
    }
}        

2.2 Using Direct Queries (Query API)

Workflow

1. The Order Service fetches orders along with the associated Product ID.
2. For each Product ID, the Order Service sends a request to the Product Service (via REST API or GraphQL) to retrieve the Product Name and Description.
3. Combines the data and returns the complete result.

.NET Example

// Order Service: Fetching Data from Product Service
public class ProductServiceClient
{
    private readonly HttpClient _httpClient;

    public ProductServiceClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<ProductDto> GetProductDetails(int productId)
    {
        var response = await _httpClient.GetAsync($"/api/products/{productId}");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsAsync<ProductDto>();
    }
}

public class OrderService
{
    private readonly ProductServiceClient _productServiceClient;

    public async Task<OrderDto> GetOrderWithProductDetails(int orderId)
    {
        var order = await _orderRepository.GetOrderById(orderId);
        var product = await _productServiceClient.GetProductDetails(order.ProductId);

        return new OrderDto
        {
            OrderId = order.Id,
            ProductName = product.Name,
            ProductDescription = product.Description
        };
    }
}        

2.3 Using Data Replication

Workflow

1. The Product Service periodically synchronizes product data with the Order Service by sending updates (e.g., via scheduled tasks or event-driven mechanisms).
2. The Order Service stores a replica of the product data in its local database.
3. When retrieving orders, the Order Service directly queries its database for both order and product information.

.NET Example

// Synchronizing Data (Product Service)
public class ProductSyncService
{
    private readonly IOrderServiceApi _orderServiceApi;

    public async Task SyncProductData(Product product)
    {
        var productData = new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Description = product.Description
        };
        await _orderServiceApi.UpdateProductData(productData);
    }
}

// Order Service: Receiving Replicated Data
[HttpPost("/api/products/update")]
public IActionResult UpdateProductData([FromBody] ProductDto product)
{
    _productRepository.UpdateProduct(product);
    return Ok();
}        

2.4 Using a Data Aggregator Service

Workflow

1. A dedicated Data Aggregator Service fetches data from both the Order Service and the Product Service.
2. The aggregator combines the data and provides a unified API for clients to retrieve enriched order information.

.NET Example

// Data Aggregator Service
public class DataAggregatorService
{
    private readonly OrderServiceClient _orderServiceClient;
    private readonly ProductServiceClient _productServiceClient;

    public DataAggregatorService(OrderServiceClient orderClient, ProductServiceClient productClient)
    {
        _orderServiceClient = orderClient;
        _productServiceClient = productClient;
    }

    public async Task<AggregatedOrderDto> GetAggregatedOrder(int orderId)
    {
        var order = await _orderServiceClient.GetOrderById(orderId);
        var product = await _productServiceClient.GetProductDetails(order.ProductId);

        return new AggregatedOrderDto
        {
            OrderId = order.Id,
            ProductName = product.Name,
            ProductDescription = product.Description
        };
    }
}        

3. Choosing the Right Approach

4. Conclusion

Using CQRS in microservices enables efficient data sharing and management between services like Order Service and Product Service. By employing methods such as event-driven synchronization, direct queries, data replication, or data aggregation, you can ensure that your services remain scalable, maintainable, and performant.

Selecting the best approach depends on your specific requirements, such as real-time data needs, system complexity, and performance expectations.