TCP 拥塞控制对数据延迟的影响

这是上周在项目上遇到的一个问题,在内网把问题用英文分析了一遍,觉得挺有用的,所以在博客上打算再写一次。

问题是这样的:我们在当前的环境中,网络延迟 <1ms,服务的延迟是 2ms,现在要迁移到一个新的环境,新的环境网络自身延迟(来回的延迟,RTT,本文中谈到延迟都指的是 RTT 延迟)是 100ms,那么请问,服务的延迟应该是多少?

我们的预期是 102ms 左右,但是现实中,发现实际的延迟涨了不止 100ms,P99 到了 300ms 左右。

从日志中,发现有请求的延迟的确很高,但是模式就是 200ms, 300ms 甚至 400ms 左右,看起来是多花了几个 RTT。

接下来就根据日志去抓包,最后发现,时间花在了 TCP 本身的机制上面,这些高延迟的请求都发生在 TCP 创建连接之后。

首先是 TCP 创建连接的时间,TCP 创建连接需要三次握手,需要额外增加一个 RTT。为什么不是两个 RTT?因为过程是这样的:

即第三个包,在 A 发给 B 之后,A 就继续发送下面的数据了,所以可以认为这第三个包不会占用额外的时间。

这样的话,延迟会额外增加一个 RTT,加上本身数据传输的一个 RTT,那么,我们能观察到的最高的 RTT 应该是 2 个 RTT,即 200ms,那么为什么会看到 400ms 的请求呢?

从抓包分析看,我发现在建立 TCP 连接之后,客户端并不是将请求一股脑发送给服务端,而是只发送了一部分,等到接收到服务端的 ACK,然后继续在发送,这就造成了额外的 RTT。看到这里我恍然大悟,原来是 cwnd 造成的。

cwnd 如何分析,之前的博文中也提到过。简单来说,这是 TCP 层面的一个机制,为了避免网络赛车,在建立 TCP 连接之后,发送端并不知道这个网络到底能承受多大的流量,所以发送端会发送一部分数据,如果 OK,满满加大发送数据的量。这就是 TCP 的慢启动。

那么慢启动从多少开始呢?

Linux 中默认是 10.

也就是说,在小于 cwnd=10 * MSS=1448bytes = 14480bytes 数据的情况下,我们可以用 2 RTT 发送完毕数据。即 1 个 RTT 用于建立 TCP 连接,1个 RTT 用于发送数据。

下面这个抓包可以证明这一点,我在 100ms 的环境中,从一端发送了正好 14480 的数据,恰好是用了 200ms:

100ms 用于建立连接,100ms 用于发送数据

如果发送的数据小于 14480 bytes(大约是 14K),那么用的时间应该是一样的。

注意,图中虽然 TCP 在我手的时候,双方协商的 MSS 是 1460bytes,但是由于 TCP 的 Timestamps 会在 options 中占用 12 bytes,所以实际上发送的数据,payload 最大为 1448bytes. 在本文中,可以理解为实际的数据段的 maximum segment size 是 1448 bytes。

Timestamps 在 Options 中占用 12 bytes

但是,如果多了即使 1 byte,延迟也会增加一个 RTT,即需要 300ms。下面是发送 14481 bytes 的抓包情况:

多出来一个 100ms 用于传输这个额外的 byte

慢启动,顾名思义,只发生在启动阶段,如果第一波发出去的数据都能收到确认,那么证明网络的容量足够,可以一次性发送更多的数据,这时 cwnd 就会继续增大了(取决于具体拥塞控制的算法)。

这就是额外的延迟的来源了。回到我们的案例,这个用户的请求大约是 30KiB,响应也大约是 30KiB,而 cwnd 是双向的,即两端分别进行慢启动,所以,请求发送过来 +1 RTT,响应 +1 RTT,TCP 建立连接 +1 RTT,加上本身数据传输就有 1 RTT,总共 4RTT,就解释的通了。

解决办法也很简单,两个问题都可以使用 TCP 长连接来解决。

PS:其实,到这里读者应该发现,这个服务本身的延迟,在这种情况下,也是 4个 RTT,只不过网络环境 A 的延迟很小,在 1ms 左右,这样服务自己处理请求的延迟要远大于网络的延迟,1 个 RTT 和 4 个 RTT 从监控上几乎看不出区别。

