系统设计：单体不够用了之后

// 单体应用的结构
/app
  /controllers
    - user.js
    - order.js
    - payment.js
  /models
    - user.js
    - order.js
    - payment.js
  /services
    - email.js
    - notification.js
  /routes.js

# 部署一次要停机 30 分钟
npm run build
pm2 stop myapp
rsync -av dist/ server:/var/www/
pm2 restart myapp

// 按业务功能拆分
/user-service
  - 用户管理
  - 权限管理

/order-service
  - 订单处理
  - 订单查询

/payment-service
  - 支付处理
  - 退款管理

// 按流量拆分
/user-service-master
/user-service-slave-1
/user-service-slave-2

# 分布式事务问题
def process_order(user_id, amount):
    # 1. 扣减库存
    inventory.reduce_stock(amount)
    
    # 2. 创建订单
    order = order_service.create_order(user_id, amount)
    
    # 3. 支付
    payment_service.charge(user_id, amount)
    
    # 问题：如果支付失败，库存已经扣了

# Saga 模式
class CreateOrderSaga:
    def execute(self, user_id, amount):
        try:
            # 步骤 1：扣减库存
            inventory_service.reduce_stock(amount)
            
            # 步骤 2：创建订单
            order = order_service.create_order(user_id, amount)
            
            # 步骤 3：支付
            payment_service.charge(user_id, amount)
            
            return order
        
        except Exception as e:
            # 补偿操作
            inventory_service.restore_stock(amount)
            raise e

// 服务发现问题
const users = [
  'http://user-service-1:3000',
  'http://user-service-2:3000',
  'http://user-service-3:3000'
];

// 简单的负载均衡
function getUserService() {
  return users[Math.floor(Math.random() * users.length)];
}

// 问题：服务挂了怎么办？

// 使用 Consul 或 Eureka
const consul = require('consul')();

// 服务注册
async function registerService(serviceName, serviceUrl) {
  await consul.agent.service.register({
    name: serviceName,
    address: serviceUrl,
    check: {
      http: `http://${serviceUrl}/health`,
      interval: '10s'
    }
  });
}

// 服务发现
async function discoverService(serviceName) {
  const services = await consul.agent.service.list();
  return services[serviceName];
}

# 服务解耦
from celery import Celery

app = Celery('orders', broker='redis://localhost:6379/0')

@app.task
def process_order(order_id):
    order = get_order(order_id)
    
    # 异步处理
    send_notification(order.user_id, '订单已创建')
    update_statistics(order)
    send_analytics(order)

# 使用 Jaeger 追踪请求
from opentelemetry import trace
from opentelemetry.exporter.jaeger import JaegerExporter

tracer = trace.get_tracer(__name__)

@tracer.start_as_current_span("process_order")
def process_order(order_id):
    with tracer.start_as_span("get_order"):
        order = get_order(order_id)
    
    with tracer.start_as_span("process_payment"):
        process_payment(order)