CMN Mesh网络流量控制实战：从架构设计到性能优化

1次阅读

没有评论

共计 2566 个字符，预计需要花费 7 分钟才能阅读完成。

在分布式系统中，Mesh 网络的流量控制一直是个棘手的问题。特别是在微服务架构下，服务间的通信频繁且复杂，流量控制不当很容易导致系统崩溃。常见的痛点包括：

突发流量导致的拥塞：某个服务突然收到大量请求，如果没有合理的流量控制，会导致整个网络拥塞，甚至引发雪崩效应。
跨节点通信延迟：Mesh 网络中，节点间的通信延迟会影响流量控制的实时性，尤其是跨地域部署时。
资源利用率不均衡：某些节点可能因为流量分配不均而过载，而其他节点却处于闲置状态。

流量控制的方案通常分为集中式和分布式两种：

集中式流量控制：由一个中心节点统一管理流量分配，优点是控制精度高，缺点是单点故障风险大，且在高并发场景下容易成为瓶颈。
分布式流量控制：每个节点独立管理自身流量，优点是扩展性好，缺点是协调复杂，容易出现资源分配不均的问题。

CMN Mesh 网络选择了分布式架构，主要是因为它更适合大规模、动态变化的微服务环境。通过智能路由算法和动态限流策略，可以在保证高可用的同时，实现精细化的流量控制。

CMN Mesh 网络的流量控制分为控制平面和数据平面：

控制平面：负责全局流量策略的制定和分发，比如限流规则、路由策略等。
数据平面：负责实际流量的转发和限流，每个节点独立执行控制平面下发的策略。

这种分层设计的好处是解耦了策略与执行，既保证了灵活性，又避免了单点故障。

我们采用了 令牌桶 和滑动窗口 结合的混合限流算法：

令牌桶算法：用于平滑突发流量，通过固定速率生成令牌，请求必须获取令牌才能被处理。
滑动窗口算法：用于精确控制单位时间内的请求量，避免短时间内流量激增。

以下是 Go 语言的实现示例（关键部分注释已标注）：

package trafficcontrol

import (
    "sync"
    "time"
)

// TokenBucket 令牌桶实现
type TokenBucket struct {
    capacity  int           // 桶容量
    okens     int           // 当前令牌数
    rate      time.Duration // 令牌生成速率
    lastCheck time.Time     // 上次检查时间
    mu        sync.Mutex    // 互斥锁
}

// NewTokenBucket 创建令牌桶
func NewTokenBucket(capacity int, rate time.Duration) *TokenBucket {
    return &TokenBucket{
        capacity:  capacity,
        tokens:    capacity,
        rate:      rate,
        lastCheck: time.Now(),}
}

// Allow 检查是否允许请求通过
func (tb *TokenBucket) Allow() bool {tb.mu.Lock()
    defer tb.mu.Unlock()

    now := time.Now()
    elapsed := now.Sub(tb.lastCheck)
    // 根据时间差计算新增的令牌数
    newTokens := int(elapsed / tb.rate)
    if newTokens > 0 {tb.tokens = min(tb.tokens+newTokens, tb.capacity)
        tb.lastCheck = now
    }

    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

// SlidingWindow 滑动窗口实现
type SlidingWindow struct {
    windowSize time.Duration // 窗口大小
    maxRequests int          // 窗口内最大请求数
    requests    []time.Time  // 请求时间记录
    mu         sync.Mutex   // 互斥锁
}

// NewSlidingWindow 创建滑动窗口
func NewSlidingWindow(windowSize time.Duration, maxRequests int) *SlidingWindow {
    return &SlidingWindow{
        windowSize: windowSize,
        maxRequests: maxRequests,
        requests:    make([]time.Time, 0, maxRequests),
    }
}

// Allow 检查是否允许请求通过
func (sw *SlidingWindow) Allow() bool {sw.mu.Lock()
    defer sw.mu.Unlock()

    now := time.Now()
    // 清理过期的请求记录
    for len(sw.requests) > 0 && now.Sub(sw.requests[0]) > sw.windowSize {sw.requests = sw.requests[1:]
    }

    if len(sw.requests) < sw.maxRequests {sw.requests = append(sw.requests, now)
        return true
    }
    return false
}

我们在不同负载下测试了混合限流算法的性能：