PPS:其实,以上内容,比如 “慢启动,顾名思义,只发生在启动阶段“,以及 ”两个问题都可以使用 TCP 长连接来解决“ 的表述是不准确的,详见我们后面又遇到的一个问题:TCP 长连接 CWND reset 的问题分析

Initial CWND 如果修改的话也有办法。

这里的 thread 的讨论,有人提出了一种方法:大意是允许让应用程序通过 socket 参数来设置 CWND 的初始值:

setsockopt(fd, IPPROTO_TCP, TCP_CWND, &val, sizeof (val))

——然后就被骂了个狗血淋头。

Stephen Hemminger 说 IETF TCP 的家伙已经觉得 Linux 里面的很多东西会允许不安全的应用了。这么做只会证明他们的想法。这个 patch 需要做很多 researech 才考虑。

如果 misuse,比如,应用将这个值设置的很大,那么假设一种情况:网络发生拥堵了,这时候应用不知道网络的情况,如果建立连接的话,还是使用一个很大的 initcwnd 来启动,会加剧拥堵,情况会原来越坏,永远不会自动恢复。

David Miller 的观点是,应用不可能知道链路 (Route) 上的特点:

  1. initcwnd 是一个路由链路上的特点,不是 by application 决定的;
  2. 只有人才可能清楚整个链路的质量,所以这个选项只能由人 by route 设置。

所以现在只能 by route 设置。

我实验了一下,将 cwnd 设置为 40:

通过 ip route 命令修改

然后在实验,可以看到这时候,client 发送的时候,可以一次发送更多的数据了。


后记

现在看这个原因,如果懂一点 TCP,很快就明白其中的原理,很简单。

但是现实情况是,监控上只能看到 latency 升高了,但是看不出具体是哪一些请求造成的,只知道这个信息的话,那可能的原因就很多了。到这里,发现问题之后,一般就进入了扯皮的阶段:中间件的用户拿着监控(而不是具体的请求日志)去找平台,平台感觉是网络问题,将问题丢给网络团队,网络团队去检查他们自己的监控,说他们那边显示网络没有问题(网络层的延迟当然没有问题)。

如果要查到具体原因的话,需要:

  1. 先从日志中查找到具体的高延迟的请求。监控是用来发现问题的,而不是用来 debug 的;
  2. 从日志分析时间到底花在了哪一个阶段;
  3. 通过抓包,或者其他手段,验证步骤2 (这个过程略微复杂,因为要从众多连接和数据包中找到具体一个 TCP 的数据流)

我发现在大公司里面,这个问题往往牵扯了多个团队,大家在没有确认问题就出现在某一个团队负责的范围内的时候,就没有人去这么查。

我在排查的时候,还得到一些错误信息,比如开发者告诉我 TCP 连接的保持时间是 10min,然后我从日志看,1min 内连续的请求依然会有高延迟的请求,所以就觉得是 TCP 建立连接 overhead 之外的问题。最后抓包才发现明显的 SYN 阶段包,去和开发核对逻辑,才发现所谓的 10min 保持连接,只是在 Server 侧一段做的,Client 侧不关心这个时间会将 TCP 直接关掉。

幸好抓到的包不会骗人。

 

Golang 程序 crash 的时候自动 core dump

前段时间遇到一个问题,程序莫名其妙 crash 了,stack 也没看出什么端倪来。今天改了一个参数,让 golang 程序在崩溃的时候 core dump。

其实核心就是加一个环境变量就可以了,GOTRACEBACK=1. 但是还有一些其他跟系统相关的问题,这篇文章简单记录一下。

Golang 1.6 之后,这个环境的变量可选值有了一些变化,新的值如下:

  • GOTRACEBACK=none will suppress all tracebacks, you only get the panic message.
  • GOTRACEBACK=single is the new default behaviour that prints only the goroutine believed to have caused the panic.
  • GOTRACEBACK=all causes stack traces for all goroutines to be shown, but stack frames related to the runtime are suppressed.
  • GOTRACEBACK=system is the same as the previous value, but frames related to the runtime are also shown, this will reveal goroutines started by the runtime itself.
  • GOTRACEBACK=crash is unchanged from Go 1.5.

一些要注意的点:

