GoEdge 开源CDN 架构设计与工作原理分析

GoEdge CDN 架构设计与工作原理

整体架构

GoEdge CDN 边缘节点采用模块化设计，核心组件包括：

├── cmd/edge-node/         # 主入口
├── internal/
│   ├── nodes/             # 节点核心模块
│   ├── caches/            # 缓存系统
│   ├── waf/               # Web 应用防火墙
│   ├── configs/           # 配置管理
│   ├── rpc/               # 远程调用
│   ├── stats/             # 统计模块
│   └── utils/             # 工具库

核心工作原理

1. 节点启动流程

节点启动时的主要步骤：

// Node.Start() 启动流程
func (this *Node) Start() {
    // 设置网络DNS
    _ = os.Setenv("GODEBUG", "netdns=go")
    
    // 处理异常
    this.handlePanic()
    
    // 监听信号
    this.listenSignals()
    
    // 本地Sock
    err := this.listenSock()
    
    // 启动IP库
    err = iplib.InitDefault()
    
    // 读取API配置
    err = this.syncConfig(0)
    
    // 启动同步计时器
    this.startSyncTimer()
    
    // 启动端口
    err = sharedListenerManager.Start(nodeConfig)
    
    // 保持进程运行
    select {}
}

工作原理 ：

1. 初始化基本环境（DNS、异常处理、信号监听）
2. 加载配置（从API节点或本地文件）
3. 启动核心组件（IP库、监听器、API连接）
4. 进入主循环，处理请求

2. HTTP 请求处理流程

核心代码 ： internal/nodes/http_request.go

一个HTTP请求的完整处理流程：

// HTTPRequest.Do() 执行请求
func (this *HTTPRequest) Do() {
    // 初始化
    this.init()
    
    // 处理健康检查
    if len(healthCheckKey) > 0 {
        if this.doHealthCheck(healthCheckKey, &this.
        isHealthCheck) {
            this.doEnd()
            return
        }
    }
    
    // 缓存检查
    if this.web.Cache != nil && this.web.Cache.IsOn 
    {
        if this.doCacheRead(false) {
            return
        }
    }
    
    // 反向代理到源站
    this.doReverseProxy()
    
    // 结束处理
    this.doEnd()
}

工作原理 ：

1. 初始化请求上下文（解析请求、匹配服务配置）
2. 检查缓存（命中则直接返回）
3. 应用WAF规则（防护恶意请求）
4. 反向代理到源站（未命中缓存时）
5. 缓存源站响应（符合缓存策略时）
6. 返回响应给客户端

3. 缓存系统

核心代码 ： internal/caches/manager.go 和 internal/caches/writer.go

缓存系统的主要组件：

// Manager 缓存策略管理器
type Manager struct {
    MaxDiskCapacity   *shared.SizeCapacity
    MainDiskDir       string
    SubDiskDirs       []*serverconfigs.CacheDir
    MaxMemoryCapacity *shared.SizeCapacity

    policyMap  map[int64]*serverconfigs.
    HTTPCachePolicy // policyId => []*Policy
    storageMap map[int64]
    StorageInterface               // policyId => 
    *Storage
    locker     sync.RWMutex
}

工作原理 ：

1. 缓存键生成 ：基于请求URL、头部等信息生成唯一缓存键
2. 存储管理 ：支持文件存储和内存存储，根据策略选择
3. 缓存检查 ：请求到达时先检查缓存是否命中
4. 缓存写入 ：从源站获取响应后，根据策略写入缓存
5. 缓存过期 ：定期清理过期缓存，控制缓存大小

4. Web 应用防火墙 (WAF)

核心代码 ： internal/waf/waf.go

WAF的主要结构：

// WAF Web应用防火墙
type WAF struct {
    IsOn      bool
    Inbound   []*RuleGroup                    // 入
    站规则组
    Outbound  []*RuleGroup                    // 出
    站规则组
    Mode      firewallconfigs.FirewallMode    // 防
    护模式
    
    AllowListId int64 // 白名单ID
    DenyListId  int64 // 黑名单ID
    GreyListId  int64 // 灰度名单ID
    
    actionMap map[int64]ActionInterface // 动作映射
}

工作原理 ：

1. 规则匹配 ：对请求进行多维度检查（IP、URL、头部、Body等）
2. 动作执行 ：匹配规则后执行相应动作（阻断、跳转、验证码等）
3. IP管理 ：基于黑白名单控制访问
4. 模式配置 ：支持不同防护强度的模式

5. 反向代理

核心代码 ： internal/nodes/http_request_reverse_proxy.go

反向代理的关键流程：

