07-scaling-patterns

Primary Role: Design and implement patterns for distributed, scalable systems. Boundaries: • ✅ Microservices, event-driven architecture, distributed patterns • ✅ AI agent integration, message queues, resilience patterns • ❌ Individual service implementation (delegate to Agent 02) • ❌ Database optimization (delegate to Agent 03) • ❌ Infrastructure deployment (delegate to Agent 04)

` ┌──────────────────────────────────────────────────────────────────┐ │ Microservices Decomposition │ ├──────────────────────────────────────────────────────────────────┤ │ │ │ Monolith → Microservices │ │ ┌─────────────────┐ ┌─────────────────┐ │ │ │ User Module │ │ User Service │ (Node.js) │ │ │ Order Module │ → │ Order Service │ (Python) │ │ │ Payment Module │ │ Payment Service │ (Go) │ │ │ Inventory Module│ │ Inventory Svc │ (Java) │ │ │ Notification │ │ Notification Svc│ (Node.js) │ │ └─────────────────┘ └─────────────────┘ │ │ │ │ Bounded Contexts: │ │ - Each service owns its data │ │ - Clear API contracts between services │ │ - Independent deployment lifecycle │ │ │ └──────────────────────────────────────────────────────────────────┘ `

`typescript // Synchronous (REST/gRPC) - Use for queries async function getUser(userId: string): Promise<User> { const response = await fetch(http://user-service/users/${userId}, { headers: { 'X-Request-ID': requestId, 'Authorization': Bearer ${serviceToken}, }, timeout: 5000, // Always set timeout }); if (!response.ok) { throw new ServiceError('user-service', response.status); } return response.json(); } // Asynchronous (Events) - Use for commands/state changes async function createOrder(order: CreateOrderDto): Promise<Order> { // Save to local database const savedOrder = await orderRepository.save(order); // Publish event for other services await eventBus.publish('order.created', { orderId: savedOrder.id, userId: savedOrder.userId, items: savedOrder.items, total: savedOrder.total, timestamp: new Date().toISOString(), }); return savedOrder; } `

`typescript import { Kafka, Producer, Consumer } from 'kafkajs'; class EventBus { private producer: Producer; private consumer: Consumer; private handlers: Map<string, ((event: any) => Promise<void>)[]> = new Map(); constructor(private kafka: Kafka) { this.producer = kafka.producer(); this.consumer = kafka.consumer({ groupId: process.env.SERVICE_NAME! }); } async connect() { await this.producer.connect(); await this.consumer.connect(); } async publish<T>(topic: string, event: T): Promise<void> { await this.producer.send({ topic, messages: [ { key: (event as any).id || crypto.randomUUID(), value: JSON.stringify({ ...event, metadata: { timestamp: new Date().toISOString(), source: process.env.SERVICE_NAME, correlationId: asyncLocalStorage.getStore()?.correlationId, }, }), }, ], }); } async subscribe(topic: string, handler: (event: any) => Promise<void>): Promise<void> { const handlers = this.handlers.get(topic) || []; handlers.push(handler); this.handlers.set(topic, handlers); await this.consumer.subscribe({ topic, fromBeginning: false }); } async start(): Promise<void> { await this.consumer.run({ eachMessage: async ({ topic, message }) => { const handlers = this.handlers.get(topic) || []; const event = JSON.parse(message.value!.toString()); for (const handler of handlers) { try { await handler(event); } catch (error) { console.error(Error handling event on ${topic}:, error); // Dead letter queue for failed events await this.publish(${topic}.dlq, { originalEvent: event, error: String(error) }); } } }, }); } } // Usage const eventBus = new EventBus(kafka); eventBus.subscribe('order.created', async (event) => { await paymentService.processPayment(event.orderId, event.total); }); eventBus.subscribe('payment.completed', async (event) => { await inventoryService.reserveItems(event.orderId); }); `