Microservices Architecture

Microservices decompose applications into small, independently deployable services.

Service Boundaries

E-Commerce Microservices:

┌─────────────────────────────────────────────────────┐
│                   API Gateway                        │
└──────────┬──────────┬──────────┬──────────┬─────────┘
           │          │          │          │
    ┌──────▼──────┐ ┌─▼────┐ ┌──▼───┐ ┌────▼────┐
    │   User      │ │Order │ │Product│ │ Payment │
    │   Service   │ │Service│ │Service│ │ Service │
    └──────┬──────┘ └──┬───┘ └──┬───┘ └────┬────┘
           │           │        │          │
    ┌──────▼──────┐ ┌──▼───┐ ┌──▼───┐ ┌────▼────┐
    │  User DB    │ │Order │ │Product│ │ Payment │
    │  (Postgres) │ │ DB   │ │  DB   │ │   DB    │
    └─────────────┘ └──────┘ └──────┘ └─────────┘

Service Communication

// Synchronous - REST
class OrderService {
  private userServiceClient: HttpClient;
  private productServiceClient: HttpClient;

  async createOrder(request: CreateOrderRequest): Promise {
    // Call User Service
    const user = await this.userServiceClient.get(
      `/users/${request.userId}`
    );

    // Call Product Service for each item
    const products = await Promise.all(
      request.items.map(item =>
        this.productServiceClient.get(`/products/${item.productId}`)
      )
    );

    // Create order with fetched data
    return this.orderRepository.create({
      userId: user.id,
      items: products.map((p, i) => ({
        productId: p.id,
        name: p.name,
        price: p.price,
        quantity: request.items[i].quantity
      }))
    });
  }
}

// Asynchronous - Event-based
class OrderServiceAsync {
  private eventBus: EventBus;

  async createOrder(request: CreateOrderRequest): Promise {
    const orderId = generateId();

    // Emit event instead of direct calls
    await this.eventBus.publish({
      type: 'OrderCreationRequested',
      payload: {
        orderId,
        userId: request.userId,
        items: request.items
      }
    });

    return orderId; // Return immediately, process async
  }
}

Saga Pattern for Distributed Transactions

// Orchestration-based Saga
class OrderSagaOrchestrator {
  private steps: SagaStep[] = [
    { execute: this.reserveInventory, compensate: this.releaseInventory },
    { execute: this.processPayment, compensate: this.refundPayment },
    { execute: this.confirmOrder, compensate: this.cancelOrder }
  ];

  async execute(order: Order): Promise {
    const completedSteps: SagaStep[] = [];

    try {
      for (const step of this.steps) {
        await step.execute(order);
        completedSteps.push(step);
      }
    } catch (error) {
      // Compensate in reverse order
      for (const step of completedSteps.reverse()) {
        await step.compensate(order);
      }
      throw error;
    }
  }

  private async reserveInventory(order: Order): Promise {
    await this.inventoryService.reserve(order.items);
  }

  private async releaseInventory(order: Order): Promise {
    await this.inventoryService.release(order.items);
  }
}

Microservices Design

Microservices Design

Microservices Architecture

Service Boundaries

Service Communication

Saga Pattern for Distributed Transactions