首先,介绍下除了这个 GOTRACEBACK 参数,还有其他一些很有用的能控制 golang 运行时的环境变量,这篇文章总结的很好。

然后这个参数在 macOS 上是无效的,就不要在 MAC 上白费力气了。

Linux 上还受到 ulimit 的限制。可以用 ulimit -c 查看对 Core dump 的大小限制。如果是 0 是 dump 不出来了,也不建议设置成 ulimited。我改成了 50G。如果程序使用 systemd 启动的,可以设置 service unit 文件中的 LimitCORE= 参数,效果等同。

产生的 core dump 存放在哪里了呢?

可以通过这里查看:

这里定义了 core dump 文件的命名方式。

但是在 ubuntu 里面,会看到这样的输出:

意思是通过 pipe 定向到了 apport. apport 是 ubuntu 发行版选择使用的 core dump 管理服务。

默认情况下,用户程序是不会有 core dump 的。然后我们有两个解决办法:

  1. 关闭 apport,使用系统的 core dump 直接写在磁盘上
  2. 配置 apport,让它也写用户的 core dump 文件

第一种方法比较简单,直接修改上文中的 /proc/sys/kernel/core_pattern 文件即可:

注意这里有一个小小的问题要注意一下:这个配置是全局的,只有 root 账户才能编辑。如果在普通用户下执行 sudo echo "kernel.core_pattern=/tmp/%e.%t.%p.%s.core" > /proc/sys/kernel/core_pattern 是不行的,因为在这行命令中,echo 是用 sudo 执行的,但是重定向确实 shell (bash) 来完成的,重定向,即真正的写入工作,实际上没有在 root 下,所以你会得到错误:Permission denied, 或者 Destination /proc/sys/kernel not writable. 解决办法是用这个命令:sudo bash -c 'echo "kernel.core_pattern=/tmp/%e.%t.%p.%s.core" > /proc/sys/kernel/core_pattern'.

然后可以 disable apport:

 

第二种方法,首先要确保 apport 在运行。可以通过 systemctl status apport 查看。也可以看下 apport 日志:

触发一次 core dump,会看到:

意思是 core dump 不是来自于 ubuntu 打包的软件,忽略。

配置方法是,修改 ~/.config/apport/settings (如果没有,手动创建)文件,写入:

再触发一次 core dump,这次日志里就会有写入的信息了:

还要注意的是,这个文件不是 core dump 文件,而是 apport 打包的 debug 文件,可以使用 apport-unpack 解包:

解包出来的 CoreDump 就可以用 gdb 分析了。其他的文件记录了一些系统相关的信息。(感觉是 Ubuntu 用来让用户报告 bug 的)

 

最后,如果进程的 workdir 下没有生成 core dump 的话,可以看下是不是在 /var/lib/systemd/coredump/,网上说用 systemd 的系统会存放在这里,不过我没遇到。

 

用油猴制作一个 Jenkins 日志窗口

上次介绍了油猴脚本的基本使用方法,这篇文章简单记录一下今天用油猴提高 Quality of Life 的一个脚本。

先描述一下我要解决的问题:

我们平时很多线上操作是通过 Jenkins 执行的,要在大规模的机器上运行任务,有时候,这些任务要运行很长时间。我一般会关注着这些自动化操作,一般进行其他的工作。我想让日志一直出现在屏幕上,但是又不影响我其他工作。

解决方法是,我在 Jenkins 页面上加了一个按钮,通过这个按钮可以打开一个最小化的窗口,效果如下:

这是新添加的按钮,点击这里,可以弹出一个日志窗口

 

弹出来的日志窗口位于左上角,没有菜单栏,没有书签栏,也没有 Extentions,基本上所有的空间都用来显示日志了。

这样做操作的时候,有实时的日志一直在滚动着,放心多了。


源代码如下:

直接粘贴到自己的油猴就能用。

核心逻辑是,如果当前页面是 Jenkins 原生的 URL(Params 没有 view_window=minimized),就在页面上插入一个链接 <a>,目标是 当前的 URL + 参数view_window=minimized 。通过代码,设置打开这个 URL 的时候关闭 menubar,toolbar,以及设置好窗口大小,位置等等。 打开一个基本上只有日志的窗口,一致放在屏幕旁边。可以用 Mac 上的 Rectangle 软件,将这个窗口固定在 Top。从这个窗口打开链接(按住 Cmd),还是用 Chrome 正常的窗口打开的,很方便。

