高可用架构 学习笔记（第 10 部分）

微服务高可用架构:

用户请求
    ↓
┌───────────────┐
│  API 网关集群  │ ← 多实例部署
└───────┬───────┘
        │
┌───────┴───────────────────┐
│                           │
↓                           ↓
┌─────────┐             ┌─────────┐
│用户服务  │             │订单服务  │
│(3实例)  │             │(5实例)  │
└────┬────┘             └────┬────┘
     │                       │
┌────┴────┐             ┌────┴────┐
│用户 DB   │             │订单 DB   │
│主 + 从   │             │主 + 从   │
└─────────┘             └─────────┘

保障措施:
1. 服务多实例部署
2. 数据库主从复制
3. 服务注册发现
4. 熔断降级
5. 限流保护

// 服务降级示例
class ServiceDegradation {
  constructor() {
    this.circuitBreaker = new CircuitBreaker()
  }
  
  // 调用远程服务
  async callRemoteService(serviceName, params) {
    // 检查熔断器状态
    if (this.circuitBreaker.isOpen(serviceName)) {
      // 服务熔断,执行降级逻辑
      return this.fallback(serviceName, params)
    }
    
    try {
      // 调用远程服务
      const result = await this.invoke(serviceName, params)
      
      // 成功,重置熔断器
      this.circuitBreaker.recordSuccess(serviceName)
      
      return result
    } catch (error) {
      // 失败,记录失败
      this.circuitBreaker.recordFailure(serviceName)
      
      // 执行降级逻辑
      return this.fallback(serviceName, params)
    }
  }
  
  // 降级逻辑
  fallback(serviceName, params) {
    switch (serviceName) {
      case 'recommendation':
        // 推荐服务降级:返回热门商品
        return this.getHotProducts()
      
      case 'comment':
        // 评论服务降级:返回缓存评论
        return this.getCachedComments(params.productId)
      
      case 'payment':
        // 支付服务不可降级:返回错误
        throw new Error('支付服务暂时不可用,请稍后重试')
      
      default:
        return null
    }
  }
  
  async invoke(serviceName, params) {
    // 模拟服务调用
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        if (Math.random() > 0.3) {
          resolve({ data: 'success' })
        } else {
          reject(new Error('服务调用失败'))
        }
      }, 100)
    })
  }
  
  async getHotProducts() {
    return [
      { id: 1, name: '热门商品1' },
      { id: 2, name: '热门商品2' }
    ]
  }
  
  async getCachedComments(productId) {
    return [
      { id: 1, content: '缓存评论1' },
      { id: 2, content: '缓存评论2' }
    ]
  }
}

// 熔断器
class CircuitBreaker {
  constructor() {
    this.states = new Map()
    this.threshold = 5  // 失败阈值
    this.timeout = 60000  // 熔断超时时间
  }
  
  isOpen(serviceName) {
    const state = this.states.get(serviceName)
    
    if (!state) return false
    
    if (state.status === 'open') {
      // 检查是否超过超时时间
      if (Date.now() - state.lastFailureTime > this.timeout) {
        // 进入半开状态
        state.status = 'half-open'
        return false
      }
      return true
    }
    
    return false
  }
  
  recordSuccess(serviceName) {
    const state = this.states.get(serviceName) || {
      status: 'closed',
      failureCount: 0
    }
    
    state.status = 'closed'
    state.failureCount = 0
    
    this.states.set(serviceName, state)
  }
  
  recordFailure(serviceName) {
    const state = this.states.get(serviceName) || {
      status: 'closed',
      failureCount: 0
    }
    
    state.failureCount++
    state.lastFailureTime = Date.now()
    
    if (state.failureCount >= this.threshold) {
      state.status = 'open'
      console.log(`服务 ${serviceName} 熔断器打开`)
    }
    
    this.states.set(serviceName, state)
  }
}

// 使用示例
const service = new ServiceDegradation()

// 正常调用
service.callRemoteService('recommendation', {})
  .then(result => console.log('推荐结果:', result))

// 服务降级
for (let i = 0; i < 10; i++) {
  service.callRemoteService('recommendation', {})
    .then(result => console.log(`第${i+1}次调用:`, result))
}

// 高可用监控指标
const monitoringMetrics = {
  // 系统层指标
  system: {
    cpu: 'CPU 使用率',
    memory: '内存使用率',
    disk: '磁盘使用率',
    network: '网络流量'
  },
  
  // 应用层指标
  application: {
    qps: '请求吞吐量',
    latency: '响应时间',
    errorRate: '错误率',
    availability: '可用性'
  },
  
  // 数据层指标
  database: {
    connections: '连接数',
    queryTime: '查询时间',
    replicationLag: '复制延迟',
    diskIO: '磁盘 I/O'
  },
  
  // 中间件指标
  middleware: {
    mqLag: '消息队列延迟',
    cacheHitRate: '缓存命中率',
    serviceHealth: '服务健康状态'
  }
}