100万级连接，石墨文档WebSocket网关如何架构？

╰半橙微兮° 2024-03-02 10:41 36阅读 0赞

### 说在前面 ###

在40岁老架构师 尼恩的**读者交流群**(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。

最近，尼恩指导一个小伙伴简历，写了一个《**高并发网关项目**》，此项目帮这个小伙拿到 **字节/阿里/微博/汽车之家** 面邀， 所以说，这是一个牛逼的项目。

为了帮助大家拿到更多面试机会，拿到更多大厂offer，

尼恩决定：9月份给大家出一章视频介绍这个项目的架构和实操，《33章：10Wqps 高并发 Netty网关架构与实操》，预计月底发布。然后，提供一对一的简历指导，让你简历金光闪闪、脱胎换骨。

《33章：10Wqps 高并发 Netty网关架构与实操》 海报如下：

![bab3c6c08da54f04841cf437267d2717.png][]

配合《33章：10Wqps 高并发 Netty网关架构与实操》， 尼恩会梳理几个工业级、生产级**网关案例**，作为架构素材、设计的素材。

前面梳理了

*  《[日流量200亿，携程网关的架构设计][200]》
 *  《[千万级连接，知乎如何架构长连接网关？][Link 1]》
 *  《[日200亿次调用，喜马拉雅网关的架构设计][200 1]》
 *  《[100万级连接，爱奇艺WebSocket网关如何架构][100_WebSocket]》
 *  《[亿级长连接，淘宝接入层网关的架构设计][Link 2]》
 *  《[单体120万连接，小爱网关如何架构？][120]》

除了以上的6个案例，这里，尼恩又找到一个漂亮的生产级案例：

《**100万级连接，石墨文档WebSocket网关如何架构？**》，

注意，这又一个非常 牛逼的工业级、生产级**网关案例**。

这些案例，并不是尼恩的原创。这些案例，仅仅是尼恩在《33章：10Wqps 高并发 Netty网关架构与实操》备课的过程中，在互联网查找资料的时候，收集起来的，供大家学习和交流使用。

> 《尼恩 架构笔记》《尼恩高并发三部曲》《尼恩Java面试宝典》的PDF，请到公号【技术自由圈】获取

#### 文章目录 ####

*   *  说在前面
     *  100万级连接，石墨文档WebSocket网关如何架构？
     *  1、v1.0架构面临的问题
     *   *  1.1 架构介绍
         *  1.2 面临的问题
     *  2、v2.0架构演进实践
     *   *  2.1 概述
         *  2.2 整体架构
         *  2.3 握手流程
         *  2.4 TLS 内存消耗优化
         *  2.5 Socket ID 设计
         *  2.6 集群会话管理方案：事件广播
         *  2.7 心跳机制
         *  2.8 自定义Headers
         *  2.9 消息接收与发送
         *  2.10 核心对象缓存
         *  2.11数据传输过程优化
         *  2.12 基础设施支持
     *  3、检查成果的时刻：性能压测
     *   *  3.1 压测准备
         *  3.2 模拟场景一
         *  3.3 模拟场景二
         *  3.4 模拟场景三
         *  3.5 模拟场景四
         *  3.6 压测总结
     *  4、总结
     *  说在最后：有问题可以找老架构取经
     *  推荐阅读

### 100万级连接，石墨文档WebSocket网关如何架构？ ###

作者：石墨文档技术团队

在石墨文档的部分业务中，例如文档分享、评论、幻灯片演示和文档表格跟随等场景，涉及到多客户端数据实时同步和服务端批量数据在线推送的需求，一般的 HTTP 协议无法满足服务端主动 Push 数据的场景，因此选择采用 WebSocket 方案进行业务开发。

随着石墨文档业务发展，目前日连接峰值已达百万量级，日益增长的用户连接数和不符合目前量级的架构设计导致了内存和 CPU 使用量急剧增长，因此我们考虑对长连接网关进行重构。

本文分享了石墨文档长连接网关从1.0架构演进到2.0的过程，并总结了整个性能优化的实践过程。

### 1、v1.0架构面临的问题 ###

这套长连接网关系统的v1.0版是使用 Node.js 基于 Socket.IO 进行修改开发的版本，很好的满足了当时用户量级下的业务场景需求。

#### 1.1 架构介绍 ####

**1.0版架构设计图：**

![37e406571e7545339668b7f16d30d6a2.png][]

**1.0版客户端连接流程：**

*  1）用户通过 NGINX 连接网关，该操作被业务服务感知；
 *  2）业务服务感知到用户连接后，会进行相关用户数据查询，再将消息 Pub 到 Redis；
 *  3）网关服务通过 Redis Sub 收到消息；
 *  4）查询网关集群中的用户会话数据，向客户端进行消息推送。

#### 1.2 面临的问题 ####

虽然 1.0 版本的长连接网关在线上运行良好，但是不能很好的支持后续业务的扩展。

**并且有以下几个问题需要解决：**

*  1）资源消耗：Nginx 仅使用 TLS 解密，请求透传，产生了大量的资源浪费，同时之前的 Node 网关性能不好，消耗大量的 CPU、内存；
 *  2）维护与观测：未接入石墨的监控体系，无法和现有监控告警联通，维护上存在一定的困难；
 *  3）业务耦合问题：业务服务与网关功能被集成到了同一个服务中，无法针对业务部分性能损耗进行针对性水平扩容，为了解决性能问题，以及后续的模块扩展能力，都需要进行服务解耦。

### 2、v2.0架构演进实践 ###

#### 2.1 概述 ####

长连接网关系统的v2.0版需要解决很多问题。

比如，石墨文档内部有很多组件（文档、表格、幻灯片和表单等等），在 1.0 版本中组件对网关的业务调用可以通过Redis、Kafka 和 HTTP 接口，来源不可查，管控困难。

此外，从性能优化的角度考虑也需要对原有服务进行解耦合，将 1.0 版本网关拆分为网关功能部分和业务处理部分。

**具体是：**

*  1）网关功能部分为 WS-Gateway：集成用户鉴权、TLS 证书验证和 WebSocket 连接管理等；
 *  2）业务处理部分为 WS-API：组件服务直接与该服务进行 gRPC 通信。

**另外还有：**

*  1）可针对具体的模块进行针对性扩容；
 *  2）服务重构加上 Nginx 移除，整体硬件消耗显著降低；
 *  3）服务整合到石墨监控体系。

#### 2.2 整体架构 ####

**2.0版本架构设计图：**

![7e67fea6a47e45dd850e85a0a9c9e7e1.png][]

**2.0版本客户端连接流程：**

*  1）客户端与 WS-Gateway 服务通过握手流程建立 WebSocket 连接；
 *  2）连接建立成功后，WS-Gateway 服务将会话进行节点存储，将连接信息映射关系缓存到 Redis 中，并通过 Kafka 向 WS-API 推送客户端上线消息；
 *  3）WS-API 通过 Kafka 接收客户端上线消息及客户端上行消息；
 *  4）WS-API 服务预处理及组装消息，包括从 Redis 获取消息推送的必要数据，并进行完成消息推送的过滤逻辑，然后 Pub 消息到 Kafka；
 *  5）WS-Gateway 通过 Sub Kafka 来获取服务端需要返回的消息，逐个推送消息至客户端。

#### 2.3 握手流程 ####

网络状态良好的情况下，完成如下图所示步骤 1 到步骤 6 之后，直接进入 WebSocket 流程；

网络环境较差的情况下，WebSocket 的通信模式会退化成 HTTP 方式，客户端通过 POST 方式推送消息到服务端，再通过 GET 长轮询的方式从读取服务端返回数据。

**客户端初次请求服务端连接建立的握手流程：**

![a0c3f2e27d5d92a12b621249f2adb315.png][]

**流程说明如下：**

*  1）Client 发送 GET 请求尝试建立连接；
 *  2）Server 返回相关连接数据，sid 为本次连接产生的唯一 Socket ID，后续交互作为凭证：  
    `{"sid":"xxx","upgrades":["websocket"],"pingInterval":xxx,"pingTimeout":xxx}`
 *  3）Client 携带步骤 2 中的 sid 参数再次请求；
 *  4）Server 返回 40，表示请求接收成功；
 *  5）Client 发送 POST 请求确认后期降级通路情况；
 *  6）Server 返回 ok，此时第一阶段握手流程完成；
 *  7）尝试发起 WebSocket 连接，首先进行 2probe 和 3probe 的请求响应，确认通信通道畅通后，即可进行正常的 WebSocket 通信。

#### 2.4 TLS 内存消耗优化 ####

客户端与服务端连接建立采用的 wss 协议，在 1.0 版本中 TLS 证书挂载在 Nginx 上，HTTPS 握手过程由 Nginx 完成。为了降低 Nginx 的机器成本，在 2.0 版本中我们将证书挂载到服务上。

通过分析服务内存，如下图所示，TLS 握手过程中消耗的内存占了总内存消耗的大概 30% 左右。

![6426df27cea08f71ed2533c50dd3ccb9.png][]

**这个部分的内存消耗无法避免，我们有两个选择：**

*  1）采用七层负载均衡，在七层负载上进行 TLS 证书挂载，将 TLS 握手过程移交给性能更好的工具完成；
 *  2）优化 Go 对 TLS 握手过程性能，在与业内大佬曹春晖（曹大）的交流中了解到，他最近在 Go 官方库提交的 [PR][]，以及相关的[性能测试数据][Link 3]。

#### 2.5 Socket ID 设计 ####

对每次连接必须产生一个唯一码，如果出现重复会导致串号，消息混乱推送的问题。

这里，选择SnowFlake算法作为唯一码生成算法。

物理机场景中，对副本所在物理机进行固定编号，即可保证每个副本上的服务产生的 Socket ID 是唯一值。

K8S 场景中，这种方案不可行，于是采用注册下发的方式返回编号，WS-Gateway 所有副本启动后，向数据库写入服务的启动信息，获取副本编号，以此作为参数作为 SnowFlake 算法的副本编号进行 Socket ID 生产，服务重启会继承之前已有的副本编号，有新版本下发时会根据自增 ID 下发新的副本编号。

于此同时，Ws-Gateway 副本会向数据库写入心跳信息，以此作为网关服务本身的健康检查依据。

#### 2.6 集群会话管理方案：事件广播 ####

客户端完成握手流程后，会话数据在当前网关节点内存存储，部分可序列化数据存储到 Redis，

redis 会话存储结构说明如下图所示。

<table> 
 <thead> 
  <tr> 
   <th>键</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ws:user:clients:${uid}</td> 
   <td>存储用户和 WebSocket 连接的关系，采用有序集合方式存储</td> 
  </tr> 
  <tr> 
   <td>ws:guid:clients:${guid}</td> 
   <td>存储文件和 WebSocket 连接的关系，采用有序结合方式存储</td> 
  </tr> 
  <tr> 
   <td>ws:client:${socket.id}</td> 
   <td>存储当前 WebSocket连接下的全部用户和文件关系数据，采用Redis Hash 方式进行存储，对应 key 为 user和guid</td> 
  </tr> 
 </tbody> 
</table>

由客户端触发或组件服务触发的消息推送，通过 Redis 存储的数据结构，在 WS-API 服务查询到返回消息体的目标客户端的 Socket ID，再由 WS-Gateway 服务进行集群消费。

如果 Socket ID 不在当前节点，则需要进行节点与会话关系的查询，找到客端户 Socket ID 实际对应的 WS-Gateway 节点，通常有以下两种方案（如下图所示）。

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>事件广播</td> 
   <td>实现简单</td> 
   <td>消息广播数量会随着节点数量上升</td> 
  </tr> 
  <tr> 
   <td>注册中心</td> 
   <td>会话与节点映射关系清晰</td> 
   <td>注册中心强依赖，额外运维成本</td> 
  </tr> 
 </tbody> 
</table>

在确定使用**事件广播方式**进行网关节点间的消息传递后，进一步选择使用哪种具体的消息中间件，列举了三种待选的方案（如下图所示）。

<table> 
 <thead> 
  <tr> 
   <th>特性</th> 
   <th>Redis</th> 
   <th>Kafka</th> 
   <th>RocketMQ</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>开发语言</td> 
   <td>C</td> 
   <td>Scala</td> 
   <td>Java</td> 
  </tr> 
  <tr> 
   <td>单机吞吐量</td> 
   <td>10w+</td> 
   <td>10w+</td> 
   <td>10w+</td> 
  </tr> 
  <tr> 
   <td>可用性</td> 
   <td>主从架构</td> 
   <td>分布式架构</td> 
   <td>分布式架构</td> 
  </tr> 
  <tr> 
   <td>特点</td> 
   <td>功能简单</td> 
   <td>吞吐量、可用性极高</td> 
   <td>功能丰富、定制化强，吞吐量可用性高</td> 
  </tr> 
  <tr> 
   <td>功能特性</td> 
   <td>数据10K 以内性能优异，功能简单，适用于简单业务场景</td> 
   <td>支持核心的 MQ 功能，不支持消息查询或消息回溯等功能</td> 
   <td>支持核心的 MQ 功能，扩展性强</td> 
  </tr> 
 </tbody> 
</table>

于是对 Redis 和其他 MQ 中间件进行 100w 次的入队和出队操作，在测试过程中发现在数据小于 10K 时 Redis 性能表现十分优秀。

进一步结合实际情况：广播内容的数据量大小在 1K 左右，业务场景简单固定，并且要兼容历史业务逻辑，最后选择了 Redis 进行消息广播。

后续还可以将 WS-API 与 WS-Gateway 两两互联，使用 gRPC stream 双向流通信节省内网流量。

#### 2.7 心跳机制 ####

会话在节点内存与 Redis 中存储后，客户端需要通过心跳上报持续更新会话时间戳，客户端按照服务端下发的周期进行心跳上报，上报时间戳首先在内存进行更新，然后再通过另外的周期进行 Redis 同步，避免大量客户端同时进行心跳上报对 Redis 产生压力。

**具体流程：**

*  1）客户端建立 WebSocket 连接成功后，服务端下发心跳上报参数；
 *  2）客户端依据以上参数进行心跳包传输，服务端收到心跳后会更新会话时间戳；
 *  3）客户端其他上行数据都会触发对应会话时间戳更新；
 *  4）服务端定时清理超时会话，执行主动关闭流程；
 *  5）通过 Redis 更新的时间戳数据进行 WebSocket 连接、用户和文件之间的关系进行清理。

**会话数据内存以及 Redis 缓存清理逻辑：**

for {
        
       select {
        
       case <-t.C:
          var now = time.Now().Unix()
          var clients = make([]*Connection, 0)
          dispatcher.clients.Range(func(_, v interface{
        }) bool {
        
             client := v.(*Connection)
             lastTs := atomic.LoadInt64(&client.LastMessageTS)
             if now-lastTs > int64(expireTime) {
        
                clients = append(clients, client)
             } else {
        
                dispatcher.clearRedisMapping(client.Id, client.Uid, lastTs, clearTimeout)
             }
             return true
          })
          for _, cli := range clients {
        
             cli.WsClose()
          }
       }
    }

在已有的两级缓存刷新机制上，进一步通过动态心跳上报频率的方式降低心跳上报产生的服务端性能压力，默认场景中客户端对服务端进行间隔 1s 的心跳上报，假设目前单机承载了 50w 的连接数，当前的 QPS 为：*QPS1 = 500000/1*。

从服务端性能优化的角度考虑，实现心跳正常情况下的动态间隔，每 x 次正常心跳上报，心跳间隔增加 a，增加上限为 y，动态 QPS 最小值为：*QPS2=500000/y*。

极限情况下，心跳产生的 QPS 降低 y 倍。在单次心跳超时后服务端立刻将 a 值变为 1s 进行重试。采用以上策略，在保证连接质量的同时，降低心跳对服务端产生的性能损耗。

#### 2.8 自定义Headers ####

使用 Kafka 自定义 Headers 的目的是避免网关层出现对消息体解码而带来的性能损耗。

客户端 WebSocket 连接建立成功后，会进行一系列的业务操作，我们选择将 WS-Gateway 和 WS-API 之间的操作指令和必要的参数放到 Kafka 的 Headers 中，例如通过 X-XX-Operator 为广播，再读取 X-XX-Guid 文件编号，对该文件内的所有用户进行消息推送。

<table> 
 <thead> 
  <tr> 
   <th>字段</th> 
   <th>说明</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>X-ID</td> 
   <td>WebSocket ID</td> 
   <td>连接 ID</td> 
  </tr> 
  <tr> 
   <td>X-Uid</td> 
   <td>用户 ID</td> 
   <td>用户 ID</td> 
  </tr> 
  <tr> 
   <td>X-Guid</td> 
   <td>文件 ID</td> 
   <td>文件 ID</td> 
  </tr> 
  <tr> 
   <td>X-Inner</td> 
   <td>网关内部操作指令</td> 
   <td>用户加入、用户退出</td> 
  </tr> 
  <tr> 
   <td>X-Event</td> 
   <td>网关事件</td> 
   <td>Connect/Message/Disconnect</td> 
  </tr> 
  <tr> 
   <td>X-Locale</td> 
   <td>语言类型设置</td> 
   <td>语言类型设置</td> 
  </tr> 
  <tr> 
   <td>X-Operator</td> 
   <td>api层操作指令</td> 
   <td>单播、广播、网关内部操作</td> 
  </tr> 
  <tr> 
   <td>X-Auth-Type</td> 
   <td>用户鉴权类型</td> 
   <td>SDKV2、主站、微信、移动端、桌面</td> 
  </tr> 
  <tr> 
   <td>X-Client-Version</td> 
   <td>客户端版本</td> 
   <td>客户端版本</td> 
  </tr> 
  <tr> 
   <td>X-Server-Version</td> 
   <td>网关版本</td> 
   <td>服务端版本</td> 
  </tr> 
  <tr> 
   <td>X-Push-Client-ID</td> 
   <td>客户端 ID</td> 
   <td>客户端 ID</td> 
  </tr> 
  <tr> 
   <td>X-Trace-ID</td> 
   <td>链路 ID</td> 
   <td>链路 ID</td> 
  </tr> 
 </tbody> 
</table>

在 Kafka Headers 中写入了 trace id 和 时间戳，可以追中某条消息的完整消费链路以及各阶段的时间消耗。

![3054fe4f36b95a40b83a948bb61cffb5.png][]

#### 2.9 消息接收与发送 ####

type Packet struct {
        
      ...
    }
     
    type Connect struct {
        
      *websocket.Con
      send chan Packet
    }
     
    func NewConnect(conn net.Conn) *Connect {
        
      c := &Connect{
        
        send: make(chan Packet, N),
      }
      go c.reader()
      go c.writer()
      return c
    }

客户端与服务端的消息交互第一版的写法类似以上写法。

对 Demo 进行压测，发现每个 WebSocket 连接都会占用 3 个 goroutine，每个 goroutine 都需要内存栈，单机承载连十分有限。

主要受制于大量的内存占用，而且大部分时间 c.writer() 是闲置状态，

于是考虑，是否只启用 2 个 goroutine 来完成交互。

type Packet struct {
        
      ...
    }
     
    type Connect struct {
        
      *websocket.Conn
      mux sync.RWMutex
    }
     
    func NewConnect(conn net.Conn) *Connect {
        
      c := &Connect{
        
        send: make(chan Packet, N),
      }
      go c.reader()
      return c
    }
     
    func (c *Connect) Write(data []byte) (err error) {
        
       c.mux.Lock()
       defer c.mux.Unlock()
       ...
       return nil
    }

保留 c.reader() 的 goroutine，如果使用轮询方式从缓冲区读取数据，可能会产生读取延迟或者锁的问题，c.writer() 操作调整为主动调用，不采用启动 goroutine 持续监听，降低内存消耗。

调研了 [gev][] 和 [gnet][] 等基于事件驱动的轻量级高性能网络库，实测发现在大量连接场景下可能产生的消息延迟的问题，所以没有在生产环境下使用。

#### 2.10 核心对象缓存 ####

确定数据接收与发送逻辑后，网关部分的核心对象为 Connection 对象，围绕 Connection 进行了 run、read、write、close 等函数的开发。

使用 sync.pool 来缓存该对象，减轻 GC 压力，创建连接时，通过对象资源池获取 Connection 对象。

生命周期结束之后，重置 Connection 对象后 Put 回资源池。

在实际编码中，建议封装 GetConn()、PutConn() 函数，收敛数据初始化、对象重置等操作。

var ConnectionPool = sync.Pool{
        
       New: func() interface{
        } {
        
          return &Connection{
        }
       },
    }
     
    func GetConn() *Connection {
        
       cli := ConnectionPool.Get().(*Connection)
       return cli
    }
     
    func PutConn(cli *Connection) {
        
       cli.Reset()
       ConnectionPool.Put(cli) // 放回连接池
    }

#### 2.11数据传输过程优化 ####

消息流转过程中，需要考虑消息体的传输效率优化，采用 MessagePack 对消息体进行序列化，压缩消息体大小。调整 MTU 值避免出现分包情况，定义 a 为探测包大小，通过如下指令，对目标服务 ip 进行 MTU 极限值探测。

ping -s {
        a} {
        ip}

a = 1400 时，实际传输包大小为：1428。

其中 28 由 8（ICMP 回显请求和回显应答报文格式）和 20（IP 首部）构成。

![22ecb41441952ddb0721ca50d37f7404.png][]

如果 a 设置过大会导致应答超时，在实际环境包大小超过该值时会出现分包的情况。

![1535787c922bd992f562121237f515c8.png][]

在调试合适的 MTU 值的同时通过 MessagePack 对消息体进行序列号，进一步压缩数据包的大小，并减小 CPU 的消耗。

#### 2.12 基础设施支持 ####

使用[EGO框架][EGO]进行服务开发：业务日志打印，异步日志输出，动态日志级别调整等功能，方便线上问题排查提升日志打印效率；微服务监控体系，CPU、P99、内存、goroutine 等监控。

![7229d0296af53f2d41c7b3413d8ae3c2.png][]

**客户端 Redis 监控：**

![89f200fb3484721d79f18e9620a19751.png][]

**客户端 Kafka 监控：**

![025a0284de26726cb301fe8f1f33545b.png][]

**自定义监控大盘：**

![28310d5b11a571618393a8b8d5a00be6.png][]

### 3、检查成果的时刻：性能压测 ###

#### 3.1 压测准备 ####

**准备的测试平台有：**

*  1）选择一台配置为 4 核 8G 的虚拟机，作为服务机，目标承载 48w 连接;
 *  2）选择八台配置为 4 核 8G 的虚拟机，作为客户机，每台客户机开放 6w 个端口。

#### 3.2 模拟场景一 ####

用户上线，50w 在线用户。

<table> 
 <thead> 
  <tr> 
   <th>服务</th> 
   <th>CPU</th> 
   <th>Memory</th> 
   <th>数量</th> 
   <th>CPU%</th> 
   <th>Mem%</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>WS-Gateway</td> 
   <td>16核</td> 
   <td>32G</td> 
   <td>1台</td> 
   <td>22.38%</td> 
   <td>70.59%</td> 
  </tr> 
 </tbody> 
</table>

单个 WS-Gateway 每秒建立连接数峰值为：1.6w 个/s，每个用户占用内存：47K。

#### 3.3 模拟场景二 ####

测试时间 15 分钟，在线用户 50w，每 5s 推送一条所有用户，用户有回执。

**推送内容为：**

42["message",{
        "type":"xx","data":{
        "type":"xx","clients":[{
        "id":xx,"name":"xx","email":"xx@xx.xx","avatar":"ZgG5kEjCkT6mZla6.png","created_at":1623811084000,"name_pinyin":"","team_id":13,"team_role":"member","merged_into":0,"team_time":1623811084000,"mobile":"+xxxx","mobile_account":"","status":1,"has_password":true,"team":null,"membership":null,"is_seat":true,"team_role_enum":3,"register_time":1623811084000,"alias":"","type":"anoymous"}],"userCount":1,"from":"ws"}}]

测试经过 5 分钟后，服务异常重启，重启原因是内存使用量到超过限制。

![a4a2cae462083e50b5d43be00e953c7e.png][]

![594bfe8a9dc7a9a2c8e09c465c6ae741.png][]

![cfbe468554f3e0ad536fe7f3016e06f9.png][]

![9b2ad4ab31f9a9475c88dcdc8ab4503b.png][]

**分析内存超过限制的原因：**

![d269b586f0886e42ef81f2b39e4d30de.png][]

**新增的广播代码用掉了 9.32% 的内存：**

![84104e4aa9378025c2dab189e9ec7ffe.png][]

**接收用户回执消息的部分消耗了 10.38% 的内存：**

![d3eb0db3d9ca4bb5b9d50c66f28e3990.png][]

进行测试规则调整，测试时间 15 分钟，在线用户 48w，每 5s 推送一条所有用户，用户有回执。

**推送内容为：**

42["message",{
        "type":"xx","data":{
        "type":"xx","clients":[{
        "id":xx,"name":"xx","email":"xx@xx.xx","avatar":"ZgG5kEjCkT6mZla6.png","created_at":1623811084000,"name_pinyin":"","team_id":13,"team_role":"member","merged_into":0,"team_time":1623811084000,"mobile":"+xxxx","mobile_account":"","status":1,"has_password":true,"team":null,"membership":null,"is_seat":true,"team_role_enum":3,"register_time":1623811084000,"alias":"","type":"anoymous"}],"userCount":1,"from":"ws"}}]

<table> 
 <thead> 
  <tr> 
   <th>服务</th> 
   <th>CPU</th> 
   <th>Memory</th> 
   <th>数量</th> 
   <th>CPU%</th> 
   <th>Mem%</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>WS-Gateway</td> 
   <td>16核</td> 
   <td>32G</td> 
   <td>1台</td> 
   <td>44%</td> 
   <td>91.75%</td> 
  </tr> 
 </tbody> 
</table>

连接数建立峰值：1w 个/s，接收数据峰值：9.6w 条/s，发送数据峰值 9.6w 条/s。

#### 3.4 模拟场景三 ####

测试时间 15 分钟，在线用户 50w，每 5s 推送一条所有用户，用户无需回执。

**推送内容为：**

42["message",{
        "type":"xx","data":{
        "type":"xx","clients":[{
        "id":xx,"name":"xx","email":"xx@xx.xx","avatar":"ZgG5kEjCkT6mZla6.png","created_at":1623811084000,"name_pinyin":"","team_id":13,"team_role":"member","merged_into":0,"team_time":1623811084000,"mobile":"+xxxx","mobile_account":"","status":1,"has_password":true,"team":null,"membership":null,"is_seat":true,"team_role_enum":3,"register_time":1623811084000,"alias":"","type":"anoymous"}],"userCount":1,"from":"ws"}}]

<table> 
 <thead> 
  <tr> 
   <th>服务</th> 
   <th>CPU</th> 
   <th>Memory</th> 
   <th>数量</th> 
   <th>CPU%</th> 
   <th>Mem%</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>WS-Gateway</td> 
   <td>16核</td> 
   <td>32G</td> 
   <td>1台</td> 
   <td>30%</td> 
   <td>93%</td> 
  </tr> 
 </tbody> 
</table>

连接数建立峰值：1.1w 个/s，发送数据峰值 10w 条/s，出内存占用过高之外，其他没有异常情况。

![59481379146d79912e2d7260c7e5a0d1.png][]

![111f01a5bb9231b112e215663c0f2caa.png][]

![1bb271f5fb87d1426963856dcf407b7c.png][]

![c19a9c5dc1b87255a838f9ee8dcc3831.png][]

内存消耗极高，分析火焰图，大部分消耗在定时 5s 进行广播的操作上。

![68f3fc6d2731a10c66c86dfc0fd799f4.png][]

#### 3.5 模拟场景四 ####

测试时间 15 分钟，在线用户 50w，每 5s 推送一条所有用户，用户有回执。每秒 4w 用户上下线。

**推送内容为：**

42["message",{
        "type":"xx","data":{
        "type":"xx","clients":[{
        "id":xx,"name":"xx","email":"xx@xx.xx","avatar":"ZgG5kEjCkT6mZla6.png","created_at":1623811084000,"name_pinyin":"","team_id":13,"team_role":"member","merged_into":0,"team_time":1623811084000,"mobile":"+xxxx","mobile_account":"","status":1,"has_password":true,"team":null,"membership":null,"is_seat":true,"team_role_enum":3,"register_time":1623811084000,"alias":"","type":"anoymous"}],"userCount":1,"from":"ws"}}]

<table> 
 <thead> 
  <tr> 
   <th>服务</th> 
   <th>CPU</th> 
   <th>Memory</th> 
   <th>数量</th> 
   <th>CPU%</th> 
   <th>Mem%</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>WS-Gateway</td> 
   <td>16核</td> 
   <td>32G</td> 
   <td>1台</td> 
   <td>46.96%</td> 
   <td>65.6%</td> 
  </tr> 
 </tbody> 
</table>

**连接数建立峰值**：18570 个/s，**接收数据峰值**：329949 条/s，**发送数据峰值**：393542 条/s，未出现异常情况。

![e129bf3740784ed9779e022092f888fb.png][]

![6b173192d3c90ae9c83aae591222a2e8.png][]

![9c82553e5f42f8281ab2dfd48523d88e.png][]

![e748796553e529eba2ce9677aab3472a.png][]

#### 3.6 压测总结 ####

**在16核32G内存的硬件条件下**：单机 50w 连接数，进行以上包括用户上下线、消息回执等四个场景的压测，内存和 CPU 消耗都符合预期，并且在较长时间的压测下，服务也很稳定。

测试的结果基本上是能满足目前量级下的资源节约要求的，我们认为完全可以在此基础上继续完善功能开发。

### 4、总结 ###

面临日益增加的用户量，网关服务的重构是势在必行。

**本次重构主要是：**

*  1）对网关服务与业务服务的解耦，移除对 Nginx 的依赖，让整体架构更加清晰；
 *  2）从用户建立连接到底层业务推送消息的整体流程分析，对其中这些流程进行了具体的优化。

2.0 版本的长连接网关有了更少的资源消耗，更低的单位用户内存损耗、更加完善的监控报警体系，让网关服务本身更加可靠。

**以上优化内容主要是以下各个方面：**

*  1）可降级的握手流程；
 *  2）Socket ID 生产；
 *  3）客户端心跳处理过程的优化；
 *  4）自定义 Headers 避免了消息解码，强化了链路追踪与监控；
 *  5）消息的接收与发送代码结构设计上的优化；
 *  6）对象资源池的使用，使用缓存降低 GC 频率；
 *  7）消息体的序列化压缩；
 *  8）接入服务观测基础设施，保证服务稳定性。

在保证网关服务性能过关的同时，更进一步的是收敛底层组件服务对网关业务调用的方式，从以前的 HTTP、Redis、Kafka 等方式，统一为 gRPC 调用，保证了来源可查可控，为后续业务接入打下了更好的基础。

### 说在最后：有问题可以找老架构取经 ###

架构之路，充满了坎坷

架构和高级开发不一样 ， 架构问题是open/开放式的，架构问题是没有标准答案的

正由于这样，很多小伙伴，尽管耗费很多精力，耗费很多金钱，但是，遗憾的是，**一生都没有完成架构升级**。

**所以，在架构升级/转型过程中，确实找不到有效的方案，可以来找40岁老架构尼恩求助.**

前段时间一个小伙伴，他是跨专业来做Java，现在面临转架构的难题，但是经过尼恩几轮指导，顺利拿到了**Java架构师+大数据架构师offer** 。所以，如果遇到职业不顺，找老架构师帮忙一下，就顺利多了。

### 推荐阅读 ###

《[百亿级访问量，如何做缓存架构设计][Link 4]》

《[多级缓存 架构设计][Link 5]》

《[消息推送 架构设计][Link 6]》

《[阿里2面：你们部署多少节点？1000W并发，当如何部署？][2_1000W]》

《[美团2面：5个9高可用99.999%，如何实现？][2_5_9_99.999]》

《[网易一面：单节点2000Wtps，Kafka怎么做的？][2000Wtps_Kafka]》

《[字节一面：事务补偿和事务重试，关系是什么？][Link 7]》

《[网易一面：25Wqps高吞吐写Mysql，100W数据4秒写完，如何实现？][25Wqps_Mysql_100W_4]》

《[亿级短视频，如何架构？][Link 8]》

《[炸裂，靠“吹牛”过京东一面，月薪40K][40K]》

《[太猛了，靠“吹牛”过顺丰一面，月薪30K][30K]》

《[炸裂了…京东一面索命40问，过了就50W+][40_50W]》

《[问麻了…阿里一面索命27问，过了就60W+][27_60W]》

《[百度狂问3小时，大厂offer到手，小伙真狠！][3_offer]》

《[饿了么太狠：面个高级Java，抖这多硬活、狠活][Java]》

《[字节狂问一小时，小伙offer到手，太狠了！][offer]》

《[收个滴滴Offer：从小伙三面经历，看看需要学点啥？][Offer]》

> 《尼恩 架构笔记》《尼恩高并发三部曲》《尼恩Java面试宝典》PDF，请到下面公号【技术自由圈】取↓↓↓

[bab3c6c08da54f04841cf437267d2717.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/2b263a2236de48089e9272a08da4c94a.png
[200]: https://blog.csdn.net/crazymakercircle/article/details/132672467
[Link 1]: https://blog.csdn.net/crazymakercircle/article/details/132675308
[200 1]: https://blog.csdn.net/crazymakercircle/article/details/132695212
[100_WebSocket]: https://blog.csdn.net/crazymakercircle/article/details/132737300
[Link 2]: https://blog.csdn.net/crazymakercircle/article/details/132886280
[120]: https://blog.csdn.net/crazymakercircle/article/details/132941352
[37e406571e7545339668b7f16d30d6a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/e0393dabbff24462b38214954b3d6980.png
[7e67fea6a47e45dd850e85a0a9c9e7e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/daf01c5d2f014939867c0a98b9484fe4.png
[a0c3f2e27d5d92a12b621249f2adb315.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/0cf063549cd94d539088e4de7e01024f.png
[6426df27cea08f71ed2533c50dd3ccb9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/4a6da9a445004fc0b04db55eb4253856.png
[PR]: https://github.com/golang/go/issues/43563
[Link 3]: https://github.com/golang/go/pull/48229
[3054fe4f36b95a40b83a948bb61cffb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/57d627f33c654d82a17c126257078b30.png
[gev]: https://github.com/Allenxuxu/gev
[gnet]: https://github.com/panjf2000/gnet
[22ecb41441952ddb0721ca50d37f7404.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/5cfa097485f147b0bb414e3a2725f4f1.png
[1535787c922bd992f562121237f515c8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/d37392eed98046e39e98af264cdae96b.png
[EGO]: https://github.com/gotomicro/ego
[7229d0296af53f2d41c7b3413d8ae3c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/2f22a1b78264493db7e170948cc2edf8.png
[89f200fb3484721d79f18e9620a19751.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/ecc225a50b024dc9a371d3c58acb8057.png
[025a0284de26726cb301fe8f1f33545b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c88ae9d9288e4caa83f76c653643e14f.png
[28310d5b11a571618393a8b8d5a00be6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/cd2fbd72d8744dc9aec41354424da78e.png
[a4a2cae462083e50b5d43be00e953c7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/e2212ecb660c472cadda9072542f9c43.png
[594bfe8a9dc7a9a2c8e09c465c6ae741.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/b38d9fc4740e43c5b02cb0b1d674dc75.png
[cfbe468554f3e0ad536fe7f3016e06f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/8dc5d20a1e0b4290afb5355df391e5bb.png
[9b2ad4ab31f9a9475c88dcdc8ab4503b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/4dac3a4af6994727bcbe43855323e111.png
[d269b586f0886e42ef81f2b39e4d30de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/93df11d775d44facbcfbc030df39f340.png
[84104e4aa9378025c2dab189e9ec7ffe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/4aa3ba1d276346c5a75b6fb930d3a50f.png
[d3eb0db3d9ca4bb5b9d50c66f28e3990.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/b83f04e8dd30448ea41b34bb39690a21.png
[59481379146d79912e2d7260c7e5a0d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/d549a3d662b6424797f0f58fd6c837a9.png
[111f01a5bb9231b112e215663c0f2caa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/293a7acdd4734ae48bd93873bdba9bc5.png
[1bb271f5fb87d1426963856dcf407b7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/f5c19d42ad7f46e4b510de9a01539aff.png
[c19a9c5dc1b87255a838f9ee8dcc3831.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/dbb33cb66fa844c6bb6f70ff0b24805c.png
[68f3fc6d2731a10c66c86dfc0fd799f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/215d7ea747014b1d9426cf6bb2656fdb.png
[e129bf3740784ed9779e022092f888fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/72916cba489b438a95c84ba57ebc73dd.png
[6b173192d3c90ae9c83aae591222a2e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/cec60e34480544bf9dbccc0db6a90591.png
[9c82553e5f42f8281ab2dfd48523d88e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/b71c62ee9120462d8700bba6899beaa0.png
[e748796553e529eba2ce9677aab3472a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c3af08b9599e4485a7635f86d25bd2c3.png
[Link 4]: https://blog.csdn.net/crazymakercircle/article/details/132628780
[Link 5]: https://blog.csdn.net/crazymakercircle/article/details/132637261
[Link 6]: https://blog.csdn.net/crazymakercircle/article/details/132561087
[2_1000W]: https://blog.csdn.net/crazymakercircle/article/details/132526730
[2_5_9_99.999]: https://blog.csdn.net/crazymakercircle/article/details/132509763
[2000Wtps_Kafka]: https://blog.csdn.net/crazymakercircle/article/details/132479866
[Link 7]: https://blog.csdn.net/crazymakercircle/article/details/132456546
[25Wqps_Mysql_100W_4]: https://blog.csdn.net/crazymakercircle/article/details/132403212
[Link 8]: https://blog.csdn.net/crazymakercircle/article/details/132379306
[40K]: https://blog.csdn.net/crazymakercircle/article/details/132150378
[30K]: https://blog.csdn.net/crazymakercircle/article/details/132000420
[40_50W]: https://blog.csdn.net/crazymakercircle/article/details/131615296
[27_60W]: https://blog.csdn.net/crazymakercircle/article/details/131147192
[3_offer]: https://blog.csdn.net/crazymakercircle/article/details/131027012
[Java]: https://blog.csdn.net/crazymakercircle/article/details/130989697
[offer]: https://blog.csdn.net/crazymakercircle/article/details/130956376
[Offer]: https://blog.csdn.net/crazymakercircle/article/details/129317821

发表评论取消回复

表情：

评论列表（有 0 条评论，36人围观）

还没有评论，来说两句吧...

相关阅读

相关千万级连接，知乎如何架构长连接网关？

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

淩亂°似流年/ 2024年03月26日 23:16/ 0 赞/ 71 阅读

相关 100万级连接，爱奇艺WebSocket网关如何架构

说在前面在40岁老架构师尼恩的读者社区(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写了

今天药忘吃喽~/ 2024年03月06日 04:44/ 0 赞/ 101 阅读

相关亿级长连接，淘宝接入层网关的架构设计

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

向右看齐/ 2024年03月03日 08:35/ 0 赞/ 45 阅读

相关 100万级连接，石墨文档WebSocket网关如何架构？

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

╰半橙微兮°/ 2024年03月02日 10:41/ 0 赞/ 37 阅读

相关单体120万连接，小爱网关如何架构？

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

缺乏、安全感/ 2024年03月02日 08:01/ 0 赞/ 56 阅读

相关工业级Netty网关，京东是如何架构的？

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

刺骨的言语ヽ痛彻心扉/ 2024年02月22日 09:55/ 0 赞/ 69 阅读

相关企业级API网关，金蝶是如何架构的？

说在前面在40岁老架构师尼恩的读者交流群(50+)中，很多小伙伴拿到一线互联网企业如阿里、网易、有赞、希音、百度、滴滴的面试资格。最近，尼恩指导一个小伙伴简历，写

- 日理万妓/ 2024年02月21日 10:13/ 0 赞/ 55 阅读

相关图文：知乎千万级高性能长连接网关是如何搭建的？

公众号后台回复“面试”，获取精品学习资料 ![format_png][] 扫描下方海报了解专栏详情 ![format_png 1][] ![format_png 2][

深藏阁楼爱情的钟/ 2023年02月13日 08:11/ 0 赞/ 16 阅读

相关 Soul网关websocket同步数据

websocket同步数据初始化属性部分首先启动soul-admin项目，然后启动soul-boostrap项目，可以明显发现websocket连接成功 ![f

港控/mmm°/ 2022年11月19日 09:53/ 0 赞/ 189 阅读

相关微服务架构·网关

学习目标：了解常用filter常用的功能，对gateway有一定的认知，根据业务痛点，成本做出服务的网关选择 zuul | gateway -----------

深碍√TFBOYSˉ_/ 2022年11月14日 13:18/ 0 赞/ 358 阅读