如果监测到 URL 中有 view_window=minimized  这个参数,就删除页面内 sidebar,footbar 等,让所有的空间都用来展示日志。

操作的时候最需要的按钮是停止键,但是默认的 Jenkins 把这个按钮放到了页面的最上面,这样在底部看滚动日志,如果需要停止的话,还要拖到页面顶部去找按钮,太慢了。我用 JQuery 把它放到日志滚动下面了。

本来想做成一个 Jenkins 插件直接把公司的 Jenkins 给改了,但是看了下 Jenkins 发布插件还是挺复杂的,还得写点 Java 和 XML,可能要花上一两天。所以就直接用油猴实现了,花了半小时。

 

MTU 和 UDP (以及基于 UDP 的协议)

上次在写了之后《有关 MTU 和 MSS 的一切》之后,最近又有了一个问题,苦苦思索了一个周,终于得到了答案。现在一想问题的答案简单而有效,但是中午吃饭的时候和几个同事讨论,我们都没有很快想到这个,所以还是觉得值得记录一下。

首先我要花一些篇幅来描述一下这个问题。因为和同事交流的时候发现大家会以为我在问另一个问题。

我们知道如果 IP 包的 size 整个大于 MTU 的话,那么 3 层就会负责 fragmentation,即讲一个大包拆成多个小包单独发送。那么我的问题是,三层在将数据从自己这边传给下一个 hop 的时候,只知道自己的 MTU,而不知道对方的 MTU,那么如果对方的 MTU 小于自己的时候,怎么拆包发给它呢?

如何将数据发给 MTU 比自己小的另一侧?

在之前的文章中,我们知道,TCP 因为是有连接的协议,连接在建立的时候,就有 MSS 的协商,如果中间设备的 MTU 比较小,就会 MSS clamping,这样就能保证两端都不会发送超过 MTU 的数据。

但是对于面向无连接的协议,比如 UDP,怎么处理这个问题呢?

首先,不处理肯定是不行的,因为理论上收到了 MTU 比自己能接受的 MTU 还要大的包,就会被丢弃。UDP 有没有重传机制,那么就一直发,一直丢,发送端也不知道发生了什么事情。

然后想到了了 PMTUD,那篇文章也提到过。但是 PMTUD 的目的是:避免进行 IP fragmentation,先通过 PMTUD 得知链路上的 MTU 是多少,然后在后续的通讯中保证不发送大于 MTU 大小的包。这不是我问的问题,我的问题是,如果对方的 MTU 比较小,这时候 Don’t Fragmentation 又没有设置,三层是怎么拆包的。并且,向 UDP 这种协议,有一些场景也不现实,难道 DNS 一次请求之前我都要发送多个包去探测 MTU 吗?效率也太低了。我还实际去抓了包,确实是没有 PMTUD 的。

下一个得到的答案是:对方会把包丢弃,然后发送一个 ICMP 回来,Type=3 (Destination Unreachable) and code=4, packet too big and DF is set. 表示我收到一个包,大的我无法转发,但是这个包又设置了 DF,让我不要拆包,没办法,只好丢了,你要知道。这个答案我也不是很满意,因为按照语义,这个 Code=4 的意思是 DF is set 我才丢的。而我想问的是,DF 没有 set,你随便拆,你要怎么知道对方的 MTU 然后拆包呢?

这些答案是我和同事们讨论过的,好像都可以解决问题,但是又好像都不太合理。

其中搜索了一些资料,感觉都没有直接回答这个问题,大部分文章提到这部分的时候好像都直接略过了,只是介绍如何根据自己这一端的 MTU 进行 fragmentation。有一些感觉比较离谱,比如这里,说路由器知道对方的 MTU。我就好奇了,它怎么知道的?IP 协议没有任何机制协商 MTU 呀。

我还自己做了一个实验,进行验证。搞了两个虚拟机,A MTU=1000,B MTU=500,然后用 A 去 ping B,size=800,结果发现 A 到 B 没有 fragmentation,B 到 A 有 fragmentation。但是两边都能收到包(我猜这个是实验环境的问题,因为两个 VM 中间的网络比较简单,所以网卡都能处理这种不合理的包?)至少,我们证明了在 IP 这一层,它不会去关心对方的 MTU 是什么,只会根据自己这边的 MTU 去 fragmentation.