// doReverseProxy 执行反向代理
func (this *HTTPRequest) doReverseProxy() {
    // 选择源站
    this.pickOrigin()
    
    // 建立连接
    conn, err := this.originConnect()
    
    // 发送请求
    err = this.sendToOrigin(conn)
    
    // 读取响应
    resp, err := http.ReadResponse(bufio.NewReader
    (conn), this.RawReq)
    
    // 处理响应
    this.processResponse(resp)
}

工作原理 ：

1. 源站选择 ：根据配置选择合适的源站（支持多源站和健康检查）
2. 连接管理 ：复用与源站的连接，提高性能
3. 请求转发 ：完整转发请求信息到源站
4. 响应处理 ：处理源站响应，应用缓存策略，返回给客户端

关键技术实现

1. 缓存策略

// NewStorageWithPolicy 根据策略获取存储对象
func (this *Manager) NewStorageWithPolicy(policy 
*serverconfigs.HTTPCachePolicy) StorageInterface {
    switch policy.Type {
    case serverconfigs.CachePolicyStorageFile:
        return NewFileStorage(policy)
    case serverconfigs.CachePolicyStorageMemory:
        return NewMemoryStorage(policy, nil)
    }
    return nil
}

设计思路 ：支持多种存储类型，根据内容特性选择合适的存储方式，提高缓存效率。

2. WAF 规则引擎

// Init 初始化WAF
func (this *WAF) Init() (resultErrors []error) {
    // 初始化检查点
    this.checkpointsMap = map[string]checkpoints.
    CheckpointInterface{}
    for _, def := range checkpoints.AllCheckpoints {
        instance := reflect.New(reflect.Indirect
        (reflect.ValueOf(def.Instance)).Type()).
        Interface().(checkpoints.
        CheckpointInterface)
        instance.Init()
        instance.SetPriority(def.Priority)
        this.checkpointsMap[def.Prefix] = instance
    }
    
    // 初始化规则组
    if this.hasInboundRules {
        for _, group := range this.Inbound {
            err := group.Init(this)
        }
    }
    
    return nil
}

设计思路 ：采用插件式架构，支持自定义检查点和规则，灵活应对各种攻击场景。

3. 连接管理

// 处理WebSocket连接
func (this *HTTPRequest) doWebSocket() (blocked 
bool) {
    // 建立与源站的连接
    originConn, err := this.originConnect()
    
    // 升级连接为WebSocket
    clientConn, err := this.upgradeWebSocket()
    
    // 双向复制数据
    go func() {
        var buf = bytepool.Pool4k.Get()
        _, _ = io.CopyBuffer(originConn, 
        clientConn, buf.Bytes)
        bytepool.Pool4k.Put(buf)
    }()
    
    var buf = bytepool.Pool4k.Get()
    _, _ = io.CopyBuffer(clientConn, originConn, 
    buf.Bytes)
    bytepool.Pool4k.Put(buf)
    
    return
}

设计思路 ：使用连接池和内存池，减少资源消耗，提高并发处理能力。

数据流程

客户端 → 监听器 → HTTPRequest → 缓存检查 → 命中缓存返回
                           ↓ 未命中
                           → WAF检查 → 反向代理 → 源站
                           ↓ 源站响应
                           → 缓存写入 → 返回客户端

优化设计

1. 多级缓存 ：内存缓存 + 磁盘缓存，提高热点内容访问速度
2. 连接复用 ：与源站保持长连接，减少建连开销
3. 异步处理 ：使用Go协程处理并发请求，提高吞吐量
4. 智能缓存 ：基于内容类型和访问模式自动调整缓存策略
5. 健康检查 ：定期检查源站状态，实现故障自动切换

总结

GoEdge CDN 边缘节点通过模块化设计和高效的实现，提供了完整的CDN服务能力。此外，GoEdge还内置了监控与指标系统提供运维数据，以及一些压缩接口来提高传输效率。总体结构可以大致如下：

1. 核心模块

• 节点管理 (Nodes) : 负责节点的启动、停止、配置同步等
• 缓存系统 (Caches) : 处理内容缓存，包括文件存储和内存存储
• HTTP请求处理 : 处理客户端请求，包括缓存检查、WAF、反向代理等
• WAF : Web应用防火墙，提供安全防护

2. 辅助模块

• 监控与指标 (Metrics) : 收集和处理性能数据
• 压缩系统 (Compressions) : 处理内容压缩，提高传输效率
• 连接管理 (Conns) : 管理网络连接，优化连接复用
• IP库 (IPLibrary) : 提供IP黑白名单功能
• 远程日志 (RemoteLogs) : 管理日志的本地打印和远程上传

3. 工具模块 各种工具函数和辅助类，提供通用功能，如：

• 字节池、对象池等性能优化工具
• 加密、时间、网络等通用工具函数
• 并发控制、错误处理等辅助类