Escalar Cargas de Lectura y Escritura con CQRS
Cómo separar modelos de lectura y escritura con CQRS para consultas optimizadas, event sourcing y escalado independiente de cada ruta.
Descripción general
Las aplicaciones CRUD tradicionales usan un único modelo de datos para leer y escribir. Una tabla relacional responde consultas SELECT para dashboards y operaciones INSERT/UPDATE para formularios. Esta simplicidad funciona en dominios pequeños pero se rompe a escala. Los esquemas optimizados para escritura (normalizados, transaccionales) son lentos para lecturas complejas. Los esquemas optimizados para lectura (desnormalizados, indexados) son caros de actualizar. Cuando el tráfico crece, ambas cargas compiten por los mismos recursos de base de datos.
Command Query Responsibility Segregation (CQRS) divide el modelo de datos en dos: un modelo de escritura optimizado para comandos (crear, actualizar, eliminar) y un modelo de lectura optimizado para consultas. Los comandos mutan el estado en el modelo de escritura y publican eventos. Los manejadores de eventos actualizan los modelos de lectura — proyecciones desnormalizadas diseñadas para patrones de consulta concretos. Los dos modelos pueden usar bases de datos distintas, esquemas distintos y escalar de forma independiente. Abajo tienes la ruta de escritura, la de proyección y tres formas de conectarlas — desde una configuración simple con dos bases de datos hasta event sourcing completo. Para componer lógica de consulta reutilizable sobre el lado de lectura, consulta el Patrón Specification.
Cuándo usarlo
Usa esta receta cuando:
- Los volúmenes de lectura y escritura difieren considerablemente (ratios 100:1 de lectura son comunes). Consulta Réplicas de Lectura de Base de Datos para escalar lecturas.
- Las consultas complejas requieren joins entre varios agregados y degradan el rendimiento de escritura. Consulta Joins en SQL para optimización de consultas.
- Estás construyendo dashboards en tiempo real, analíticas o búsquedas que necesitan datos con una forma distinta a la del modelo transaccional.
- Trabajas con sistemas event-sourced donde el estado se deriva de una secuencia de eventos. Consulta Event Sourcing para patrones de event store.
- Los equipos necesitan optimizar los esquemas de lectura y escritura de forma independiente sin coordinación.
Sáltate esta receta cuando lecturas y escrituras son simétricas y un CRUD simple cubre las consultas — un solo modelo es mucho más fácil de operar y depurar.
Solución
Manejador de Comandos con Publicación de Eventos (TypeScript)
interface Event {
type: string;
aggregateId: string;
payload: unknown;
occurredAt: Date;
}
interface EventStore {
append(events: Event[]): Promise<void>;
getEvents(aggregateId: string): Promise<Event[]>;
getEventsAfter?(aggregateId: string, fromVersion: number): Promise<Event[]>;
}
class OrderWriteModel {
constructor(
public id: string,
public customerId: string,
public items: Array<{ productId: string; quantity: number; price: number }>,
public status: 'pending' | 'paid' | 'shipped' = 'pending'
) {}
pay(paymentMethod: string): Event[] {
if (this.status !== 'pending') throw new Error('Order already paid');
return [{
type: 'OrderPaid',
aggregateId: this.id,
payload: { paymentMethod, total: this.total() },
occurredAt: new Date(),
}];
}
total(): number {
return this.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}
}
class PayOrderCommand {
constructor(
public orderId: string,
public paymentMethod: string
) {}
}
class PayOrderHandler {
constructor(private eventStore: EventStore) {}
async handle(command: PayOrderCommand): Promise<void> {
const events = await this.eventStore.getEvents(command.orderId);
const order = this.rehydrate(events);
const newEvents = order.pay(command.paymentMethod);
await this.eventStore.append(newEvents);
}
private rehydrate(events: Event[]): OrderWriteModel {
if (events.length === 0) throw new Error(`No events found for order`);
const order = new OrderWriteModel(events[0].aggregateId, '', []);
for (const event of events) {
if (event.type === 'OrderCreated') {
const p = event.payload as {
customerId: string;
items: OrderWriteModel['items'];
};
order.customerId = p.customerId;
order.items = p.items;
} else if (event.type === 'OrderPaid') {
order.status = 'paid';
}
}
return order;
}
}
Proyección del Modelo de Lectura (SQL)
-- Modelo de lectura desnormalizado para resúmenes de pedidos
CREATE TABLE order_summaries (
order_id UUID PRIMARY KEY,
customer_name VARCHAR(255),
total_amount DECIMAL(10,2),
item_count INT,
status VARCHAR(20),
last_updated TIMESTAMP
);
-- El manejador de proyección actualiza el modelo de lectura cuando ocurren eventos
CREATE OR REPLACE FUNCTION project_order_paid()
RETURNS TRIGGER AS $$
BEGIN
UPDATE order_summaries
SET status = 'paid', last_updated = NEW.occurred_at
WHERE order_id = NEW.aggregate_id;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
Manejador de Eventos Actualizando el Modelo de Lectura (Node.js)
class OrderProjection {
constructor(readDb, elasticsearch) {
this.readDb = readDb;
this.elasticsearch = elasticsearch;
}
async handleOrderPaid(event) {
// Actualizar modelo de lectura relacional
await this.readDb.query(
'UPDATE order_summaries SET status = $1, last_updated = $2 WHERE order_id = $3',
['paid', event.occurredAt, event.aggregateId]
);
// Actualizar índice de búsqueda
await this.elasticsearch.update({
index: 'orders',
id: event.aggregateId,
doc: { status: 'paid', paidAt: event.occurredAt }
});
}
async handleOrderCreated(event) {
await this.readDb.query(
`INSERT INTO order_summaries (order_id, customer_name, total_amount, item_count, status, last_updated)
VALUES ($1, $2, $3, $4, $5, $6)`,
[event.aggregateId, event.payload.customerName, event.payload.total,
event.payload.items.length, 'pending', event.occurredAt]
);
}
}
Explicación
- Modelo de comandos: el lado que cambia el estado. Cada comando se valida contra invariantes, muta el modelo de escritura y produce eventos de dominio. El modelo de escritura está normalizado y es transaccional — impone las reglas de negocio a costa de mayor complejidad en las consultas.
- Event sourcing: en lugar de guardar el estado actual, guarda la secuencia de eventos que condujo a él. El modelo de escritura añade eventos a un event store. Reproducir los eventos reconstruye el estado. Esto te da un historial de auditoría completo y consultas temporales.
- Modelo de lectura (proyección): una vista desnormalizada y optimizada para consultas, construida a partir de eventos. Un modelo de lectura
customer_orderspuede aplanar ítems del pedido, nombres de cliente y estado de envío en una sola tabla con los índices adecuados. Las proyecciones se construyen y refrescan en segundo plano. - Consistencia eventual: un comando completado no actualiza el modelo de lectura al instante. Hay una breve ventana (milisegundos a segundos) en la que el modelo de escritura refleja el cambio pero el de lectura no. Es consistencia eventual — aceptable para la mayoría de sistemas con mucha lectura.
Variantes
| Enfoque | Modelo de escritura | Modelo de lectura | Consistencia | Mejor para |
|---|---|---|---|---|
| Una DB, vistas separadas | Relacional | Vistas materializadas | Fuerte | CQRS simple |
| Doble DB | Relacional | Documental/Búsqueda | Eventual | Alta escala de lectura |
| Event sourcing | Event store | Múltiples proyecciones | Eventual | Auditoría, consultas temporales |
| Réplicas de lectura (no es CQRS estricto) | DB primaria | DB réplica | Casi fuerte | Escalar lecturas sin cambiar código |
Qué Funciona
- Mantén los modelos de lectura simples y desechables: un modelo de lectura es una caché, no una fuente de verdad. Si se corrompe, se reconstruye reproduciendo los eventos desde el principio. Nada de lógica de negocio ni de escrituras ahí dentro.
- Versiona tus eventos: a medida que los esquemas evolucionan, las proyecciones antiguas deben seguir entendiendo los eventos históricos. Incluye un campo de versión en los eventos y escribe manejadores para cada versión. Esto permite migraciones graduales sin downtime.
- Haz las proyecciones idempotentes: los brokers entregan eventos al menos una vez, así que un manejador puede ver el mismo evento dos veces. Diseña las proyecciones para que procesar el mismo evento dos veces produzca el mismo resultado. Usa
UPSERTen lugar deINSERT. - Monitoriza el lag de las proyecciones: el retraso entre la escritura y la actualización del modelo de lectura debe estar acotado. Alerta si el lag supera tu SLA (p. ej., 5 segundos). Proyecciones lentas indican backpressure o manejadores de eventos ineficientes.
- Empieza simple y evoluciona hacia CQRS: no construyas CQRS desde el día uno en un proyecto nuevo. Empieza con un solo modelo. Cuando las lecturas se vuelvan complejas o lentas, extrae un modelo de lectura aparte. Un CQRS prematuro añade complejidad innecesaria.
Errores comunes
- CQRS sin motivo: si tu aplicación tiene un CRUD simple con ratios de lectura/escritura equilibrados, CQRS añade complejidad sin beneficio. Úsalo cuando la asimetría de carga o la complejidad de las consultas justifique la separación.
- Reglas de negocio dentro de las proyecciones: el modelo de lectura existe solo para servir consultas. Si te encuentras validando o mutando estado en una proyección, has violado la separación. Esa lógica vive en los manejadores de comandos.
- Ignorar la consistencia eventual en la UX: el usuario puede enviar un formulario y refrescar de inmediato, viendo datos obsoletos. Diseña la UI para manejarlo — muestra un mensaje de éxito, actualiza de forma optimista o redirige a una página de confirmación en lugar de consultar el modelo de lectura al instante.
- Reconstruir proyecciones desde cero en cada despliegue: en desarrollo es tentador borrar el modelo de lectura y reconstruir desde cero. En producción, donde un event store con carga real acumula miles de millones de eventos, una reproducción completa tarda días. Implementa snapshotting — guarda periódicamente el estado del agregado para que las reproducciones empiecen desde el snapshot, no desde el evento 1.
Ejemplos avanzados
Implementación en Python con Event Sourcing
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import List, Any
from abc import ABC, abstractmethod
@dataclass
class Event:
type: str
aggregate_id: str
payload: Any
occurred_at: datetime = field(
default_factory=lambda: datetime.now(timezone.utc)
)
class EventStore(ABC):
@abstractmethod
async def append(self, events: List[Event]) -> None:
...
@abstractmethod
async def get_events(self, aggregate_id: str) -> List[Event]:
...
@dataclass
class OrderItem:
product_id: str
quantity: int
price: float
class OrderWriteModel:
def __init__(self, order_id: str, customer_id: str, items: List[OrderItem]):
self.id = order_id
self.customer_id = customer_id
self.items = items
self.status = 'pending'
def pay(self, payment_method: str) -> List[Event]:
if self.status != 'pending':
raise ValueError('Order already paid')
self.status = 'paid'
return [Event(
type='OrderPaid',
aggregate_id=self.id,
payload={'payment_method': payment_method, 'total': self.total()}
)]
def total(self) -> float:
return sum(item.price * item.quantity for item in self.items)
class PayOrderHandler:
def __init__(self, event_store: EventStore):
self._event_store = event_store
async def handle(self, order_id: str, payment_method: str) -> None:
events = await self._event_store.get_events(order_id)
order = self._rehydrate(events)
new_events = order.pay(payment_method)
await self._event_store.append(new_events)
def _rehydrate(self, events: List[Event]) -> OrderWriteModel:
if not events:
raise ValueError('No events found for order')
order = OrderWriteModel(events[0].aggregate_id, '', [])
for event in events:
if event.type == 'OrderCreated':
order.customer_id = event.payload['customer_id']
order.items = [OrderItem(**i) for i in event.payload['items']]
elif event.type == 'OrderPaid':
order.status = 'paid'
return order
Snapshotting para Flujos de Eventos Grandes
interface Snapshot {
aggregateId: string;
version: number;
state: unknown;
}
class SnapshotStore {
async save(snapshot: Snapshot): Promise<void> {
// Persistir snapshot en base de datos
}
async load(aggregateId: string): Promise<Snapshot | null> {
// Cargar el snapshot más reciente
return null;
}
}
class PayOrderHandlerWithSnapshots {
constructor(
private eventStore: EventStore,
private snapshots: SnapshotStore
) {}
async handle(command: PayOrderCommand): Promise<void> {
const snapshot = await this.snapshots.load(command.orderId);
let order: OrderWriteModel;
let fromVersion = 0;
if (snapshot) {
order = snapshot.state as OrderWriteModel;
fromVersion = snapshot.version;
} else {
const events = await this.eventStore.getEvents(command.orderId);
order = this.rehydrate(events);
fromVersion = events.length;
}
// Aplicar solo los eventos posteriores al snapshot
const recentEvents = await this.eventStore.getEventsAfter(
command.orderId, fromVersion
);
for (const event of recentEvents) {
this.apply(order, event);
}
const newEvents = order.pay(command.paymentMethod);
await this.eventStore.append(newEvents);
// Guardar snapshot cada 100 eventos
if (fromVersion + recentEvents.length + newEvents.length >= 100) {
await this.snapshots.save({
aggregateId: command.orderId,
version: fromVersion + recentEvents.length + newEvents.length,
state: order,
});
}
}
private apply(order: OrderWriteModel, event: Event): void {
// Aplicar evento al pedido
}
private rehydrate(events: Event[]): OrderWriteModel {
if (events.length === 0) throw new Error('No events found for order');
return new OrderWriteModel(events[0].aggregateId, '', []);
}
}
Base de Datos de Lectura Separada con Redis
interface OrderSummary {
orderId: string;
customerName: string;
totalAmount: number;
itemCount: number;
status: string;
}
interface OrderCreatedPayload {
customerName: string;
total: number;
items: Array<{ productId: string; quantity: number; price: number }>;
}
interface RedisClient {
hgetall(key: string): Promise<Record<string, string>>;
hset(key: string, fields: Record<string, string>): Promise<number>;
}
class OrderReadModelRedis {
constructor(private redis: RedisClient) {}
async getOrderSummary(orderId: string): Promise<OrderSummary | null> {
const data = await this.redis.hgetall(`order:${orderId}:summary`);
if (!data || Object.keys(data).length === 0) return null;
return {
orderId,
customerName: data.customerName,
totalAmount: parseFloat(data.totalAmount),
itemCount: parseInt(data.itemCount, 10),
status: data.status,
};
}
async handleOrderCreated(event: Event): Promise<void> {
const payload = event.payload as OrderCreatedPayload;
await this.redis.hset(`order:${event.aggregateId}:summary`, {
customerName: payload.customerName,
totalAmount: payload.total.toString(),
itemCount: payload.items.length.toString(),
status: 'pending',
});
}
async handleOrderPaid(event: Event): Promise<void> {
await this.redis.hset(`order:${event.aggregateId}:summary`, {
status: 'paid',
});
}
}
Lecturas adicionales
- CQRS — Martin Fowler: el artículo de referencia sobre los orígenes del patrón y cuándo compensa
- Patrón CQRS — Azure Architecture Center: guía de implementación con trade-offs de consistencia y particionado
- Event Sourcing — Martin Fowler: el patrón complementario con el que CQRS suele combinarse
- Código complementario — stack-practices-resources: versiones descargables de los snippets TypeScript, Python, SQL y Redis de esta página
Preguntas frecuentes
¿Es CQRS lo mismo que event sourcing?
No. CQRS separa lecturas y escrituras. Event sourcing guarda el estado como eventos. Se usan juntos con frecuencia porque event sourcing produce de forma natural los eventos que pueblan los modelos de lectura. Pero puedes usar CQRS sin event sourcing (p. ej., doble base de datos) y event sourcing sin CQRS (un solo modelo reconstruido desde eventos).
¿Cómo manejo consultas que necesitan datos en tiempo real?
Para requisitos de tiempo real estricto (menos de un segundo), consulta el modelo de escritura directamente. Acepta el coste de rendimiento para ese pequeño subconjunto de consultas que necesita frescura perfecta. La mayoría de dashboards y listas toleran consistencia eventual.
¿Qué pasa si una proyección falla?
Las proyecciones que fallan no deben bloquear la ruta de escritura. Usa una dead-letter queue para los eventos fallidos. Corrige el manejador de la proyección y reproduce desde el punto de fallo. Mientras tanto, el lado de escritura no se detiene.
¿Puedo usar CQRS con una base de datos relacional?
Sí. El modelo de escritura puede ser un esquema relacional normalizado. El modelo de lectura puede ser un esquema separado con vistas desnormalizadas, o una tecnología distinta por completo (Elasticsearch, Redis, ClickHouse). Usa lo que encaje con el patrón de consulta.
¿Cuál es la diferencia entre CQRS y réplicas de lectura?
Las réplicas de lectura copian los mismos datos a otro servidor — mismo esquema, mismas consultas. CQRS cambia el propio modelo de datos: el lado de lectura guarda proyecciones desnormalizadas diseñadas para cada consulta, algo que una réplica no puede darte. Las réplicas resuelven el volumen de lectura; CQRS además resuelve la forma de lectura.
¿Cómo mantengo los modelos de lectura sincronizados tras un cambio de esquema?
Versiona los eventos y añade un upcaster que migre los payloads antiguos al leerlos. Para cambios incompatibles, levanta una nueva versión de la proyección, reproduce los eventos en ella y cambia el tráfico cuando se ponga al día — nunca edites una proyección en producción sobre la marcha.
Recursos Relacionados
Patrón CQRS
Separa los modelos de lectura y escritura para optimizar cada uno según su carga — cuándo CQRS merece la pena, cuándo es excesivo y cómo se combina con event sourcing.
RecipeImplementar Event Sourcing con CQRS en Python
Construye un sistema con event sourcing y CQRS en Python: event store, aggregates, proyecciones, snapshots y handlers idempotentes para sistemas auditables.
GuideEvent Sourcing y CQRS: Event Store, Proyecciones
Event sourcing y CQRS: diseño del event store, aggregate roots, proyecciones, snapshots, consistencia eventual y cuándo evitar el patrón.
RecipeImplementar event sourcing en una base de datos relacional
Implementa event sourcing en una base de datos relacional. Almacena eventos inmutables, proyecta read models y usa snapshots con PostgreSQL, MySQL y SQL Server.
RecipeImplementar Patrones Tácticos de Domain-Driven Design
Cómo estructurar código alrededor de conceptos de negocio usando bounded contexts, aggregates, entities, value objects y domain events para gestionar complejidad en aplicaciones grandes.
RecipeImplementar Sistemas Reactivos con el Observer Pattern
Cómo construir sistemas event-driven y reactivos usando el observer pattern con pub/sub, event emitters y reactive streams en JavaScript, Java y Python.