某天有同事从深圳来新加坡出差,我们一起吃饭,又提起这个话题,他直接说:UDP 不管这个问题呀!

对哦,这就是我为什么在 UDP 相关的资料中都没发现和 MTU 有关的东西。这个协议太简单了,不处理这个问题。如果你要基于 UDP 实现一个协议,就要自己处理超过 MTU 的问题。

这是我基于自己读了一些 RFC 之后认为的答案,如果有错误,欢迎指出。

比如:

DNS 协议规定:RFC 1035 DNS 响应不能超过 512 bytes(UDP message),如果超过 512 bytes,在 512 bytes 之后的内容就会被截断。512 bytes 的内容是安全的吗?(链路上所有的节点都能正常接受这个 size?),我们来算一下:2 层 Ethernet 最小的 Frame 是 576 bytes, IP header 20 bytes + IP option 0-40 bytes, UDP header 8 bytes, 所以在 IP option =0 的时候,512 bytes 的 UDP message 最终的 Ethernet Frame 是: 512 bytes + 20 bytes + 0 + 8 = 540 bytes, 小于 576 bytes。是安全的。IP option 在小于 576 – 540 = 36 bytes 的时候是安全的,可以说,在绝大部分情况,这个大小是安全的。

这是 DNS 对 MTU 问题的解决办法:我只发送全世界最小的二层包,总没问题了吧?

与之类似解决方法的是 TFTP 协议(RFC 1350),默认是 512 bytes,但是可以配置。不过用户要自己对配置负责,配置不当就直接丢包

KCP 也是有一个默认值 1400 bytes,但是支持通过函数 ikcp_setmtu 来设置。因为本质上这个是 “Pure algorithm protocol”,你可以有自己的 MTU 探测实现。

最后是 QUIC,这个最具有代表性。它的处理方法是:

  1. QUIC 的实现应该(RFC 用的是 SHOULD)使用 PMTUD,并且应该记录每一个 source ip + dest ip 的 MTU
  2. 但是如果没有 PMTUD 的话,也可以认为 MTU=1280,协议设置 max_udp_payload_size = 1200 bytes,如此,按照上面的算法的话,IPv4 的 header 最多可以有 52 bytes,IPv6 的 header 可以有 32 bytes,正常情况下也够用
  3. 如果链路上连 1280 的 PDU 都支持不了,QUIC 就会这个 UDP 无法使用(和端口连不上等同),然后会 fallback 到 TCP

对于3,还有一个问题,就是 QUIC 如何知道 1280 的 MTU 能不能传呢?我发现了这个协议一个很神奇的设置,就是它的每一个 IP 包大小都是一样的,比如 MTU=1280,那么发送的每一个二层包都是 1280 bytes,不够的就 padding 到 1280,如果传不过去,那么握手包也传不过去,一开始就被丢弃了。

QUIC 所有的包都一样大

很绝妙,不过我觉得有一点要注意的是,中间 overlay 协议在设计的时候可能要注意这一点:比如 Overlay 要在中间插入 100 bytes 的数据,MTU 设置为 1400,那么就不应该接收 1450 的包。即,即使有时候没有 100 bytes 的数据要插入的时候,也应该 padding 100 bytes 进去。否则的话,像 QUIC 这种协议,就可能握手阶段没问题,让它过去了,协议认为 MTU=1450,但是后面可能会频繁丢包。

最后,重申一下我对 QUIC 不是很了解,只是浅读了一些资料。如果读者发现本文错误,欢迎指出。

 

部署和维护开源软件的经验

现在公司多多少少都会用一些开源的软件,我在工作中也部署和维护了很多开源软件。这篇文章就讲讲维护这些软件的一些经验。我主要想说的,是那些需要部署的服务,比如 Jenkins,Prometheus 这些。命令行工具,和库之类的,不在讨论的范围内(但是有一些经验是同样适用的)。

技术选型

如果能解决问题的方案有很多的话,选择哪一种来使用呢?

对开源软件技术选型的时候,可以参考的因素有:

口碑,被接受程度。如果软件的用户越多,那么存在的问题暴露的概率就越大,网上的资料也越多。需要去踩的坑也就越少。

已经存在的时间。同上,久经考验的软件相对可靠一些。

API 和 开放性。这一点容易被忽略。如果有 API 支持的话,在结合公司内部其他系统的时候就会简单很多。也可以做更多定制化的功能。存储使用的格式是什么?如果是公开的标准的话,比如 VictoriaMetrics 有针对 Prometheus 很方便的导入和导出,之后迁移会简单很多,就算以后不用这个软件了,也能很容易地换到其他的方案上。

做决策的支持一部分是知识,一部分是信息。信息就主要来自于项目文档。项目的 issue 页面,和社区讨论也值得参考。

项目文档建议仔细阅读一遍,能得到不少 insights。我经常在解决一个问题的时候,苦于不知道这个工具是否提供了某种方案可以解决这个问题。如果度过一遍文档的时候,遇到问题,你至少能想起某一个关键字。

读文档看似是挺花费时间的,但其实是节省时间。它至少可以加深你对软件的了解。(我发现我花时间最多的,就是用一个工具干不适合它干的事情……)

从 0 到 1 搭建

新部署一个开源软件,主要需要解决两个方面的问题。

第一个问题是如何将它部署到自家公司的基础设施中。常见的部署方法有:

  • 直接在机器上安装 Docker,然后一个 Docker 命令启动;
  • 写 ansible playbook 部署
  • 使用 k8s (一般公司内部都会有定制化)

对于合适的软件选择合适的部署方法非常重要。不要小看一行命令 Docker 部署这种方式,对于有些软件来说非常合适,比如 Jenkins,它的 Java 依赖比较难处理,又有很多系统依赖,但是本质是一个非常独立的单体应用,依赖的内容存储在一个单一的文件夹中,这种就非常适合用 Docker 部署了,升级和重启都是一行命令。虽然是手动操作,但这种方式几乎是效率最高的。

WordPress 是一个特殊的例子,这个软件有一些神奇的功能,比如在后台点一下,它可以去更新自己的代码,升级插件代码,甚至能升级自己本身。所以我将 wordpress 的运行环境整个都放在一个 Git 中,追踪代码的变化。

第二个问题是解决依赖,软件一般都有对其他服务的依赖,最常见的是存储。这部分选型的时候也可以考虑,一般依赖越少越好。比如 Jenkins,这个东西很神奇,基本上只依赖一个 $HOME_DIR, 给它一个文件夹,其他什么都不需要了,对升级和备份特别友好。其他依赖比如网关怎么接入,用户怎么登陆,后端的存储怎么维护,等等。

定制功能

官方的版本没有办法满足所有人的需求,我们经常需要对软件进行定制化。

需要强调的是,最好使用软件支持的一些插件的格式来做,比如 Jenkins, CoreDNS, K8s 等等,都支持插件。还有一些像是 Prometheus,可以通过写外部服务的方式做定制化的功能。

下下策就是直接 fork 修改软件的代码,这样就脱离主干了,后面很难跟进官方的升级。(不过要是能直接给官方提交 PR,是一个不错的方式)

升级

这其实是一个很重要的问题,就是要跟进官方的更新。

为什么说很重要呢?我见过很多故事,都是安装上一个软件版本,之后就再也不更新了,因为跑的好好的,没有人想去动(大部分软件都是这样,你通过它的版本就可以发现它是什么时候引入公司的,笑)。或者是因为 fork 修改了代码,升级升不动。然后从这个版本开始,存在的问题,可能你都要自己解决一遍。可能官方已经发布修复或者优化了,但是因为没有升级,就没办法享受到。甚至你都不知道这个更新。

所以建议订阅官方的发布记录,一般都会有提供 RSS 的订阅方式。

要阅读每一个版本的 changelog。

最好不要进行跨版本升级,因为有些不兼容修改可能会导致问题(还是以官方的升级指引为准)。

还可以订阅一些核心开发者的消息动态,看看大家都在关心什么问题,解决什么问题。

支持

最后,使用软件的过程中一定会遇到各种问题。如果当前没有解决方案,但是又有很多人有同样的问题,那么可以尝试自己去解决一下。(回馈社区!)

报告问题,在某种程度上也是一种支持。但是要把问题说清楚,提交可以复现的 Case。

如果没精力,那么捐点钱也是很大的支持。