Linux 命令神器:lsof 入门

lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息,但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实,因为它是指“列出打开文件(lists openfiles)”。而有一点要切记,在Unix中一切(包括网络套接口)都是文件。

有趣的是,lsof也是有着最多开关的Linux/Unix命令之一。它有那么多的开关,它有许多选项支持使用-和+前缀。

  1. usage: [-?abhlnNoOPRstUvV] [+|-c c] [+|-d s] [+D D] [+|-f[cgG]]
  2. [-F [f]] [-g [s]] [-i [i]] [+|-L [l]] [+|-M] [-o [o]]
  3. [-p s] [+|-r [t]] [-S [t]] [-T [t]] [-u s] [+|-w] [-x [fl]] [–] [names]

正如你所见,lsof有着实在是令人惊讶的选项数量。你可以使用它来获得你系统上设备的信息,你能通过它了解到指定的用户在指定的地点正在碰什么东西,或者甚至是一个进程正在使用什么文件或网络连接。

对于我,lsof替代了netstat和ps的全部工作。它可以带来那些工具所能带来的一切,而且要比那些工具多得多。那么,让我们来看看它的一些基本能力吧:

关键选项

理解一些关于lsof如何工作的关键性东西是很重要的。最重要的是,当你给它传递选项时,默认行为是对结果进行“或”运算。因此,如果你正是用-i来拉出一个端口列表,同时又用-p来拉出一个进程列表,那么默认情况下你会获得两者的结果。

下面的一些其它东西需要牢记:

  • 默认 : 没有选项,lsof列出活跃进程的所有打开文件
  • 组合 : 可以将选项组合到一起,如-abc,但要当心哪些选项需要参数
  • -a : 结果进行“与”运算(而不是“或”)
  • -l : 在输出显示用户ID而不是用户名
  • -h : 获得帮助
  • -t : 仅获取进程ID
  • -U : 获取UNIX套接口地址
  • -F : 格式化输出结果,用于其它命令。可以通过多种方式格式化,如-F pcfn(用于进程id、命令名、文件描述符、文件名,并以空终止)

获取网络信息

正如我所说的,我主要将lsof用于获取关于系统怎么和网络交互的信息。这里提供了关于此信息的一些主题:

使用-i显示所有连接

有些人喜欢用netstat来获取网络连接,但是我更喜欢使用lsof来进行此项工作。结果以对我来说很直观的方式呈现,我仅仅只需改变我的语法,就可以通过同样的命令来获取更多信息。

  1. # lsof i
  2.  
  3. COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
  4. dhcpcd 6061 root 4u IPv4 4510 UDP *:bootpc
  5. sshd 7703 root 3u IPv6 6499 TCP *:ssh (LISTEN)
  6. sshd 7892 root 3u IPv6 6757 TCP 10.10.1.5:ssh->192.168.1.5:49901 (ESTABLISHED)

使用-i 6仅获取IPv6流量

  1. # lsof i 6

仅显示TCP连接(同理可获得UDP连接)

你也可以通过在-i后提供对应的协议来仅仅显示TCP或者UDP连接信息。

  1. # lsof iTCP
  2.  
  3. COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
  4. sshd 7703 root 3u IPv6 6499 TCP *:ssh (LISTEN)
  5. sshd 7892 root 3u IPv6 6757 TCP 10.10.1.5:ssh->192.168.1.5:49901 (ESTABLISHED)

使用-i:port来显示与指定端口相关的网络信息

或者,你也可以通过端口搜索,这对于要找出什么阻止了另外一个应用绑定到指定端口实在是太棒了。

  1. # lsof i :22
  2.  
  3. COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
  4. sshd 7703 root 3u IPv6 6499 TCP *:ssh (LISTEN)
  5. sshd 7892 root 3u IPv6 6757 TCP 10.10.1.5:ssh->192.168.1.5:49901 (ESTABLISHED)

使用@host来显示指定到指定主机的连接

这对于你在检查是否开放连接到网络中或互联网上某个指定主机的连接时十分有用。

  1. # lsof i@172.16.12.5
  2.  
  3. sshd 7892 root 3u IPv6 6757 TCP 10.10.1.5:ssh->172.16.12.5:49901 (ESTABLISHED)

使用@host:port显示基于主机与端口的连接

你也可以组合主机与端口的显示信息。

  1. # lsof i@172.16.12.5:22
  2.  
  3. sshd 7892 root 3u IPv6 6757 TCP 10.10.1.5:ssh->172.16.12.5:49901 (ESTABLISHED)

找出监听端口

找出正等候连接的端口。

  1. # lsof i sTCP:LISTEN

你也可以grep “LISTEN”来完成该任务。

  1. # lsof i | grep i LISTEN
  2.  
  3. iTunes 400 daniel 16u IPv4 0x4575228 0t0 TCP *:daap (LISTEN)

找出已建立的连接

你也可以显示任何已经连接的连接。

  1. # lsof i sTCP:ESTABLISHED

你也可以通过grep搜索“ESTABLISHED”来完成该任务。

  1. # lsof i | grep i ESTABLISHED
  2.  
  3. firefoxb 169 daniel 49u IPv4 0t0 TCP 1.2.3.3:1863->1.2.3.4:http (ESTABLISHED)

用户信息

你也可以获取各种用户的信息,以及它们在系统上正干着的事情,包括它们的网络活动、对文件的操作等。

使用-u显示指定用户打开了什么

  1. # lsof u daniel
  2.  
  3. snipped
  4. Dock 155 daniel txt REG 14,2 2798436 823208 /usr/lib/libicucore.A.dylib
  5. Dock 155 daniel txt REG 14,2 1580212 823126 /usr/lib/libobjc.A.dylib
  6. Dock 155 daniel txt REG 14,2 2934184 823498 /usr/lib/libstdc++.6.0.4.dylib
  7. Dock 155 daniel txt REG 14,2 132008 823505 /usr/lib/libgcc_s.1.dylib
  8. Dock 155 daniel txt REG 14,2 212160 823214 /usr/lib/libauto.dylib
  9. snipped

使用-u user来显示除指定用户以外的其它所有用户所做的事情

  1. # lsof u ^daniel
  2.  
  3. snipped
  4. Dock 155 jim txt REG 14,2 2798436 823208 /usr/lib/libicucore.A.dylib
  5. Dock 155 jim txt REG 14,2 1580212 823126 /usr/lib/libobjc.A.dylib
  6. Dock 155 jim txt REG 14,2 2934184 823498 /usr/lib/libstdc++.6.0.4.dylib
  7. Dock 155 jim txt REG 14,2 132008 823505 /usr/lib/libgcc_s.1.dylib
  8. Dock 155 jim txt REG 14,2 212160 823214 /usr/lib/libauto.dylib
  9. snipped

杀死指定用户所做的一切事情

可以消灭指定用户运行的所有东西,这真不错。

  1. # kill 9 `lsof -t -u daniel`

命令和进程

可以查看指定程序或进程由什么启动,这通常会很有用,而你可以使用lsof通过名称或进程ID过滤来完成这个任务。下面列出了一些选项:

使用-c查看指定的命令正在使用的文件和网络连接

  1. # lsof c syslogng
  2.  
  3. COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
  4. syslogng 7547 root cwd DIR 3,3 4096 2 /
  5. syslogng 7547 root rtd DIR 3,3 4096 2 /
  6. syslogng 7547 root txt REG 3,3 113524 1064970 /usr/sbin/syslogng
  7. snipped

使用-p查看指定进程ID已打开的内容

  1. # lsof p 10075
  2.  
  3. snipped
  4. sshd 10068 root mem REG 3,3 34808 850407 /lib/libnss_files2.4.so
  5. sshd 10068 root mem REG 3,3 34924 850409 /lib/libnss_nis2.4.so
  6. sshd 10068 root mem REG 3,3 26596 850405 /lib/libnss_compat2.4.so
  7. sshd 10068 root mem REG 3,3 200152 509940 /usr/lib/libssl.so.0.9.7
  8. sshd 10068 root mem REG 3,3 46216 510014 /usr/lib/liblber2.3
  9. sshd 10068 root mem REG 3,3 59868 850413 /lib/libresolv2.4.so
  10. sshd 10068 root mem REG 3,3 1197180 850396 /lib/libc2.4.so
  11. sshd 10068 root mem REG 3,3 22168 850398 /lib/libcrypt2.4.so
  12. sshd 10068 root mem REG 3,3 72784 850404 /lib/libnsl2.4.so
  13. sshd 10068 root mem REG 3,3 70632 850417 /lib/libz.so.1.2.3
  14. sshd 10068 root mem REG 3,3 9992 850416 /lib/libutil2.4.so
  15. snipped

-t选项只返回PID

  1. # lsof t c Mail
  2.  
  3. 350

文件和目录

通过查看指定文件或目录,你可以看到系统上所有正与其交互的资源——包括用户、进程等。

显示与指定目录交互的所有一切

  1. # lsof /var/log/messages/
  2.  
  3. COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
  4. syslogng 7547 root 4w REG 3,3 217309 834024 /var/log/messages

显示与指定文件交互的所有一切

  1. # lsof /home/daniel/firewall_whitelist.txt

高级用法

tcpdump类似,当你开始组合查询时,它就显示了它强大的功能。

显示daniel连接到1.1.1.1所做的一切

  1. # lsof u daniel i @1.1.1.1
  2.  
  3. bkdr 1893 daniel 3u IPv6 3456 TCP 10.10.1.10:1234->1.1.1.1:31337 (ESTABLISHED)

同时使用-t和-c选项以给进程发送 HUP 信号

  1. # kill HUP `lsof -t -c sshd`

lsof +L1显示所有打开的链接数小于1的文件

这通常(当不总是)表示某个攻击者正尝试通过删除文件入口来隐藏文件内容。

  1. # lsof +L1
  2.  
  3. (hopefully nothing)

显示某个端口范围的打开的连接

  1. # lsof i @fw.google.com:2150=2180

结尾

本入门教程只是管窥了lsof功能的一斑,要查看完整参考,运行man lsof命令或查看在线版本。希望本文对你有所助益,也随时欢迎你的评论和指正

资源

一些贼好用的开发原则

https://mp.weixin.qq.com/s/stjzHiF9_oQKOAo9tYGd-Q

 

下图就是我之前整理的一个与设计原则相关的思维导图。

图片

但是不管你整理的多好,很多人到实际写代码的时候完全想不起这些原则。不用自我怀疑,大多数人都是如此,你并不是特例。
之所以会有这样的情况,是因为总结后的原则大多都太抽象了,往往只有一句话,甚至只是一个词,自然不会有太多深刻的印象。
我们今天不聊这些刻板的名词,来聊聊Z哥在工作中常用到的一些“原则”,以及它们的适用场景,帮助你更好地记住它们。另外,我还给它们做了一下分类,更便于你记忆。
/01  耦合/
01  避免循环依赖
这个原则不管是在单体应用,还是分布式应用里都是非常重要的一个原则,它可以避免「big ball of mud」项目的产生。而且,如果项目里存在着过多的循环依赖,也更容易一不小心写出循环调用的代码,让整个系统陷入死循环。
02  尽量单向依赖
在满足「01」的前提下,尽量做到单向依赖可以大大降低阅读代码、排查问题时的复杂度。如果实在对上游有依赖的话,尽量通过IOC的思路来处理,用隐性依赖代替显性依赖。
如果实在没法通过IOC来解决的话,可以将依赖上游的数据在当前系统冗余一份,然后通过MQ来保持数据同步,在业务处理的时候直接使用本地的这份冗余数据。当然,这个方法的复杂度明显比上面的更高,所以还是优先考虑上面的方案。
03  避免跨层调用
在满足「1」和「2」的前提下,尽量做到避免跨层调用,可以很起到更好的封装效果。
举个最简单的反例,就拿三层架构来说,如果应用层的代码可以直接访问数据访问层,那么业务逻辑层自然会形同虚设。而且,后续一旦涉及到某数据表增加一个参数,要修改的相关调用代码可多了……这也是为什么很多维护不善的老项目越往后大家就越不敢乱动代码的主要原因之一。
/02  对象设计/
01  单一职责原则
其实我在后面会提到SOLID原则,这里为什么将单一原则单独拿出来说呢,因为我觉得它是SOLID的六大原则里最重要的,虽然它看上去最简单。
单一职责原则规定一个类应该有且仅有一个引起它变化的原因,否则类应该被拆分。
Robert C. Martin《敏捷软件开发:原则、模式和实践》
只有深刻理解这个概念,你才能真正发挥面向对象编程语言的最大优势。并且,这个思路也可以运用在模块的划分上。
遵循这一原则最关键的地方在于职责的划分,很多人其实并没有掌握好正确的划分思路。因为这个的确很难,需要你对业务有深入的了解,因为职责存在于业务里。
比如,在电商系统里体现「一个商品在某个平台销售」这个业务,你可以既在「商品」类上设置「销售渠道」属性,也可以在「销售渠道」上设置「在售商品列表」属性,还可以单独设计一个「商品绑定销售渠道」的类。但是我们从单一职责原则来考虑的话,就应该选择最后一个方案。为什么呢?因为在不同的渠道销售商品,其实对商品和销售渠道本身都没有什么影响,商品还是那个商品、渠道还是那个渠道,因此这个业务不是它们的职责。
02  减少if else
这一点可能算不上传统意义上的原则吧。但是我觉得这是很容易体现开发水平高低的一点。所以也列了一下。
大部分的 if-else 都可以合理运用设计模式来消灭掉。比如, 状态模式、策略模式、命令模式、责任链模式、代理模式。
如果对这些设计模式的形态有些模糊了,那么赶紧去回顾一下。
03  数据冗余
冗余数据的确可以带来很多便利,比如减少RPC请求查询其它程序内的数据。但是副作用也是很明显的,付出了需要解决数据一致性问题为代价。因此仅当存在性能要求时,才考虑数据冗余。 
在平时的代码设计中,你可以有很多方法来降低不必要的数据冗余,比如:
  1. 给每一个API或者Function区分必要参数和可选参数。如此一来,对调用方来说能够减少为了传入可选参数而做的不必要的数据冗余以及RPC请求。
  2. 如果是会对外提供访问的API,一定要最小化参数,可以自行获取的数据尽量在内部自行获取,不要求外部传入。目的同1。
我觉得能意识到上面的这些设计原则,已经算得上是一个合格的程序员了。如果想要更近一步,还可以在以下这几个方面考虑。
/01  对象设计/
01  SOLID原则
这个原则鼎鼎大名了,应该大家都知道,就不展开说了。
  • Single Responsibility Principle:单一职责原则
  • Open Closed Principle:开闭原则
  • Liskov Substitution Principle:里氏替换原则
  • Law of Demeter:迪米特法则
  • Interface Segregation Principle:接口隔离原则
  • Dependence Inversion Principle:依赖倒置原则
我为什么将它们放到进阶里面呢,因为我觉得这里面除了单一职责,其它几个原则还兼顾着在可扩展性上的考量。所以,除了单一职责以外的原则没做到位,最多牺牲了可扩展性和一定的耦合度。但是单一职责没做好,可会存在非常大的耦合问题。
/02  数据准确性/
01  可重试
这点可能在单体应用中感受不明显。但是在分布式系统却重要得多。因为网络是不可靠的,如果设计的代码不可重试,那么会存在大量的数据不一致问题需要手动去处理。可头疼死你。
02  幂等
重视「幂等」的原因和「可重试」一样,在单体应用中作用不大,最多对瞬时的重复点击有作用。但是在不可靠网络的分布式系统中,某个请求被重复提交的可能性大大增加,如何保证多次请求的结果是一致的就至关重要了。
03  CAP、BASE
前面的「可重试」和「幂等」更多是在代码级别的数据准确性设计。如果在整个大系统层面考虑数据准确性,需要基于经典的CAP定理、BASE理论去设计。什么业务场景需要保证强一致性,什么业务场景可以接受存在延迟的最终一致性,是需要仔细考量的。
多提一句,如果采用最终一致性方案的话,尽可能地增加一个后续的核对机制,以解决某些异步消息在中途丢失、长期异常挂起等等导致的数据不一致问题。
/03  数据存储/
01  数据安全
其实,要在代码设计上考虑数据安全,只需要一些非常基础的业务意识就够了。你只要能识别到哪些数据是敏感的,针对这些数据做一些保护机制,防止数据泄漏。比如,加密、脱敏、避免越权、减少非必要传输等等。
以上的这些是我目前暂时想到的在工作中最常用的开发原则。如果后续再想到什么我会补充在评论区,也欢迎你在评论区发表你的经验之谈。
还是总结一下,这篇呢Z哥与你分享了一些我在工作中常用的开发原则。总体来说,他们分为4类。
  1. 耦合:避免循环依赖、尽量单向依赖、避免跨层调用。
  2. 对象设计:单一职责原则、减少if else、数据冗余、SOLID原则。
  3. 数据准确性:可重试、幂等、CAP、BASE。
  4. 数据存储:数据安全。

在程序设计领域, SOLID(单一功能、开闭原则、里氏替换、接口隔离以及依赖反转)是由罗伯特·C·马丁在21世纪早期引入,指代了面向对象编程和面向对象设计的五个基本原则。当这些原则被一起应用时,它们使得一个程序员开发一个容易进行软件维护和扩展的系统变得更加可能。

1 单一职责原则(SRP)

一个对象应该只包含单一的职责,并且该职责被完整地封装在一个类中,即又定义有且仅有一个原因使类变更。(甲类负责两个不同的职责:职责A,职责B。当由于职责A需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责B功能发生故障。也就是说职责A和B被耦合在了一起”)。

2 开放封闭原则(OCP)

实体应该对扩展是开放的,对修改是封闭的。即可扩展(extension),不可修改(modification)。

eg:

原代码,不同用户类型进行不同服务,但是后续每新增不同的用户类型,只能在下面继续加判断代码。

修改后代码,用户实现统一的接口,后续新增用户类型,只需要新增对应实现类。

3 里氏替换原则(LSP)

一个对象在其出现的任何地方,都可以用子类实例做替换,并且不会导致程序的错误。
经典的例子: 正方形不是长方形的子类。原因是正方形多了一个属性“长 == 宽”。这时,对正方形类设置不同的长和宽,计算面积的结果是最后设置那项的平方,而不是长*宽,从而发生了与长方形不一致的行为。如果程序依赖了长方形的面积计算方式,并使用正方形替换了长方形,实际表现与预期不符。

4 接口隔离原则(ISP)

接口隔离原则表明客户端不应该被强迫实现一些他们不会使用的接口,应该把胖接口中的方法分组,然后用多个接口替代它,每个接口服务于一个子模块。简单地说,就是使用多个专门的接口比使用单个接口要好很多。

ISP的主要观点如下:

1)一个类对另外一个类的依赖性应当是建立在最小的接口上的。

ISP可以达到不强迫客户(接口的使用方法)依赖于他们不用的方法,接口的实现类应该只呈现为单一职责的角色(遵循SRP原则)

ISP还可以降低客户之间的相互影响—当某个客户要求提供新的职责(需要变化)而迫使接口发生改变时,影响到其他客户程序的可能性最小。

2)客户端程序不应该依赖它不需要的接口方法(功能)。

客户端程序就应该依赖于它不需要的接口方法(功能),那依赖于什么?依赖它所需要的接口。客户端需要什么接口就是提供什么接口,把不需要的接口剔除,这就要求对接口进行细化,保证其纯洁性。

5 依赖倒置原则(DIP)

抽象不应该依赖于细节,细节应当依赖于抽象。换言之,要针对抽象(接口)编程,而不是针对实现细节编程。

开闭原则(OCP)是面向对象设计原则的基础也是整个设计的一个终极目标,而依赖倒置原则(DIP )则是实现OCP原则的一个基础,换句话说开闭原则(OCP)是你盖一栋大楼的设计蓝图,那么依赖倒置原则就是盖这栋大楼的一个钢构框架。

来看一个例子假设我们在开发一个软件产品需要一个日志系统,要将系统产生的一些重要事情记录在记事本上。通常我们的实现如下:

但是随着时间的推移,产品做的好买了很多客户,产品变得越来越大,使用Logger 类的地方成千上万处,可怕的事情终于发生了:

A 客户提出来我想把日志存在数据库中便于做统计分析。

B 客户说我想把日志打印在一个控制台上便于我时时监测系统运行情况。

C 客户说我要把日志存到Windows Azure Storage上。

深度解析 Raft 分布式一致性协议

https://juejin.cn/post/6907151199141625870

笔者期望通过一篇权威靠谱、清晰易懂的系统性文章,帮助读者深入理解 Raft 算法,并能付诸于工程实践中,同时解读不易理解或容易误解的关键点。

本文是 Raft 实战系列理论内容的整合篇,我们结合 Raft 论文讲解 Raft 算法思路,并遵循 Raft 的模块化思想对难理解及容易误解的内容抽丝剥茧。算法方面讲解:选主机制、基于日志实现状态机机制、安全正确维护状态机机制;工程实现方面讲解:集群成员变更防脑裂策略、解决数据膨胀及快速恢复状态机策略、线性一致读性能优化策略等。


1. 概述

1.1 Raft 是什么?

Raft is a consensus algorithm for managing a replicated log. It produces a result equivalent to (multi-)Paxos, and it is as efficient as Paxos, but its structure is different from Paxos; this makes Raft more understandable than Paxos and also provides a better foundation for building practical systems.

–《In Search of an Understandable Consensus Algorithm》

在分布式系统中,为了消除单点提高系统可用性,通常会使用副本来进行容错,但这会带来另一个问题,即如何保证多个副本之间的一致性?

这里我们只讨论强一致性,即线性一致性。弱一致性涵盖的范围较广,涉及根据实际场景进行诸多取舍,不在 Raft 系列的讨论目标范围内。

所谓的强一致性(线性一致性)并不是指集群中所有节点在任一时刻的状态必须完全一致,而是指一个目标,即让一个分布式系统看起来只有一个数据副本,并且读写操作都是原子的,这样应用层就可以忽略系统底层多个数据副本间的同步问题。也就是说,我们可以将一个强一致性分布式系统当成一个整体,一旦某个客户端成功的执行了写操作,那么所有客户端都一定能读出刚刚写入的值。即使发生网络分区故障,或者少部分节点发生异常,整个集群依然能够像单机一样提供服务。

共识算法(Consensus Algorithm)就是用来做这个事情的,它保证即使在小部分(≤ (N-1)/2)节点故障的情况下,系统仍然能正常对外提供服务。共识算法通常基于状态复制机(Replicated State Machine)模型,也就是所有节点从同一个 state 出发,经过同样的操作 log,最终达到一致的 state。

 图:Replicated State Machine

共识算法是构建强一致性分布式系统的基石,Paxos 是共识算法的代表,而 Raft 则是其作者在博士期间研究 Paxos 时提出的一个变种,主要优点是容易理解、易于实现,甚至关键的部分都在论文中给出了伪代码实现。

1.2 谁在使用 Raft

采用 Raft 的系统最著名的当属 etcd 了,可以认为 etcd 的核心就是 Raft 算法的实现。作为一个分布式 kv 系统,etcd 使用 Raft 在多节点间进行数据同步,每个节点都拥有全量的状态机数据。我们在学习了 Raft 以后将会深刻理解为什么 etcd 不适合大数据量的存储(for the most critical data)、为什么集群节点数不是越多越好、为什么集群适合部署奇数个节点等问题。

作为一个微服务基础设施,consul 底层使用 Raft 来保证 consul server 之间的数据一致性。在阅读完第六章后,我们会理解为什么 consul 提供了 defaultconsistentstale 三种一致性模式(Consistency Modes)、它们各自适用的场景,以及 consul 底层是如何通过改变 Raft 读模型来支撑这些不同的一致性模式的。

TiKV 同样在底层使用了 Raft 算法。虽然都自称是“分布式 kv 存储”,但 TiKV 的使用场景与 etcd 存在区别。其目标是支持 100TB+ 的数据,类似 etcd 的单 Raft 集群肯定无法支撑这个数据量。因此 TiKV 底层使用 Multi Raft,将数据划分为多个 region,每个 region 其实还是一个标准的 Raft 集群,对每个分区的数据实现了多副本高可用。

目前 Raft 在工业界已经开始大放异彩,对于其各类应用场景这里不再赘述,感兴趣的读者可以参考 这里,下方有列出各种语言的大量 Raft 实现。

1.3 Raft 基本概念

Raft 使用 Quorum 机制来实现共识和容错,我们将对 Raft 集群的操作称为提案,每当发起一个提案,必须得到大多数(> N/2)节点的同意才能提交。

这里的“提案”我们可以先狭义地理解为对集群的读写操作,“提交”理解为操作成功。

那么当我们向 Raft 集群发起一系列读写操作时,集群内部究竟发生了什么呢?我们先来概览式地做一个整体了解,接下来再分章节详细介绍每个部分。

首先,Raft 集群必须存在一个主节点(leader),我们作为客户端向集群发起的所有操作都必须经由主节点处理。所以 Raft 核心算法中的第一部分就是选主Leader election)——没有主节点集群就无法工作,先票选出一个主节点,再考虑其它事情。

其次,主节点需要承载什么工作呢?它会负责接收客户端发过来的操作请求,将操作包装为日志同步给其它节点,在保证大部分节点都同步了本次操作后,就可以安全地给客户端回应响应了。这一部分工作在 Raft 核心算法中叫日志复制Log replication)。

然后,因为主节点的责任是如此之大,所以节点们在选主的时候一定要谨慎,只有符合条件的节点才可以当选主节点。此外主节点在处理操作日志的时候也一定要谨慎,为了保证集群对外展现的一致性,不可以覆盖或删除前任主节点已经处理成功的操作日志。所谓的“谨慎处理”,其实就是在选主和提交日志的时候进行一些限制,这一部分在 Raft 核心算法中叫安全性Safety)。

Raft 核心算法其实就是由这三个子问题组成的:选主(Leader election)、日志复制(Log replication)、安全性(Safety)。这三部分共同实现了 Raft 核心的共识和容错机制。

除了核心算法外,Raft 也提供了几个工程实践中必须面对问题的解决方案。

第一个是关于日志无限增长的问题。Raft 将操作包装成为了日志,集群每个节点都维护了一个不断增长的日志序列,状态机只有通过重放日志序列来得到。但由于这个日志序列可能会随着时间流逝不断增长,因此我们必须有一些办法来避免无休止的磁盘占用和过久的日志重放。这一部分叫日志压缩Log compaction)。

第二个是关于集群成员变更的问题。一个 Raft 集群不太可能永远是固定几个节点,总有扩缩容的需求,或是节点宕机需要替换的时候。直接更换集群成员可能会导致严重的脑裂问题。Raft 给出了一种安全变更集群成员的方式。这一部分叫集群成员变更Cluster membership change)。

此外,我们还会额外讨论线性一致性的定义、为什么 Raft 不能与线性一致划等号、如何基于 Raft 实现线性一致,以及在如何保证线性一致的前提下进行读性能优化

以上便是理论篇内将会讨论到的大部分内容的概要介绍,这里我们对 Raft 已经有了一个宏观上的认识,知道了各个部分大概是什么内容,以及它们之间的关系。

接下来我们将会详细讨论 Raft 算法的每个部分。让我们先从第一部分选主开始。

2. 选主

2.1 什么是选主

选主(Leader election)就是在分布式系统内抉择出一个主节点来负责一些特定的工作。在执行了选主过程后,集群中每个节点都会识别出一个特定的、唯一的节点作为 leader。

我们开发的系统如果遇到选主的需求,通常会直接基于 zookeeper 或 etcd 来做,把这部分的复杂性收敛到第三方系统。然而作为 etcd 基础的 Raft 自身也存在“选主”的概念,这是两个层面的事情:基于 etcd 的选主指的是利用第三方 etcd 让集群对谁做主节点的决策达成一致,技术上来说利用的是 etcd 的一致性状态机、lease 以及 watch 机制,这个事情也可以改用单节点的 MySQL/Redis 来做,只是无法获得高可用性;而 Raft 本身的选主则指的是在 Raft 集群自身内部通过票选、心跳等机制来协调出一个大多数节点认可的主节点作为集群的 leader 去协调所有决策。

当你的系统利用 etcd 来写入谁是主节点的时候,这个决策也在 etcd 内部被它自己集群选出的主节点处理并同步给其它节点。

2.2 Raft 为什么要进行选主?

按照论文所述,原生的 Paxos 算法使用了一种点对点(peer-to-peer)的方式,所有节点地位是平等的。在理想情况下,算法的目的是制定一个决策,这对于简化的模型比较有意义。但在工业界很少会有系统会使用这种方式,当有一系列的决策需要被制定的时候,先选出一个 leader 节点然后让它去协调所有的决策,这样算法会更加简单快速。

此外,和其它一致性算法相比,Raft 赋予了 leader 节点更强的领导力,称之为 Strong Leader。比如说日志条目只能从 leader 节点发送给其它节点而不能反着来,这种方式简化了日志复制的逻辑,使 Raft 变得更加简单易懂。

2.3 Raft 选主过程

2.3.1 节点角色

Raft 集群中每个节点都处于以下三种角色之一:

  • Leader: 所有请求的处理者,接收客户端发起的操作请求,写入本地日志后同步至集群其它节点。
  • Follower: 请求的被动更新者,从 leader 接收更新请求,写入本地文件。如果客户端的操作请求发送给了 follower,会首先由 follower 重定向给 leader。
  • Candidate: 如果 follower 在一定时间内没有收到 leader 的心跳,则判断 leader 可能已经故障,此时启动 leader election 过程,本节点切换为 candidate 直到选主结束。

2.3.2 任期

每开始一次新的选举,称为一个任期term),每个 term 都有一个严格递增的整数与之关联。

每当 candidate 触发 leader election 时都会增加 term,如果一个 candidate 赢得选举,他将在本 term 中担任 leader 的角色。但并不是每个 term 都一定对应一个 leader,有时候某个 term 内会由于选举超时导致选不出 leader,这时 candicate 会递增 term 号并开始新一轮选举。

Term 更像是一个逻辑时钟logic clock)的作用,有了它,就可以发现哪些节点的状态已经过期。每一个节点都保存一个 current term,在通信时带上这个 term 号。

节点间通过 RPC 来通信,主要有两类 RPC 请求:

  • RequestVote RPCs: 用于 candidate 拉票选举。
  • AppendEntries RPCs: 用于 leader 向其它节点复制日志以及同步心跳。

2.3.3 节点状态转换

我们知道集群每个节点的状态都只能是 leader、follower 或 candidate,那么节点什么时候会处于哪种状态呢?下图展示了一个节点可能发生的状态转换:

接下来我们详细讨论下每个转换所发生的场景。

2.3.3.1 Follower 状态转换过程

Raft 的选主基于一种心跳机制,集群中每个节点刚启动时都是 follower 身份(Step: starts up),leader 会周期性的向所有节点发送心跳包来维持自己的权威,那么首个 leader 是如何被选举出来的呢?方法是如果一个 follower 在一段时间内没有收到任何心跳,也就是选举超时,那么它就会主观认为系统中没有可用的 leader,并发起新的选举(Step: times out, starts election)。

这里有一个问题,即这个“选举超时时间”该如何制定?如果所有节点在同一时刻启动,经过同样的超时时间后同时发起选举,整个集群会变得低效不堪,极端情况下甚至会一直选不出一个主节点。Raft 巧妙的使用了一个随机化的定时器,让每个节点的“超时时间”在一定范围内随机生成,这样就大大的降低了多个节点同时发起选举的可能性。

 图:一个五节点 Raft 集群的初始状态,所有节点都是 follower 身份,term 为 1,且每个节点的选举超时定时器不同

若 follower 想发起一次选举,follower 需要先增加自己的当前 term,并将身份切换为 candidate。然后它会向集群其它节点发送“请给自己投票”的消息(RequestVote RPC)。

 图:S1 率先超时,变为 candidate,term + 1,并向其它节点发出拉票请求

2.3.3.2 Candicate 状态转换过程

Follower 切换为 candidate 并向集群其他节点发送“请给自己投票”的消息后,接下来会有三种可能的结果,也即上面节点状态图中 candidate 状态向外伸出的三条线

1. 选举成功(Step: receives votes from majority of servers)

当candicate从整个集群的大多数(N/2+1)节点获得了针对同一 term 的选票时,它就赢得了这次选举,立刻将自己的身份转变为 leader 并开始向其它节点发送心跳来维持自己的权威。

 图:“大部分”节点都给了 S1 选票

 图:S1 变为 leader,开始发送心跳维持权威

每个节点针对每个 term 只能投出一张票,并且按照先到先得的原则。这个规则确保只有一个 candidate 会成为 leader。

2. 选举失败(Step: discovers current leader or new term)

Candidate 在等待投票回复的时候,可能会突然收到其它自称是 leader 的节点发送的心跳包,如果这个心跳包里携带的 term 不小于 candidate 当前的 term,那么 candidate 会承认这个 leader,并将身份切回 follower。这说明其它节点已经成功赢得了选举,我们只需立刻跟随即可。但如果心跳包中的 term 比自己小,candidate 会拒绝这次请求并保持选举状态。

 图:S4、S2 依次开始选举

 图:S4 成为 leader,S2 在收到 S4 的心跳包后,由于 term 不小于自己当前的 term,因此会立刻切为 follower 跟随 S4

3. 选举超时(Step: times out, new election)

第三种可能的结果是 candidate 既没有赢也没有输。如果有多个 follower 同时成为 candidate,选票是可能被瓜分的,如果没有任何一个 candidate 能得到大多数节点的支持,那么每一个 candidate 都会超时。此时 candidate 需要增加自己的 term,然后发起新一轮选举。如果这里不做一些特殊处理,选票可能会一直被瓜分,导致选不出 leader 来。这里的“特殊处理”指的就是前文所述的随机化选举超时时间

 图:S1 ~ S5 都在参与选举

 图:没有任何节点愿意给他人投票

 图:如果没有随机化超时时间,所有节点将会继续同时发起选举……

以上便是 candidate 三种可能的选举结果。

2.3.3.3 Leader 状态转换过程

节点状态图中的最后一条线是:discovers server with higher term。想象一个场景:当 leader 节点发生了宕机或网络断连,此时其它 follower 会收不到 leader 心跳,首个触发超时的节点会变为 candidate 并开始拉票(由于随机化各个 follower 超时时间不同),由于该 candidate 的 term 大于原 leader 的 term,因此所有 follower 都会投票给它,这名 candidate 会变为新的 leader。一段时间后原 leader 恢复了,收到了来自新leader 的心跳包,发现心跳中的 term 大于自己的 term,此时该节点会立刻切换为 follower 并跟随的新 leader。

上述流程的动画模拟如下:

 图:S4 作为 term2 的 leader

 图:S4 宕机,S5 即将率先超时

 图:S5 当选 term3 的 leader

 图:S4 宕机恢复后收到了来自 S5 的 term3 心跳

 图:S4 立刻变为 S5 的 follower

以上就是 Raft 的选主逻辑,但还有一些细节(譬如是否给该 candidate 投票还有一些其它条件)依赖算法的其它部分基础,我们会在后续“安全性”一章描述。

当票选出 leader 后,leader 也该承担起相应的责任了,这个责任是什么?就是下一章将介绍的“日志复制”。

3. 日志复制

3.1 什么是日志复制

在前文中我们讲过:共识算法通常基于状态复制机Replicated State Machine)模型,所有节点从同一个 state 出发,经过一系列同样操作 log 的步骤,最终也必将达到一致的 state。也就是说,只要我们保证集群中所有节点的 log 一致,那么经过一系列应用(apply)后最终得到的状态机也就是一致的。

Raft 负责保证集群中所有节点 log 的一致性

此外我们还提到过:Raft 赋予了 leader 节点更强的领导力(Strong Leader)。那么 Raft 保证 log 一致的方式就很容易理解了,即所有 log 都必须交给 leader 节点处理,并由 leader 节点复制给其它节点。

这个过程,就叫做日志复制Log replication)。

3.2 Raft 日志复制机制解析

3.2.1 整体流程解析

一旦 leader 被票选出来,它就承担起领导整个集群的责任了,开始接收客户端请求,并将操作包装成日志,并复制到其它节点上去。

整体流程如下:

  • Leader 为客户端提供服务,客户端的每个请求都包含一条即将被状态复制机执行的指令。
  • Leader 把该指令作为一条新的日志附加到自身的日志集合,然后向其它节点发起附加条目请求AppendEntries RPC),来要求它们将这条日志附加到各自本地的日志集合。
  • 当这条日志已经确保被安全的复制,即大多数(N/2+1)节点都已经复制后,leader 会将该日志 apply 到它本地的状态机中,然后把操作成功的结果返回给客户端。

整个集群的日志模型可以宏观表示为下图(x ← 3 代表 x 赋值为 3):

每条日志除了存储状态机的操作指令外,还会拥有一个唯一的整数索引值log index)来表明它在日志集合中的位置。此外,每条日志还会存储一个 term 号(日志条目方块最上方的数字,相同颜色 term 号相同),该 term 表示 leader 收到这条指令时的当前任期,term 相同的 log 是由同一个 leader 在其任期内发送的。

当一条日志被 leader 节点认为可以安全的 apply 到状态机时,称这条日志是 committed(上图中的 committed entries)。那么什么样的日志可以被 commit 呢?答案是:当 leader 得知这条日志被集群过半的节点复制成功时。因此在上图中我们可以看到 (term3, index7) 这条日志以及之前的日志都是 committed,尽管有两个节点拥有的日志并不完整。

Raft 保证所有 committed 日志都已经被持久化,且“最终”一定会被状态机apply。

注:这里的“最终”用词很微妙,它表明了一个特点:Raft 保证的只是集群内日志的一致性,而我们真正期望的集群对外的状态机一致性需要我们做一些额外工作,这一点在《线性一致性与读性能优化》一章会着重介绍。

3.2.2 日志复制流程图解

我们通过 Raft 动画 来模拟常规日志复制这一过程:

如上图,S1 当选 leader,此时还没有任何日志。我们模拟客户端向 S1 发起一个请求。

S1 收到客户端请求后新增了一条日志 (term2, index1),然后并行地向其它节点发起 AppendEntries RPC。

S2、S4 率先收到了请求,各自附加了该日志,并向 S1 回应响应。

所有节点都附加了该日志,但由于 leader 尚未收到任何响应,因此暂时还不清楚该日志到底是否被成功复制。

当 S1 收到2个节点的响应时,该日志条目的边框就已经变为实线,表示该日志已经安全的复制,因为在5节点集群中,2个 follower 节点加上 leader 节点自身,副本数已经确保过半,此时 S1 将响应客户端的请求

leader 后续会持续发送心跳包给 followers,心跳包中会携带当前已经安全复制(我们称之为 committed)的日志索引,此处为 (term2, index1)。

所有 follower 都通过心跳包得知 (term2, index1) 的 log 已经成功复制 (committed),因此所有节点中该日志条目的边框均变为实线。

3.2.3 对日志一致性的保证

前边我们使用了 (term2, index1) 这种方式来表示一条日志条目,这里为什么要带上 term,而不仅仅是使用 index?原因是 term 可以用来检查不同节点间日志是否存在不一致的情况,阅读下一节后会更容易理解这句话。

Raft 保证:如果不同的节点日志集合中的两个日志条目拥有相同的 term 和 index,那么它们一定存储了相同的指令。

为什么可以作出这种保证?因为 Raft 要求 leader 在一个 term 内针对同一个 index 只能创建一条日志,并且永远不会修改它。

同时 Raft 也保证:如果不同的节点日志集合中的两个日志条目拥有相同的 term 和 index,那么它们之前的所有日志条目也全部相同。

这是因为 leader 发出的 AppendEntries RPC 中会额外携带上一条日志的 (term, index),如果 follower 在本地找不到相同的 (term, index) 日志,则拒绝接收这次新的日志

所以,只要 follower 持续正常地接收来自 leader 的日志,那么就可以通过归纳法验证上述结论。

3.2.4 可能出现的日志不一致场景

在所有节点正常工作的时候,leader 和 follower的日志总是保持一致,AppendEntries RPC 也永远不会失败。然而我们总要面对任意节点随时可能宕机的风险,如何在这种情况下继续保持集群日志的一致性才是我们真正要解决的问题。

上图展示了一个 term8 的 leader 刚上任时,集群中日志可能存在的混乱情况。例如 follower 可能缺少一些日志(a ~ b),可能多了一些未提交的日志(c ~ d),也可能既缺少日志又多了一些未提交日志(e ~ f)。

注:Follower 不可能比 leader 多出一些已提交(committed)日志,这一点是通过选举上的限制来达成的,会在下一章《安全性》介绍。

我们先来尝试复现上述 a ~ f 场景,最后再讲 Raft 如何解决这种不一致问题。

场景a~b. Follower 日志落后于 leader

这种场景其实很简单,即 follower 宕机了一段时间,follower-a 从收到 (term6, index9) 后开始宕机,follower-b 从收到 (term4, index4) 后开始宕机。这里不再赘述。

场景c. Follower 日志比 leader 多 term6

当 term6 的 leader 正在将 (term6, index11) 向 follower 同步时,该 leader 发生了宕机,且此时只有 follower-c 收到了这条日志的 AppendEntries RPC。然后经过一系列的选举,term7 可能是选举超时,也可能是 leader 刚上任就宕机了,最终 term8 的 leader 上任了,成就了我们看到的场景 c。

场景d. Follower 日志比 leader 多 term7

当 term6 的 leader 将 (term6, index10) 成功 commit 后,发生了宕机。此时 term7 的 leader 走马上任,连续同步了两条日志给 follower,然而还没来得及 commit 就宕机了,随后集群选出了 term8 的 leader。

场景e. Follower 日志比 leader 少 term5 ~ 6,多 term4

当 term4 的 leader 将 (term4, index7) 同步给 follower,且将 (term4, index5) 及之前的日志成功 commit 后,发生了宕机,紧接着 follower-e 也发生了宕机。这样在 term5~7 内发生的日志同步全都被 follower-e 错过了。当 follower-e 恢复后,term8 的 leader 也刚好上任了。

场景f. Follower 日志比 leader 少 term4 ~ 6,多 term2 ~ 3

当 term2 的 leader 同步了一些日志(index4 ~ 6)给 follower 后,尚未来得及 commit 时发生了宕机,但它很快恢复过来了,又被选为了 term3 的 leader,它继续同步了一些日志(index7~11)给 follower,但同样未来得及 commit 就又发生了宕机,紧接着 follower-f 也发生了宕机,当 follower-f 醒来时,集群已经前进到 term8 了。

3.2.5 如何处理日志不一致

通过上述场景我们可以看到,真实世界的集群情况很复杂,那么 Raft 是如何应对这么多不一致场景的呢?其实方式很简单暴力,想想 Strong Leader 这个词。

Raft 强制要求 follower 必须复制 leader 的日志集合来解决不一致问题。

也就是说,follower 节点上任何与 leader 不一致的日志,都会被 leader 节点上的日志所覆盖。这并不会产生什么问题,因为某些选举上的限制,如果 follower 上的日志与 leader 不一致,那么该日志在 follower 上一定是未提交的。未提交的日志并不会应用到状态机,也不会被外部的客户端感知到。

要使得 follower 的日志集合跟自己保持完全一致,leader 必须先找到二者间最后一次达成一致的地方。因为一旦这条日志达成一致,在这之前的日志一定也都一致(回忆下前文)。这个确认操作是在 AppendEntries RPC 的一致性检查步骤完成的。

Leader 针对每个 follower 都维护一个 next index,表示下一条需要发送给该follower 的日志索引。当一个 leader 刚刚上任时,它初始化所有 next index 值为自己最后一条日志的 index+1。但凡某个 follower 的日志跟 leader 不一致,那么下次 AppendEntries RPC 的一致性检查就会失败。在被 follower 拒绝这次 Append Entries RPC 后,leader 会减少 next index 的值并进行重试。

最终一定会存在一个 next index 使得 leader 和 follower 在这之前的日志都保持一致。极端情况下 next index 为1,表示 follower 没有任何日志与 leader 一致,leader 必须从第一条日志开始同步。

针对每个 follower,一旦确定了 next index 的值,leader 便开始从该 index 同步日志,follower 会删除掉现存的不一致的日志,保留 leader 最新同步过来的。

整个集群的日志会在这个简单的机制下自动趋于一致。此外要注意,leader 从来不会覆盖或者删除自己的日志,而是强制 follower 与它保持一致。

这就要求集群票选出的 leader 一定要具备“日志的正确性”,这也就关联到了前文提到的:选举上的限制。

下一章我们将对此详细讨论。

4. 安全性及正确性

前面的章节我们讲述了 Raft 算法是如何选主和复制日志的,然而到目前为止我们描述的这套机制还不能保证每个节点的状态机会严格按照相同的顺序 apply 日志。想象以下场景:

  1. Leader 将一些日志复制到了大多数节点上,进行 commit 后发生了宕机。
  2. 某个 follower 并没有被复制到这些日志,但它参与选举并当选了下一任 leader。
  3. 新的 leader 又同步并 commit 了一些日志,这些日志覆盖掉了其它节点上的上一任 committed 日志。
  4. 各个节点的状态机可能 apply 了不同的日志序列,出现了不一致的情况。

因此我们需要对“选主+日志复制”这套机制加上一些额外的限制,来保证状态机的安全性,也就是 Raft 算法的正确性。

4.1 对选举的限制

我们再来分析下前文所述的 committed 日志被覆盖的场景,根本问题其实发生在第2步。Candidate 必须有足够的资格才能当选集群 leader,否则它就会给集群带来不可预料的错误。Candidate 是否具备这个资格可以在选举时添加一个小小的条件来判断,即:

每个 candidate 必须在 RequestVote RPC 中携带自己本地日志的最新 (term, index),如果 follower 发现这个 candidate 的日志还没有自己的新,则拒绝投票给该 candidate。

Candidate 想要赢得选举成为 leader,必须得到集群大多数节点的投票,那么它的日志就一定至少不落后于大多数节点。又因为一条日志只有复制到了大多数节点才能被 commit,因此能赢得选举的 candidate 一定拥有所有 committed 日志

因此前一篇文章我们才会断定地说:Follower 不可能比 leader 多出一些 committed 日志。

比较两个 (term, index) 的逻辑非常简单:如果 term 不同 term 更大的日志更新,否则 index 大的日志更新。

4.2 对提交的限制

除了对选举增加一点限制外,我们还需对 commit 行为增加一点限制,来完成我们 Raft 算法核心部分的最后一块拼图。

回忆下什么是 commit:

当 leader 得知某条日志被集群过半的节点复制成功时,就可以进行 commit,committed 日志一定最终会被状态机 apply。

所谓 commit 其实就是对日志简单进行一个标记,表明其可以被 apply 到状态机,并针对相应的客户端请求进行响应。

然而 leader 并不能在任何时候都随意 commit 旧任期留下的日志,即使它已经被复制到了大多数节点。Raft 论文给出了一个经典场景:

上图从左到右按时间顺序模拟了问题场景。

阶段a:S1 是 leader,收到请求后将 (term2, index2) 只复制给了 S2,尚未复制给 S3 ~ S5。

阶段b:S1 宕机,S5 当选 term3 的 leader(S3、S4、S5 三票),收到请求后保存了 (term3, index2),尚未复制给任何节点。

阶段c:S5 宕机,S1 恢复,S1 重新当选 term4 的 leader,继续将 (term2, index2) 复制给了 S3,已经满足大多数节点,我们将其 commit。

阶段d:S1 又宕机,S5 恢复,S5 重新当选 leader(S2、S3、S4 三票),将 (term3, inde2) 复制给了所有节点并 commit。注意,此时发生了致命错误,已经 committed 的 (term2, index2) 被 (term3, index2) 覆盖了。

为了避免这种错误,我们需要添加一个额外的限制:

Leader 只允许 commit 包含当前 term 的日志。

针对上述场景,问题发生在阶段c,即使作为 term4 leader 的 S1 将 (term2, index2) 复制给了大多数节点,它也不能直接将其 commit,而是必须等待 term4 的日志到来并成功复制后,一并进行 commit。

阶段e:在添加了这个限制后,要么 (term2, index2) 始终没有被 commit,这样 S5 在阶段d将其覆盖就是安全的;要么 (term2, index2) 同 (term4, index3) 一起被 commit,这样 S5 根本就无法当选 leader,因为大多数节点的日志都比它新,也就不存在前边的问题了。

以上便是对算法增加的两个小限制,它们对确保状态机的安全性起到了至关重要的作用。

至此我们对 Raft 算法的核心部分,已经介绍完毕。下一章我们会介绍两个同样描述于论文内的辅助技术:集群成员变更和日志压缩,它们都是在 Raft 工程实践中必不可少的部分。

5. 集群成员变更与日志压缩

尽管我们已经通过前几章了解了 Raft 算法的核心部分,但相较于算法理论来说,在工程实践中仍有一些现实问题需要我们去面对。Raft 非常贴心的在论文中给出了两个常见问题的解决方案,它们分别是:

  1. 集群成员变更:如何安全地改变集群的节点成员。
  2. 日志压缩:如何解决日志集合无限制增长带来的问题。

本文我们将分别讲解这两种技术。

5.1 集群成员变更

在前文的理论描述中我们都假设了集群成员是不变的,然而在实践中有时会需要替换宕机机器或者改变复制级别(即增减节点)。一种最简单暴力达成目的的方式就是:停止集群、改变成员、启动集群。这种方式在执行时会导致集群整体不可用,此外还存在手工操作带来的风险。

为了避免这样的问题,Raft 论文中给出了一种无需停机的、自动化的改变集群成员的方式,其实本质上还是利用了 Raft 的核心算法,将集群成员配置作为一个特殊日志从 leader 节点同步到其它节点去。

5.1.1 直接切换集群成员配置

先说结论:所有将集群从旧配置直接完全切换到新配置的方案都是不安全的

因此我们不能想当然的将新配置直接作为日志同步给集群并 apply。因为我们不可能让集群中的全部节点在“同一时刻原子地切换其集群成员配置,所以在切换期间不同的节点看到的集群视图可能存在不同,最终可能导致集群存在多个 leader。

为了理解上述结论,我们来看一个实际出现问题的场景,下图对其进行了展现。

 图5-1

阶段a. 集群存在 S1 ~ S3 三个节点,我们将该成员配置表示为 C-old,绿色表示该节点当前视图(成员配置)为 C-old,其中红边的 S3 为 leader。

阶段b. 集群新增了 S4、S5 两个节点,该变更从 leader 写入,我们将 S1 ~ S5 的五节点新成员配置表示为 C-new,蓝色表示该节点当前视图为 C-new。

阶段c. 假设 S3 短暂宕机触发了 S1 与 S5 的超时选主。

阶段d. S1 向 S2、S3 拉票,S5 向其它全部四个节点拉票。由于 S2 的日志并没有比 S1 更新,因此 S2 可能会将选票投给 S1,S1 两票当选(因为 S1 认为集群只有三个节点)。而 S5 肯定会得到 S3、S4 的选票,因为 S1 感知不到 S4,没有向它发送 RequestVote RPC,并且 S1 的日志落后于 S3,S3 也一定不会投给 S1,结果 S5 三票当选。最终集群出现了多个主节点的致命错误,也就是所谓的脑裂。

 图5-2

上图来自论文,用不同的形式展现了和图5-1相同的问题。颜色代表的含义与图5-1是一致的,在 problem: two disjoint majorities 所指的时间点,集群可能会出现两个 leader。

但是,多主问题并不是在任何新老节点同时选举时都一定可能出现的,社区一些文章在举多主的例子时可能存在错误,下面是一个案例(笔者学习 Raft 协议也从这篇文章中受益匪浅,应该是作者行文时忽略了。文章很赞,建议大家参考学习):

来源:zhuanlan.zhihu.com/p/27207160

 图5-3

该假想场景类似图5-1的阶段d,模拟过程如下:

  1. S1 为集群原 leader,集群新增 S4、S5,该配置被推给了 S3,S2 尚未收到。
  2. 此时 S1 发生短暂宕机,S2、S3 分别触发选主。
  3. 最终 S2 获得了 S1 和自己的选票,S3 获得了 S4、S5 和自己的选票,集群出现两个 leader。

图5-3过程看起来好像和图5-1没有什么大的不同,只是参与选主的节点存在区别,然而事实是图5-3的情况是不可能出现的

注意:Raft 论文中传递集群变更信息也是通过日志追加实现的,所以也受到选主的限制。很多读者对选主限制中比较的日志是否必须是 committed 产生疑惑,回看下在《安全性》一文中的描述:

每个 candidate 必须在 RequestVote RPC 中携带自己本地日志的最新 (term, index),如果 follower 发现这个 candidate 的日志还没有自己的新,则拒绝投票给该 candidate。

这里再帮大家明确下,论文里确实间接表明了,选主时比较的日志是不要求 committed 的,只需比较本地的最新日志就行

回到图5-3,不可能出现的原因在于,S1 作为原 leader 已经第一个保存了新配置的日志,而 S2 尚未被同步这条日志,根据上一章《安全性》我们讲到的选主限制S1 不可能将选票投给 S2,因此 S2 不可能成为 leader。

5.1.2 两阶段切换集群成员配置

Raft 使用一种两阶段方法平滑切换集群成员配置来避免遇到前一节描述的问题,具体流程如下:

阶段一

  1. 客户端将 C-new 发送给 leader,leader 将 C-old 与 C-new 取并集并立即apply,我们表示为 C-old,new
  2. Leader 将 C-old,new 包装为日志同步给其它节点。
  3. Follower 收到 C-old,new 后立即 apply,当 **C-old,new 的大多数节点(即 C-old 的大多数节点和 C-new 的大多数节点)**都切换后,leader 将该日志 commit。

阶段二

  1. Leader 接着将 C-new 包装为日志同步给其它节点。
  2. Follower 收到 C-new 后立即 apply,如果此时发现自己不在 C-new 列表,则主动退出集群。
  3. Leader 确认 C-new 的大多数节点都切换成功后,给客户端发送执行成功的响应。

上图展示了该流程的时间线。虚线表示已经创建但尚未 commit 的成员配置日志,实线表示 committed 的成员配置日志。

为什么该方案可以保证不会出现多个 leader?我们来按流程逐阶段分析。

阶段1. C-old,new 尚未 commit

该阶段所有节点的配置要么是 C-old,要么是 C-old,new,但无论是二者哪种,只要原 leader 发生宕机,新 leader 都必须得到大多数 C-old 集合内节点的投票

以图5-1场景为例,S5 在阶段d根本没有机会成为 leader,因为 C-old 中只有 S3 给它投票了,不满足大多数。

阶段2. C-old,new 已经 commit,C-new 尚未下发

该阶段 C-old,new 已经 commit,可以确保已经被 C-old,new 的大多数节点(再次强调:C-old 的大多数节点和 C-new 的大多数节点)复制。

因此当 leader 宕机时,新选出的 leader 一定是已经拥有 C-old,new 的节点,不可能出现两个 leader。

阶段3. C-new 已经下发但尚未 commit

该阶段集群中可能有三种节点 C-old、C-old,new、C-new,但由于已经经历了阶段2,因此 C-old 节点不可能再成为 leader。而无论是 C-old,new 还是 C-new 节点发起选举,都需要经过大多数 C-new 节点的同意,因此也不可能出现两个 leader。

阶段4. C-new 已经 commit

该阶段 C-new 已经被 commit,因此只有 C-new 节点可以得到大多数选票成为 leader。此时集群已经安全地完成了这轮变更,可以继续开启下一轮变更了。

以上便是对该两阶段方法可行性的分步验证,Raft 论文将该方法称之为共同一致Joint Consensus)。

关于集群成员变更另一篇更详细的论文还给出了其它方法,简单来说就是论证一次只变更一个节点的的正确性,并给出解决可用性问题的优化方案。感兴趣的同学可以参考:《Consensus: Bridging Theory and Practice》

5.2 日志压缩

我们知道 Raft 核心算法维护了日志的一致性,通过 apply 日志我们也就得到了一致的状态机,客户端的操作命令会被包装成日志交给 Raft 处理。然而在实际系统中,客户端操作是连绵不断的,但日志却不能无限增长,首先它会占用很高的存储空间,其次每次系统重启时都需要完整回放一遍所有日志才能得到最新的状态机。

因此 Raft 提供了一种机制去清除日志里积累的陈旧信息,叫做日志压缩

快照Snapshot)是一种常用的、简单的日志压缩方式,ZooKeeper、Chubby 等系统都在用。简单来说,就是将某一时刻系统的状态 dump 下来并落地存储,这样该时刻之前的所有日志就都可以丢弃了。所以大家对“压缩”一词不要产生错误理解,我们并没有办法将状态机快照“解压缩”回日志序列。

注意,在 Raft 中我们只能为 committed 日志做 snapshot,因为只有 committed 日志才是确保最终会应用到状态机的。

上图展示了一个节点用快照替换了 (term1, index1) ~ (term3, index5) 的日志。

快照一般包含以下内容:

  1. 日志的元数据:最后一条被该快照 apply 的日志 term 及 index
  2. 状态机:前边全部日志 apply 后最终得到的状态机

当 leader 需要给某个 follower 同步一些旧日志,但这些日志已经被 leader 做了快照并删除掉了时,leader 就需要把该快照发送给 follower。

同样,当集群中有新节点加入,或者某个节点宕机太久落后了太多日志时,leader 也可以直接发送快照,大量节约日志传输和回放时间。

同步快照使用一个新的 RPC 方法,叫做 InstallSnapshot RPC

至此我们已经将 Raft 论文中的内容基本讲解完毕了。《In Search of an Understandable Consensus Algorithm (Extended Version)》 毕竟只有18页,更加侧重于理论描述而非工程实践。如果你想深入学习 Raft,或自己动手写一个靠谱的 Raft 实现,《Consensus: Bridging Theory and Practice》 是你参考的不二之选。

接下来我们将额外讨论一下关于线性一致性和 Raft 读性能优化的内容。

6. 线性一致性与读性能优化

6.1 什么是线性一致性?

在该系列首篇《基本概念》中我们提到过:在分布式系统中,为了消除单点提高系统可用性,通常会使用副本来进行容错,但这会带来另一个问题,即如何保证多个副本之间的一致性

什么是一致性?所谓一致性有很多种模型,不同的模型都是用来评判一个并发系统正确与否的不同程度的标准。而我们今天要讨论的是强一致性(Strong Consistency)模型,也就是线性一致性(Linearizability),我们经常听到的 CAP 理论中的 C 指的就是它。

其实我们在第一篇就已经简要描述过何为线性一致性:

所谓的强一致性(线性一致性)并不是指集群中所有节点在任一时刻的状态必须完全一致,而是指一个目标,即让一个分布式系统看起来只有一个数据副本,并且读写操作都是原子的,这样应用层就可以忽略系统底层多个数据副本间的同步问题。也就是说,我们可以将一个强一致性分布式系统当成一个整体,一旦某个客户端成功的执行了写操作,那么所有客户端都一定能读出刚刚写入的值。即使发生网络分区故障,或者少部分节点发生异常,整个集群依然能够像单机一样提供服务。

像单机一样提供服务”从感官上描述了一个线性一致性系统应该具备的特性,那么我们该如何判断一个系统是否具备线性一致性呢?通俗来说就是不能读到旧(stale)数据,但具体分为两种情况:

  • 对于调用时间存在重叠(并发)的请求,生效顺序可以任意确定。
  • 对于调用时间存在先后关系(偏序)的请求,后一个请求不能违背前一个请求确定的结果。

只要根据上述两条规则即可判断一个系统是否具备线性一致性。下面我们来看一个非线性一致性系统的例子。

本节例图均来自《Designing Data-Intensive Application》,作者 Martin Kleppmann

如上图所示,裁判将世界杯的比赛结果写入了主库,Alice 和 Bob 所浏览的页面分别从两个不同的从库读取,但由于存在主从同步延迟,Follower 2 的本次同步延迟高于 Follower 1,最终导致 Bob 听到了 Alice 的惊呼后刷新页面看到的仍然是比赛进行中。

虽然线性一致性的基本思想很简单,只是要求分布式系统看起来只有一个数据副本,但在实际中还是有很多需要关注的点,我们继续看几个例子。

上图从客户端的外部视角展示了多个用户同时请求读写一个系统的场景,每条柱形都是用户发起的一个请求,左端是请求发起的时刻,右端是收到响应的时刻。由于网络延迟和系统处理时间并不固定,所以柱形长度并不相同。

  • x 最初的值为 0,Client C 在某个时间段将 x 写为 1
  • Client A 第一个读操作位于 Client C 的写操作之前,因此必须读到原始值 0
  • Client A 最后一个读操作位于 Client C 的写操作之后,如果系统是线性一致的,那么必须读到新值 1
  • 其它与写操作重叠的所有读操作,既可能返回 0,也可能返回 1,因为我们并不清楚写操作在哪个时间段内哪个精确的点生效,这种情况下读写是并发的。

仅仅是这样的话,仍然不能说这个系统满足线性一致。假设 Client B 的第一次读取返回了 1,如果 Client A 的第二次读取返回了 0,那么这种场景并不破坏上述规则,但这个系统仍不满足线性一致,因为客户端在写操作执行期间看到 x 的值在新旧之间来回翻转,这并不符合我们期望的“看起来只有一个数据副本”的要求。

所以我们需要额外添加一个约束,如下图所示。

在任何一个客户端的读取返回新值后,所有客户端的后续读取也必须返回新值,这样系统便满足线性一致了。

我们最后来看一个更复杂的例子,继续细化这个时序图。

如上图所示,每个读写操作在某个特定的时间点都是原子性的生效,我们在柱形中用竖线标记出生效的时间点,将这些标记按时间顺序连接起来。那么线性一致的要求就是:连线总是按照时间顺序向右移动,而不会向左回退。所以这个连线结果必定是一个有效的寄存器读写序列:任何客户端的每次读取都必须返回该条目最近一次写入的值。

线性一致性并非限定在分布式环境下,在单机单核系统中可以简单理解为“寄存器”的特性。

Client B 的最后一次读操作并不满足线性一致,因为在连线向右移动的前提下,它读到的值是错误的(因为Client A 已经读到了由 Client C 写入的 4)。此外这张图里还有一些值得指出的细节点,可以解开很多我们在使用线性一致系统时容易产生的误解:

  • Client B 的首个读请求在 Client D 的首个写请求和 Client A 的首个写请求之前发起,但最终读到的却是最后由 Client A 写成功之后的结果。
  • Client A 尚未收到首个写请求成功的响应时,Client B 就读到了 Client A 写入的值。

上述现象在线性一致的语义下都是合理的。

所以线性一致性(Linearizability)除了叫强一致性(Strong Consistency)外,还叫做原子一致性(Atomic Consistency)、立即一致性(Immediate Consistency)或外部一致性(External Consistency),这些名字看起来都是比较贴切的。

6.2 Raft 线性一致性读

在了解了什么是线性一致性之后,我们将其与 Raft 结合来探讨。首先需要明确一个问题,使用了 Raft 的系统都是线性一致的吗?不是的,Raft 只是提供了一个基础,要实现整个系统的线性一致还需要做一些额外的工作。

假设我们期望基于 Raft 实现一个线性一致的分布式 kv 系统,让我们从最朴素的方案开始,指出每种方案存在的问题,最终使整个系统满足线性一致性。

6.2.1 写主读从缺陷分析

写操作并不是我们关注的重点,如果你稍微看了一些理论部分就应该知道,所有写操作都要作为提案从 leader 节点发起,当然所有的写命令都应该简单交给 leader 处理。真正关键的点在于读操作的处理方式,这涉及到整个系统关于一致性方面的取舍

在该方案中我们假设读操作直接简单地向 follower 发起,那么由于 Raft 的 Quorum 机制(大部分节点成功即可),针对某个提案在某一时间段内,集群可能会有以下两种状态:

  • 某次写操作的日志尚未被复制到一少部分 follower,但 leader 已经将其 commit。
  • 某次写操作的日志已经被同步到所有 follower,但 leader 将其 commit 后,心跳包尚未通知到一部分 follower。

以上每个场景客户端都可能读到过时的数据,整个系统显然是不满足线性一致的。

6.2.2 写主读主缺陷分析

在该方案中我们限定,所有的读操作也必须经由 leader 节点处理,读写都经过 leader 难道还不能满足线性一致?是的!! 并且该方案存在不止一个问题!!

问题一:状态机落后于 committed log 导致脏读

回想一下前文讲过的,我们在解释什么是 commit 时提到了写操作什么时候可以响应客户端:

所谓 commit 其实就是对日志简单进行一个标记,表明其可以被 apply 到状态机,并针对相应的客户端请求进行响应。

也就是说一个提案只要被 leader commit 就可以响应客户端了,Raft 并没有限定提案结果在返回给客户端前必须先应用到状态机。所以从客户端视角当我们的某个写操作执行成功后,下一次读操作可能还是会读到旧值。

这个问题的解决方式很简单,在 leader 收到读命令时我们只需记录下当前的 commit index,当 apply index 追上该 commit index 时,即可将状态机中的内容响应给客户端。

问题二:网络分区导致脏读

假设集群发生网络分区,旧 leader 位于少数派分区中,而且此刻旧 leader 刚好还未发现自己已经失去了领导权,当多数派分区选出了新的 leader 并开始进行后续写操作时,连接到旧 leader 的客户端可能就会读到旧值了。

因此,仅仅是直接读 leader 状态机的话,系统仍然不满足线性一致性。

6.2.3 Raft Log Read

为了确保 leader 处理读操作时仍拥有领导权,我们可以将读请求同样作为一个提案走一遍 Raft 流程,当这次读请求对应的日志可以被应用到状态机时,leader 就可以读状态机并返回给用户了。

这种读方案称为 Raft Log Read,也可以直观叫做 Read as Proposal

为什么这种方案满足线性一致?因为该方案根据 commit index 对所有读写请求都一起做了线性化,这样每个读请求都能感知到状态机在执行完前一写请求后的最新状态,将读写日志一条一条的应用到状态机,整个系统当然满足线性一致。但该方案的缺点也非常明显,那就是性能差,读操作的开销与写操作几乎完全一致。而且由于所有操作都线性化了,我们无法并发读状态机。

6.3 Raft 读性能优化

接下来我们将介绍几种优化方案,它们在不违背系统线性一致性的前提下,大幅提升了读性能。

6.3.1 Read Index

与 Raft Log Read 相比,Read Index 省掉了同步 log 的开销,能够大幅提升读的吞吐一定程度上降低读的时延。其大致流程为:

  1. Leader 在收到客户端读请求时,记录下当前的 commit index,称之为 read index。
  2. Leader 向 followers 发起一次心跳包,这一步是为了确保领导权,避免网络分区时少数派 leader 仍处理请求。
  3. 等待状态机至少应用到 read index(即 apply index 大于等于 read index)。
  4. 执行读请求,将状态机中的结果返回给客户端。

这里第三步的 apply index 大于等于 read index 是一个关键点。因为在该读请求发起时,我们将当时的 commit index 记录了下来,只要使客户端读到的内容在该 commit index 之后,那么结果一定都满足线性一致(如不理解可以再次回顾下前文线性一致性的例子以及2.2中的问题一)。

6.3.2 Lease Read

与 Read Index 相比,Lease Read 进一步省去了网络交互开销,因此更能显著降低读的时延

基本思路是 leader 设置一个比选举超时(Election Timeout)更短的时间作为租期,在租期内我们可以相信其它节点一定没有发起选举,集群也就一定不会存在脑裂,所以在这个时间段内我们直接读主即可,而非该时间段内可以继续走 Read Index 流程,Read Index 的心跳包也可以为租期带来更新。

Lease Read 可以认为是 Read Index 的时间戳版本,额外依赖时间戳会为算法带来一些不确定性,如果时钟发生漂移会引发一系列问题,因此需要谨慎的进行配置。

6.3.3 Follower Read

在前边两种优化方案中,无论我们怎么折腾,核心思想其实只有两点:

  • 保证在读取时的最新 commit index 已经被 apply。
  • 保证在读取时 leader 仍拥有领导权。

这两个保证分别对应2.2节所描述的两个问题。

其实无论是 Read Index 还是 Lease Read,最终目的都是为了解决第二个问题。换句话说,读请求最终一定都是由 leader 来承载的。

那么读 follower 真的就不能满足线性一致吗?其实不然,这里我们给出一个可行的读 follower 方案:Follower 在收到客户端的读请求时,向 leader 询问当前最新的 commit index,反正所有日志条目最终一定会被同步到自己身上,follower 只需等待该日志被自己 commit 并 apply 到状态机后,返回给客户端本地状态机的结果即可。这个方案叫做 Follower Read

注意:Follower Read 并不意味着我们在读过程中完全不依赖 leader 了,在保证线性一致性的前提下完全不依赖 leader 理论上是不可能做到的。


以上就是 Raft 算法的核心内容及工程实践最需要考虑的内容。

如果你坚持看了下来,相信已经对 Raft 算法的理论有了深刻的理解。当然,理论和工程实践之间存在的鸿沟可能比想象的还要大,实践中有众多的细节问题需要去面对。在后续的源码分析及实践篇中,我们会结合代码讲解到许多理论部分没有提到的这些细节点,并介绍基础架构设计的诸多经验,敬请期待!

最多能创建多少个TCP连接?

https://mp.weixin.qq.com/s/mGkf-9LZhhUgSIRBRqfRDw

低并发编程
战略上藐视技术,战术上重视技术
本文坚持看到结尾才有动图
气不气?
我是一个 Linux 服务器上的进程,名叫小进。
老是有人说我最多只能创建 65535 个 TCP 连接。
我不信这个邪,今天我要亲自去实践一下。
我走到操作系统老大的跟前,说:
“老操,我要建立一个 TCP 连接!”
老操不慌不忙,拿出一个表格递给我,”小进,先填表吧”
图片
我一看这个表,这不就是经典的 socket 四元组嘛。我只有一块网卡,其 IP 地址是 123.126.45.68,我想要与 110.242.68.3 的 80 端口建立一个 TCP 连接,我将这些信息填写在了表中。
图片
源端口号填什么呢?我记得端口号是 16 位的,可以有 0 ~ 65535 这个范围的数字,那我随便选一个吧!
正当我犹豫到底选什么数字的时候,老操一把抢过我的表格。
“你墨迹个啥呢小进?源端口号不用你填,我会给你分配一个可用的数字。源IP也不用你填,我知道都有哪些网卡,并且会帮你选个合适的。真是个新手,回去等消息吧。”
“哦”
老操带着我的表格,走了。
过了很长时间,老操终于回来了,并且带着一个纸条。
图片
“小进,你把这个收好了。”
我问道,”这是啥呀?”
老操不耐烦地说道,”刚刚说你是新手你还不服,这个 5 表示文件描述符,linux 下一切皆文件,你待会和你那个目标 IP 进行 TCP 通信的时候,就对着这个文件描述符读写就好啦。”
“这么方便!好的,谢谢老操。”
我拿着这个文件描述符,把它放到属于我的内存中裱起来了,反正我只是想看看最多能创建多少 TCP 连接,又不是去真的用它,嘻嘻。
 
端口号
 
过了一分钟,我又去找老操了。
“老操,我要建立一个 TCP 连接!”
老操不慌不忙,拿出一个表格递给我,”小进,先填表吧”
图片
这回我熟悉了,只把目标IP和目标端口填好。
图片
老操办好事之后,又带着一个纸条回来,上面写着数字”6″。
就这样,我每隔一分钟都去找老操建立一个新的 TCP 连接,目标 IP 都是110.242.68.3,目标端口都是 80。
老操也很奇怪,不知道我在这折腾啥,他虽然权力大,但无权拒绝我的指令,每次都兢兢业业地把事情办好,并给我一张一张写着文件描述符的纸条。
直到有一次,我收到的纸条有些不同。
图片
我带着些许责怪的语气问,”老操,这是怎么回事呀?”
老操也没好气地说,”这表示端口号不够用啦!早就觉得你小子不对劲了,一个劲地对着同一个 IP 和端口创建 TCP 连接,之前没办法必须执行你给的指令,现在不行了,端口号不够用了,源端口那里我没法给你填了。”
我也不是那么好骗的,质疑道。”老操,你也别欺负我这个新手,我可是知道端口号是 16 位的,范围是 1~65535,一共可以创建 65535 个 TCP 连接,我现在才创建了 63977 个,怎么就不够了!”
老操鄙视地看了我一眼,”你小子可真是闲的蛋疼啊,还真一个个数,来我告诉你吧,Linux 对可使用的端口范围是有具体限制的,具体可以用如下命令查看。”
[root]# cat /proc/sys/net/ipv4/ip_local_port_range 
1024 65000
“看到没,当前的限制是1024~65000,所以你就只能有63977个端口号可以使用。”
图片
我赶紧像老操道歉,”哎哟真是抱歉,还是我见识太少,那这个数可以修改么?”
老操也没跟我一般见识,还是耐心地回答我,”可以的,具体可以 vim /etc/sysctl.conf 这个文件进行修改,我们在这个文件里添加一行记录”
net.ipv4.ip_local_port_range = 60000 60009
“保存好后执行 sysctl -p /etc/sysctl.conf 使其生效。这样你就只有 10 个端口号可以用了,就会更快报出端口号不够用的错误”
“原来如此,谢谢老操又给我上了一课。”
哎不对,建立一个 TCP 连接,需要将通信两端的套接字(socket)进行绑定,如下:
源 IP 地址:源端口号 <—->  目标 IP 地址:目标端口号
只要这套绑定关系构成的四元组不重复即可,刚刚端口号不够用了,是因为我一直对同一个目标IP和端口建立连接,那我换一个目标端口号试试。
图片
我又把这个表交给老操,老操一眼就看破了我的小心思,可是也没办法,马上去给我建立了一个新的TCP连接,并且成功返回给我一个新的文件描述符纸条。
看来成功了,只要源端口号不用够用了,就不断变换目标 IP 和目标端口号,保证四元组不重复,我就能创建好多好多 TCP 连接啦!
这也证明了有人说最多只能创建 65535 个TCP连接是多么荒唐。
 
文件描述符
 
找到了突破端口号限制的办法,我不断找老操建立TCP连接,老操也拿我没有办法。
直到有一次,我又收到了一张特殊的纸条,上面写的不是文件描述符。
图片
我又没好气地问老操,”这又是咋回事?”
老操幸灾乐祸地告诉我,”呵呵,你小子以为突破端口号限制就无法无天了?现在文件描述符不够用啦!”
“怎么啥啥都有限制啊?你们操作系统给我们的限制也太多了吧?”
“废话,你看看你都建了多少个TCP连接了!每建立一个TCP连接,我就得分配给你一个文件描述符,linux 对可打开的文件描述符的数量分别作了三个方面的限制。”

系统级:当前系统可打开的最大数量,通过 cat /proc/sys/fs/file-max 查看

用户级:指定用户可打开的最大数量,通过 cat /etc/security/limits.conf 查看

进程级:单个进程可打开的最大数量,通过 cat /proc/sys/fs/nr_open 查看

图片

天呢,真是人在屋檐下呀,我赶紧看了看这些具体的限制。
[root ~]# cat /proc/sys/fs/file-max
100000
[root ~]# cat /proc/sys/fs/nr_open
100000
[root ~]# cat /etc/security/limits.conf
...
* soft nproc 100000
* hard nproc 100000
原来如此,我记得刚刚收到的最后一张纸条是。
图片
再之后就收到文件描述符不够的错误了。
我又请教老操,”老操,那这个限制可以修改么?”
老操仍然耐心地告诉我,”当然可以,比如你想修改单个进程可打开的最大文件描述符限制为100,可以这样。”
echo 100 > /proc/sys/fs/nr_open
“原来如此,我这就去把各种文件描述符限制都改大一点,也不多,就在后面加个0吧”
“额,早知道不告诉你小子了。”老操再次用鄙视的眼睛看着我。
 
线程
 
突破了文件描述符限制,我又开始肆无忌惮地创建起了TCP连接。
但我发现,老操的办事效率越来越慢,建立一个TCP连接花的时间越来越久。
有一次,我忍不住责问老操,”你是不是在偷懒啊?之前找你建一个TCP连接就花不到一分钟时间,你看看最近我哪次不是等一个多小时你才搞好?”
老操也忍不住了,”小进啊你还好意思说我,你知不知道你每建一个TCP连接都需要消耗一个线程来为你服务?现在我和CPU老大那里都忙得不可开交了,一直在为你这好几十万个线程不停地进行上下文切换,我们精力有限啊,自然就没法像以前那么快为你服务了。”
图片
听完老操的抱怨,我想起了之前似乎有人跟我说过 C10K 问题,就是当服务器连接数达到 1 万且每个连接都需要消耗一个线程资源时,操作系统就会不停地忙于线程的上下文切换,最终导致系统崩溃,这可不是闹着玩的。
我赶紧像操作系统老大请教,”老操,实在不好意思,一直以为你强大无比,没想到也有忙得不可开交的时候呀,那我们现在应该怎么办呀?”
老操无奈地说,”我劝你还是别再继续玩了,没什么意义,不过我想你也不会听我的,那我跟你说两句吧。”
你现在这种每建一个TCP连接就创建一个线程的方式,是最传统的多线程并发模型,早期的操作系统也只支持这种方式。但现在我进化了,我还支持 IO 多路复用的方式,简单说就是一个线程可以管理多个 TCP 连接的资源,这样你就可以用少量的线程来管理大量的 TCP 连接了。
图片
我一脸疑惑,”啥是 IO 多路复用啊?”。
老操一脸鄙视,”你这… 你去看看闪客的《你管这破玩意叫 IO 多路复用》,就明白了。”
这次真是大开眼界了,我赶紧把代码改成了这种 IO 多路复用的模型,将原来的 TCP 连接销毁掉,改成同一个线程管理多个 TCP 连接,很快,操作系统老大就恢复了以往的办事效率,同时我的 TCP 连接数又多了起来。
 
内存
 
突破了端口号、文件描述符、线程数等重重限制的我,再次肆无忌惮地创建起了TCP连接。
直到有一次,我又收到了一张红牌。
图片
嗨,又是啥东西限制了呀,改了不就完了。我不耐烦地问老操,”这回又是啥毛病?”
老操说道。”这个错误叫内存溢出,每个TCP连接本身,以及这个连接所用到的缓冲区,都是需要占用一定内存的,现在内存已经被你占满了,不够用了,所以报了这个错。”
图片
我看这次老操特别耐心,也没多说什么,但想着被内存限制住了,有点不太开心,于是我让老操帮我最后一个忙。
“老操呀,帮小进我最后一个忙吧,你权利大,你看看把那些特别占内存的进程给杀掉,给我腾出点地方,我今天要完成我的梦想,看看TCP连接数到底能创建多少个!”
老操见我真的是够拼的,便答应了我,杀死了好多进程,我很是感动。
 
CPU
 
有了老操为我争取的内存资源,我又开始日以继日地创建TCP连接。
老操也不再说什么,同样日以继日地执行着我的指令。
有一次,老操语重心长地对我说,”差不多了,我劝你就此收手吧,现在 CPU 的占用率已经快到 100% 了。”
图片
我觉得老操这人真的可笑,经过这几次的小挫折,我明白了只要思想不滑坡,方法总比苦难多,老操这人就是太谨慎了,我岂能半途而废,不管他。
我仍然继续创建着 TCP 连接。
直到有一天,老操把我请到一个小饭馆,一块吃了顿饭,吃好后说道。”咱哥俩也算是配合了很久啦,今天我是来跟你道个别的。”
我很不解地问,”怎么了老操,发生什么事了?。”
老操说,”由于你的 TCP 连接,CPU 占用率已经很长时间维持在 100%,我们的使用者,也就是我们的上帝,几乎什么事情都做不了了,连鼠标动一下都要等好久,所以他给我下达了一个重启的指令,我执行这个指令后,你,以及像你一样的所有进程,包括我这个操作系统本身,一切都就消失了。”
我大惊失色,”啊,这么突然么?这条指令什么时候执行?”
老操缓缓起身,”就现在了,刚刚这条指令还没得到 CPU 运行的机会,不过现在到了。”
突然,我眼前一黑,一切都没了。
 
总结
 
图片
资源 一台Linux服务器的资源 一个TCP连接占用的资源 占满了会发生什么
CPU 看你花多少钱买的 看你用它干嘛 电脑卡死
内存 看你花多少钱买的 取决于缓冲区大小 OOM
临时端口号 ip_local_port_range 1 cannot assign requested address
文件描述符 fs.file-max 1 too many open files
进程\线程数 ulimit -n 看IO模型 系统崩溃
后记

其实这个问题,我觉得结论不重要,最重要的是思考过程。

而思考过程其实相当简单,就是,寻找限制条件而已,其实一开始这篇文章,我写了个故事在开头,但后来感觉放在后记更合适。故事是这样的。

闪客:小宇,我问你,你一天最多能吃多少个汉堡?

小宇:额,你这问的太隐私了吧,不过看在你教我技术的份上,我就告诉你,最多能吃 4 个左右吧。

闪客:咳咳真的么?好吧,那你一分钟最多能吃多少个汉堡?

小宇:快的话可能 2 个,不过正常应该最多就能吃完 1 个了。

闪客:好的,那我问你,刚刚这两个问题你为什么能不假思索地回答出来呢?

小宇:哈哈你这是什么话,我自己我当然了解了。

闪客:不,你仔细想想你回答这两个问题的逻辑。

小宇:哦我明白你的意思了,当你问我一天最多能吃多少个汉堡时,我考虑的是我的胃的容量最多能容下多少个汉堡。而当你问我一分钟最多能吃多少个汉堡时,我考虑的时我吃汉堡的速度,按照这个速度在一分钟内能吃多少。

闪客:没错,你总结得很好!一天最多吃多少个汉堡,此时时间非常充裕,所以主要是胃的容量限制了这个汉堡最大值,计算公式应该是:

最多汉堡数 = 胃的容量 ÷ 汉堡的体积

图片

而一分钟最多吃多少个汉堡,此时胃的容量非常充裕,限制汉堡最大值的是时间因素,计算公式是:

最多汉堡数 = 一分钟 ÷ 吃一个汉堡的耗时

图片

所以,取决于最先触达的那个限制条件。

而最大 TCP 连接数这个问题,假如面试被问到了,即使你完全不会,也应该有这样的思路。

而如果你有了这样的思路,你多多少少都能回答出让面试官满意的答案,因为计算机很多时候,更看重思路,而不是细枝末节。

 

你管这破玩意叫 IO 多路复用?

https://mp.weixin.qq.com/s/YdIdoZ_yusVWza1PU7lWaw
低并发编程
战略上藐视技术,战术上重视技术

为了讲多路复用,当然还是要跟风,采用鞭尸的思路,先讲讲传统的网络 IO 的弊端,用拉踩的方式捧起多路复用 IO 的优势。

为了方便理解,以下所有代码都是伪代码,知道其表达的意思即可。

Let’s go

阻塞 IO

服务端为了处理客户端的连接和请求的数据,写了如下代码。

listenfd = socket();   // 打开一个网络通信端口
bind(listenfd);        // 绑定
listen(listenfd);      // 监听
while(1) {
  connfd = accept(listenfd);  // 阻塞建立连接
  int n = read(connfd, buf);  // 阻塞读数据
  doSomeThing(buf);  // 利用读到的数据做些什么
  close(connfd);     // 关闭连接,循环等待下一个连接
}

这段代码会执行得磕磕绊绊,就像这样。

图片

可以看到,服务端的线程阻塞在了两个地方,一个是 accept 函数,一个是 read 函数。

如果再把 read 函数的细节展开,我们会发现其阻塞在了两个阶段。

图片

这就是传统的阻塞 IO。

整体流程如下图。

图片

所以,如果这个连接的客户端一直不发数据,那么服务端线程将会一直阻塞在 read 函数上不返回,也无法接受其他客户端连接。

这肯定是不行的。

非阻塞 IO

 

为了解决上面的问题,其关键在于改造这个 read 函数。

有一种聪明的办法是,每次都创建一个新的进程或线程,去调用 read 函数,并做业务处理。

while(1) {
  connfd = accept(listenfd);  // 阻塞建立连接
  pthread_create(doWork);  // 创建一个新的线程
}
void doWork() {
  int n = read(connfd, buf);  // 阻塞读数据
  doSomeThing(buf);  // 利用读到的数据做些什么
  close(connfd);     // 关闭连接,循环等待下一个连接
}

这样,当给一个客户端建立好连接后,就可以立刻等待新的客户端连接,而不用阻塞在原客户端的 read 请求上。

图片

不过,这不叫非阻塞 IO,只不过用了多线程的手段使得主线程没有卡在 read 函数上不往下走罢了。操作系统为我们提供的 read 函数仍然是阻塞的。

所以真正的非阻塞 IO,不能是通过我们用户层的小把戏,而是要恳请操作系统为我们提供一个非阻塞的 read 函数

这个 read 函数的效果是,如果没有数据到达时(到达网卡并拷贝到了内核缓冲区),立刻返回一个错误值(-1),而不是阻塞地等待。

操作系统提供了这样的功能,只需要在调用 read 前,将文件描述符设置为非阻塞即可。

fcntl(connfd, F_SETFL, O_NONBLOCK);
int n = read(connfd, buffer) != SUCCESS);

这样,就需要用户线程循环调用 read,直到返回值不为 -1,再开始处理业务。

图片

这里我们注意到一个细节。

非阻塞的 read,指的是在数据到达前,即数据还未到达网卡,或者到达网卡但还没有拷贝到内核缓冲区之前,这个阶段是非阻塞的。

当数据已到达内核缓冲区,此时调用 read 函数仍然是阻塞的,需要等待数据从内核缓冲区拷贝到用户缓冲区,才能返回。

整体流程如下图

图片

 

IO 多路复用

 

为每个客户端创建一个线程,服务器端的线程资源很容易被耗光。

图片

当然还有个聪明的办法,我们可以每 accept 一个客户端连接后,将这个文件描述符(connfd)放到一个数组里。

fdlist.add(connfd);

然后弄一个新的线程去不断遍历这个数组,调用每一个元素的非阻塞 read 方法。

while(1) {
  for(fd <-- fdlist) {
    if(read(fd) != -1) {
      doSomeThing();
    }
  }
}

这样,我们就成功用一个线程处理了多个客户端连接。

图片

你是不是觉得这有些多路复用的意思?

但这和我们用多线程去将阻塞 IO 改造成看起来是非阻塞 IO 一样,这种遍历方式也只是我们用户自己想出的小把戏,每次遍历遇到 read 返回 -1 时仍然是一次浪费资源的系统调用。

在 while 循环里做系统调用,就好比你做分布式项目时在 while 里做 rpc 请求一样,是不划算的。

所以,还是得恳请操作系统老大,提供给我们一个有这样效果的函数,我们将一批文件描述符通过一次系统调用传给内核,由内核层去遍历,才能真正解决这个问题。

 

select

 

select 是操作系统提供的系统调用函数,通过它,我们可以把一个文件描述符的数组发给操作系统, 让操作系统去遍历,确定哪个文件描述符可以读写, 然后告诉我们去处理:

图片

select系统调用的函数定义如下。

int select(
    int nfds,
    fd_set *readfds,
    fd_set *writefds,
    fd_set *exceptfds,
    struct timeval *timeout);
// nfds:监控的文件描述符集里最大文件描述符加1
// readfds:监控有读数据到达文件描述符集合,传入传出参数
// writefds:监控写数据到达文件描述符集合,传入传出参数
// exceptfds:监控异常发生达文件描述符集合, 传入传出参数
// timeout:定时阻塞监控时间,3种情况
//  1.NULL,永远等下去
//  2.设置timeval,等待固定时间
//  3.设置timeval里时间均为0,检查描述字后立即返回,轮询

服务端代码,这样来写。

首先一个线程不断接受客户端连接,并把 socket 文件描述符放到一个 list 里。

while(1) {
  connfd = accept(listenfd);
  fcntl(connfd, F_SETFL, O_NONBLOCK);
  fdlist.add(connfd);
}

然后,另一个线程不再自己遍历,而是调用 select,将这批文件描述符 list 交给操作系统去遍历。

while(1) {
  // 把一堆文件描述符 list 传给 select 函数
  // 有已就绪的文件描述符就返回,nready 表示有多少个就绪的
  nready = select(list);
  ...
}

不过,当 select 函数返回后,用户依然需要遍历刚刚提交给操作系统的 list。

只不过,操作系统会将准备就绪的文件描述符做上标识,用户层将不会再有无意义的系统调用开销。

while(1) {
  nready = select(list);
  // 用户层依然要遍历,只不过少了很多无效的系统调用
  for(fd <-- fdlist) {
    if(fd != -1) {
      // 只读已就绪的文件描述符
      read(fd, buf);
      // 总共只有 nready 个已就绪描述符,不用过多遍历
      if(--nready == 0) break;
    }
  }
}

正如刚刚的动图中所描述的,其直观效果如下。(同一个动图消耗了你两次流量,气不气?)

图片

可以看出几个细节:

1. select 调用需要传入 fd 数组,需要拷贝一份到内核,高并发场景下这样的拷贝消耗的资源是惊人的。(可优化为不复制)
2. select 在内核层仍然是通过遍历的方式检查文件描述符的就绪状态,是个同步过程,只不过无系统调用切换上下文的开销。(内核层可优化为异步事件通知)
3. select 仅仅返回可读文件描述符的个数,具体哪个可读还是要用户自己遍历。(可优化为只返回给用户就绪的文件描述符,无需用户做无效的遍历)

整个 select 的流程图如下。

图片

可以看到,这种方式,既做到了一个线程处理多个客户端连接(文件描述符),又减少了系统调用的开销(多个文件描述符只有一次 select 的系统调用 + n 次就绪状态的文件描述符的 read 系统调用)。

poll

 

poll 也是操作系统提供的系统调用函数。

int poll(struct pollfd *fds, nfds_tnfds, int timeout);

struct pollfd {
  intfd; /*文件描述符*/
  shortevents; /*监控的事件*/
  shortrevents; /*监控事件中满足条件返回的事件*/
};

它和 select 的主要区别就是,去掉了 select 只能监听 1024 个文件描述符的限制。

 

epoll

 

epoll 是最终的大 boss,它解决了 select 和 poll 的一些问题。

还记得上面说的 select 的三个细节么?

1. select 调用需要传入 fd 数组,需要拷贝一份到内核,高并发场景下这样的拷贝消耗的资源是惊人的。(可优化为不复制)
2. select 在内核层仍然是通过遍历的方式检查文件描述符的就绪状态,是个同步过程,只不过无系统调用切换上下文的开销。(内核层可优化为异步事件通知)
3. select 仅仅返回可读文件描述符的个数,具体哪个可读还是要用户自己遍历。(可优化为只返回给用户就绪的文件描述符,无需用户做无效的遍历)

所以 epoll 主要就是针对这三点进行了改进。

1. 内核中保存一份文件描述符集合,无需用户每次都重新传入,只需告诉内核修改的部分即可。
2. 内核不再通过轮询的方式找到就绪的文件描述符,而是通过异步 IO 事件唤醒。
3. 内核仅会将有 IO 事件的文件描述符返回给用户,用户也无需遍历整个文件描述符集合。

具体,操作系统提供了这三个函数。

第一步,创建一个 epoll 句柄

int epoll_create(int size);

第二步,向内核添加、修改或删除要监控的文件描述符。

int epoll_ctl(
  int epfd, int op, int fd, struct epoll_event *event);

第三步,类似发起了 select() 调用

int epoll_wait(
  int epfd, struct epoll_event *events, int max events, int timeout);

使用起来,其内部原理就像如下一般丝滑。

图片

如果你想继续深入了解 epoll 的底层原理,推荐阅读飞哥的《图解 | 深入揭秘 epoll 是如何实现 IO 多路复用的!》,从 linux 源码级别,一行一行非常硬核地解读 epoll 的实现原理,且配有大量方便理解的图片,非常适合源码控的小伙伴阅读。

后记

 

大白话总结一下。
一切的开始,都起源于这个 read 函数是操作系统提供的,而且是阻塞的,我们叫它 阻塞 IO
为了破这个局,程序员在用户态通过多线程来防止主线程卡死。
后来操作系统发现这个需求比较大,于是在操作系统层面提供了非阻塞的 read 函数,这样程序员就可以在一个线程内完成多个文件描述符的读取,这就是 非阻塞 IO
但多个文件描述符的读取就需要遍历,当高并发场景越来越多时,用户态遍历的文件描述符也越来越多,相当于在 while 循环里进行了越来越多的系统调用。
后来操作系统又发现这个场景需求量较大,于是又在操作系统层面提供了这样的遍历文件描述符的机制,这就是 IO 多路复用
多路复用有三个函数,最开始是 select,然后又发明了 poll 解决了 select 文件描述符的限制,然后又发明了 epoll 解决 select 的三个不足。

所以,IO 模型的演进,其实就是时代的变化,倒逼着操作系统将更多的功能加到自己的内核而已。
如果你建立了这样的思维,很容易发现网上的一些错误。
比如好多文章说,多路复用之所以效率高,是因为用一个线程就可以监控多个文件描述符。
这显然是知其然而不知其所以然,多路复用产生的效果,完全可以由用户态去遍历文件描述符并调用其非阻塞的 read 函数实现。而多路复用快的原因在于,操作系统提供了这样的系统调用,使得原来的 while 循环里多次系统调用,变成了一次系统调用 + 内核层遍历这些文件描述符。
就好比我们平时写业务代码,把原来 while 循环里调 http 接口进行批量,改成了让对方提供一个批量添加的 http 接口,然后我们一次 rpc 请求就完成了批量添加。
一个道理。
找时间我再专门写一篇,讲讲这块网络上鱼龙混杂的花式错误理解。

Understanding Linux CPU Load – when should you be worried?

copy from:https://scoutapm.com/blog/understanding-load-averages

You might be familiar with Linux load averages already. Load averages are the three numbers shown with the uptime and top commands – they look like this:

load average: 0.09, 0.05, 0.01

Most people have an inkling of what the load averages mean: the three numbers represent averages over progressively longer periods of time (one, five, and fifteen-minute averages), and that lower numbers are better. Higher numbers represent a problem or an overloaded machine. But, what’s the threshold? What constitutes “good” and “bad” load average values? When should you be concerned over a load average value, and when should you scramble to fix it ASAP?

First, a little background on what the load average values mean. We’ll start out with the simplest case: a machine with one single-core processor.

The traffic analogy

A single-core CPU is like a single lane of traffic. Imagine you are a bridge operator … sometimes your bridge is so busy there are cars lined up to cross. You want to let folks know how traffic is moving on your bridge. A decent metric would be how many cars are waiting at a particular time. If no cars are waiting, incoming drivers know they can drive across right away. If cars are backed up, drivers know they’re in for delays.

So, Bridge Operator, what numbering system are you going to use? How about:

  • 0.00 means there’s no traffic on the bridge at all. In fact, between 0.00 and 1.00 means there’s no backup, and an arriving car will just go right on.
  • 1.00 means the bridge is exactly at capacity. All is still good, but if traffic gets a little heavier, things are going to slow down.
  • over 1.00 means there’s backup. How much? Well, 2.00 means that there are two lanes worth of cars total — one lane’s worth on the bridge, and one lane’s worth waiting. 3.00 means there are three lanes worth total — one lane’s worth on the bridge, and two lanes’ worth waiting. Etc.

undefined

This is basically what CPU load is. “Cars” are processes using a slice of CPU time (“crossing the bridge”) or queued up to use the CPU. Unix refers to this as the run-queue length: the sum of the number of processes that are currently running plus the number that are waiting (queued) to run.

Like the bridge operator, you’d like your cars/processes to never be waiting. So, your CPU load should ideally stay below 1.00. Also, like the bridge operator, you are still ok if you get some temporary spikes above 1.00 … but when you’re consistently above 1.00, you need to worry.

So you’re saying the ideal load is 1.00?

Well, not exactly. The problem with a load of 1.00 is that you have no headroom. In practice, many sysadmins will draw a line at 0.70:

  • The “Need to Look into it” Rule of Thumb: 0.70 If your load average is staying above > 0.70, it’s time to investigate before things get worse.
  • The “Fix this now” Rule of Thumb: 1.00. If your load average stays above 1.00, find the problem and fix it now. Otherwise, you’re going to get woken up in the middle of the night, and it’s not going to be fun.
  • The “Arrgh, it’s 3 AM WTF?” Rule of Thumb: 5.0. If your load average is above 5.00, you could be in serious trouble, your box is either hanging or slowing way down, and this will (inexplicably) happen in the worst possible time like in the middle of the night or when you’re presenting at a conference. Don’t let it get there.

What about Multi-processors? My load says 3.00, but things are running fine!

Got a quad-processor system? It’s still healthy with a load of 3.00.

On a multi-processor system, the load is relative to the number of processor cores available. The “100% utilization” mark is 1.00 on a single-core system, 2.00, on a dual-core, 4.00 on a quad-core, etc.

If we go back to the bridge analogy, the “1.00” really means “one lane’s worth of traffic”. On a one-lane bridge, that means it’s filled up. On a two-lane bridge, a load of 1.00 means it’s at 50% capacity — only one lane is full, so there’s another whole lane that can be filled.

Same with CPUs: a load of 1.00 is 100% CPU utilization on a single-core box. On a dual-core box, a load of 2.00 is 100% CPU utilization.

Multicore vs. multiprocessor

While we’re on the topic, let’s talk about multicore vs. multiprocessor. For performance purposes, is a machine with a single dual-core processor basically equivalent to a machine with two processors with one core each? Yes. Roughly. There are lots of subtleties here concerning amount of cache, frequency of process hand-offs between processors, etc. Despite those finer points, for the purposes of sizing up the CPU load value, the total number of cores is what matters, regardless of how many physical processors those cores are spread across.

Which leads us to two new Rules of Thumb:

  • The “number of cores = max load” Rule of Thumb: on a multicore system, your load should not exceed the number of cores available.
  • The “cores is cores” Rule of Thumb: How the cores are spread out over CPUs doesn’t matter. Two quad-cores == four dual-cores == eight single-cores. It’s all eight cores for these purposes.

Bringing It Home

Let’s take a look at the load averages output from uptime:

~ $ uptime
23:05 up 14 days, 6:08, 7 users, load averages: 0.65 0.42 0.36

This is on a dual-core CPU, so we’ve got lots of headroom. I won’t even think about it until load gets and stays above 1.7 or so.

Now, what about those three numbers? 0.65 is the average over the last minute, 0.42 is the average over the last five minutes, and 0.36 is the average over the last 15 minutes. Which brings us to the question:

Which average should I be observing? One, five, or 15 minutes?

For the numbers we’ve talked about (1.00 = fix it now, etc), you should be looking at the five or 15-minute averages. Frankly, if your box spikes above 1.0 on the one-minute average, you’re still fine. It’s when the 15-minute average goes north of 1.0 and stays there that you need to snap to. (obviously, as we’ve learned, adjust these numbers to the number of processor cores your system has).

So # of cores is important to interpreting load averages … how do I know how many cores my system has?

cat /proc/cpuinfo to get info on each processor in your system. Note: not available on OSX, Google for alternatives. To get just a count, run it through grep and word count: grep 'model name' /proc/cpuinfo | wc -l

More servers? Or faster code?

Adding servers can be a band-aid for slow code. Scout APM helps you find and fix your inefficient and costly code. We automatically identify N+1 SQL calls, memory bloat, and other code-related issues so you can spend less time debugging and more time programming.

Ready to optimize your site? Sign up for a free trial.

More Reading

More on Linux Performance

差值哈希(DHash)

某些情况下,我们需要检测图片之间的相似性,进行我们需要的处理:删除同一张图片、标记盗版等。
如何判断是同一张图片呢?最简单的方法是使用加密哈希(例如MD5, SHA-1)判断。但是局限性非常大。例如一个txt文档,其MD5值是根据这个txt的二进制数据计算的,如果是这个txt文档的完全复制版,那他们的MD5值是完全相同的。但是,一旦改变副本的内容,哪怕只是副本的缩进格式,其MD5也会天差地别。因此加密哈希只能用于判断两个完全一致、未经修改的文件,如果是一张经过调色或者缩放的图片,根本无法判断其与另一张图片是否为同一张图片。
那么如何判断一张被PS过的图片是否与另一张图片本质上相同呢?比较简单、易用的解决方案是采用感知哈希算法(Perceptual Hash Algorithm)。

感知哈希算法是一类算法的总称,包括aHash、pHash、dHash。顾名思义,感知哈希不是以严格的方式计算Hash值,而是以更加相对的方式计算哈希值,因为“相似”与否,就是一种相对的判定。

  • aHash:平均值哈希。速度比较快,但是常常不太精确。
  • pHash:感知哈希。精确度比较高,但是速度方面较差一些。
  • dHash:差异值哈希。Amazing!精确度较高,且速度也非常快。因此我就选择了dHash作为我图片判重的算法。

一、 相似图片检测步骤:

  1. 分别计算两张图片的dHash值
  2. 通过dHash值计算两张图片的汉明距离(Hamming Distance),通过汉明距离的大小,判断两张图片的相似程度。

二、dHash计算

需要计算dHash值的图片
Step1. 缩放图片

如果我们要计算上图的dHash值,第一步是把它缩放到足够小。为什么需要缩放呢?因为原图的分辨率一般都非常高。一张 200*200 的图片,就有整整4万个像素点,每一个像素点都保存着一个RGB值,4万个RGB,是相当庞大的信息量,非常多的细节需要处理。因此,我们需要把图片缩放到非常小,隐藏它的细节部分,只见森林,不见树木。建议缩放为9*8,虽然可以缩放为任意大小,但是这个值是相对合理的。而且宽度为9,有利于我们转换为hash值,往下面看,你就明白了。

  1. resize_width = 9
  2. resize_height = 8
  3. # 1. resize to (9,8)
  4. smaller_image = image.resize((resize_width, resize_height))

缩放为9*8分辨率后
Step2. 灰度化

dHash全名为差异值hash,通过计算相邻像素之间的颜色强度差异得出。我们缩放后的图片,细节已经被隐藏,信息量已经变少。但是还不够,因为它是彩色的,由RGB值组成。白色表示为(255,255,255),黑色表示为(0,0,0),值越大颜色越亮,越小则越暗。每种颜色都由3个数值组成,也就是红、绿、蓝的值 。如果直接使用RGB值对比颜色强度差异,相当复杂,因此我们转化为灰度值——只由一个0到255的整数表示灰度。这样的话就将三维的比较简化为了一维比较。

  1. # 2. 灰度化 Grayscale
  2. grayscale_image = smaller_image.convert("L")

灰度化后
Step3. 差异计算

差异值是通过计算每行相邻像素的强度对比得出的。我们的图片为9*8的分辨率,那么就有8行,每行9个像素。差异值是每行分别计算的,也就是第二行的第一个像素不会与第一行的任何像素比较。每一行有9个像素,那么就会产生8个差异值,这也是为何我们选择9作为宽度,因为8bit刚好可以组成一个byte,方便转换为16进制值。
如果前一个像素的颜色强度大于第二个像素,那么差异值就设置为True(也就是1),如果不大于第二个像素,就设置为False(也就是0)。

  1. # 3. 比较相邻像素
  2. pixels = list(grayscale_image.getdata())
  3. difference = []
  4. for row in range(resize_height):
  5. row_start_index = row * resize_width
  6. for col in range(resize_width - 1):
  7. left_pixel_index = row_start_index + col
  8. difference.append(pixels[left_pixel_index] > pixels[left_pixel_index + 1])
Step4. 转换为hash值

我们将差异值数组中每一个值看做一个bit,每8个bit组成为一个16进制值,将16进制值连接起来转换为字符串,就得出了最后的dHash值。

  1. # 转化为16进制(每个差值为一个bit,每8bit转为一个16进制)
  2. decimal_value = 0
  3. hash_string = ""
  4. for index, value in enumerate(difference):
  5. if value: # value为0, 不用计算, 程序优化
  6. decimal_value += value * (2 ** (index % 8))
  7. if index % 8 == 7: # 每8位的结束
  8. hash_string += str(hex(decimal_value)[2:].rjust(2, "0")) # 不足2位以0填充。0xf=>0x0f
  9. decimal_value = 0

三、 计算汉明距离(Hamming Distance)

汉明距离这个概念不止运用于图片对比领域,也被使用于众多领域,具体的介绍可以参见Wikipedia。
汉明距离表示将A修改成为B,需要多少个步骤。比如字符串“abc”与“ab3”,汉明距离为1,因为只需要修改“c”为“3”即可。
dHash中的汉明距离是通过计算差异值的修改位数。我们的差异值是用0、1表示的,可以看做二进制。二进制0110与1111的汉明距离为2。
我们将两张图片的dHash值转换为二进制difference,并取异或。计算异或结果的“1”的位数,也就是不相同的位数,这就是汉明距离。

  1. difference = (int(dhash1, 16)) ^ (int(dhash2, 16))
  2. return bin(difference).count("1")

如果传入的参数不是两张图的dHash值,而是直接比较两张图片,那么不需要生成dHash值,直接用Step3中的difference数组,统计不相同的位数,就是汉明距离。

  1. hamming_distance = 0
  2. for index, img1_pix in enumerate(image1_difference):
  3. img2_pix = image2_difference[index]
  4. if img1_pix != img2_pix:
  5. hamming_distance += 1

一般来说,汉明距离小于5,基本就是同一张图片。大家可以根据自己的实际情况,判断汉明距离临界值为多少。

Github:

https://github.com/hjaurum/DHash

参考文档:

nginx负载均衡一则

 


#user nobody;
worker_processes 2;
events {
# 最大并发数
worker_connections 1024;
}
http{
# 待选服务器列表
upstream list{
#ip_hash;
server 172.17.30.1 fail_timeout=60s;
server 172.17.30.2;
server 172.17.30.3;
}

log_format main '$remote_addr - $remote_user [$time_local] &amp;quot;$request&amp;quot; '
'$status $body_bytes_sent &amp;quot;$http_referer&amp;quot; '
'&amp;quot;$http_user_agent&amp;quot; &amp;quot;$http_x_forwarded_for&amp;quot;'
'$upstream_addr '
'ups_resp_time: $upstream_response_time '
'request_time: $request_time';
#access_log logs/access.log main;
access_log /var/log/nginx/access.log main;

server{
# 监听端口
listen 80;
# 根目录下
location / {
# 选择哪个服务器列表
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header host $host;
proxy_pass http://list;
}

}

server{
# 监听端口
listen 443 ssl;
add_header X-Frame-Options SAMEORIGIN;
ssl_certificate cert/test.pem;
ssl_certificate_key cert/test.key;
ssl_session_timeout 5m;
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
# 根目录下
location / {
# 选择哪个服务器列表
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header host $host;
proxy_pass http://list;
}


}


c++编译参数

代码文件
hello.h


#include <stdio.h>
#include <stdlib.h>

void hello();
void main();

hello.c


#include "hello.h"
void hello()
{
printf("this is in hello...\n");
}

void main()
{

printf("main \n");
}

一 简单编译

gcc hello.c -o hello
直接经过了预处理、编译、汇编和链接

二 分步拆解
1,预处理
gcc -E hello.c -o hello.i

预处理结果就是将stdio.h 文件中的内容插入到hello.c中了

2,编译
gcc -S hello.i -o hello.s
gcc的-S选项,表示在程序编译期间,在生成汇编代码后,停止,-o输出汇编代码文件。

3,汇编
gcc -c hello.s -o hello.o

4,链接
gcc hello.o -o test
gcc连接器是gas提供的,负责将程序的目标文件与所需的所有附加的目标文件连接起来,最终生成可执行文件。附加的目标文件包括静态连接库和动态连接库
三 库文件链接

去掉原始文件main相关内容


#include "hello.h"
int main()
{
hello();
return 0;
}

1,生成库文件
gcc hello.c -shared -fPIC -o libhello.so
-shared选项说明编译成的文件为动态链接库,不使用该选项相当于可执行文件
-fPIC 表示编译为位置独立的代码,不用此选项的话编译后的代码是位置相关的。所以动态载入时是通过代码拷贝的方式来满足不同进程的需要,而不能达到真正代码段共享的目的
2,
gcc hello_b.c -L ./ -l hello -o hello
其中-L ./ 表示链接的文件在当前目录下
-lhello 代表链接的文件名 gcc会自动为其前面添加lib,在其后边添加.so 即libhello.so
3,设置lib库文件地址
export LD_LIBRARY_PATH=/home/work/code/gcc/:$LD_LIBRARY_PATH

m3u8 文件格式详解

简介

M3U8 是 Unicode 版本的 M3U,用 UTF-8 编码。”M3U” 和 “M3U8” 文件都是苹果公司使用的 HTTP Live Streaming(HLS) 协议格式的基础,这种协议格式可以在 iPhone 和 Macbook 等设备播放。

上述文字定义来自于维基百科。可以看到,m3u8 文件其实是 HTTP Live Streaming(缩写为 HLS) 协议的部分内容,而 HLS 是一个由苹果公司提出的基于 HTTP流媒体网络传输协议

HLS 的工作原理是把整个流分成一个个小的基于 HTTP 的文件来下载,每次只下载一些。当媒体流正在播放时,客户端可以选择从许多不同的备用源中以不同的速率下载同样的资源,允许流媒体会话适应不同的数据速率。在开始一个流媒体会话时,客户端会下载一个包含元数据的 extended M3U (m3u8) playlist文件,用于寻找可用的媒体流。
HLS 只请求基本的 HTTP 报文,与实时传输协议(RTP)不同,HLS 可以穿过任何允许 HTTP 数据通过的防火墙或者代理服务器。它也很容易使用内容分发网络来传输媒体流。

简而言之,HLS 是新一代流媒体传输协议,其基本实现原理为将一个大的媒体文件进行分片,将该分片文件资源路径记录于 m3u8 文件(即 playlist)内,其中附带一些额外描述(比如该资源的多带宽信息···)用于提供给客户端。客户端依据该 m3u8 文件即可获取对应的媒体资源,进行播放。

因此,客户端获取 HLS 流文件,主要就是对 m3u8 文件进行解析操作。

那么,下面就简单介绍下 m3u8 文件。

M3U8 文件简介

m3u8 文件实质是一个播放列表(playlist),其可能是一个媒体播放列表(Media Playlist),或者是一个主列表(Master Playlist)。但无论是哪种播放列表,其内部文字使用的都是 utf-8 编码。

当 m3u8 文件作为媒体播放列表(Meida Playlist)时,其内部信息记录的是一系列媒体片段资源,顺序播放该片段资源,即可完整展示多媒体资源。其格式如下所示:

#EXTM3U
#EXT-X-TARGETDURATION:10

#EXTINF:9.009,
http://media.example.com/first.ts
#EXTINF:9.009,
http://media.example.com/second.ts
#EXTINF:3.003,
http://media.example.com/third.ts

对于点播来说,客户端只需按顺序下载上述片段资源,依次进行播放即可。而对于直播来说,客户端需要 定时重新请求 该 m3u8 文件,看下是否有新的片段数据需要进行下载并播放。

当 m3u8 作为主播放列表(Master Playlist)时,其内部提供的是同一份媒体资源的多份流列表资源(Variant Stream)。其格式如下所示:

#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=150000,RESOLUTION=416x234,CODECS="avc1.42e00a,mp4a.40.2"
http://example.com/low/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=240000,RESOLUTION=416x234,CODECS="avc1.42e00a,mp4a.40.2"
http://example.com/lo_mid/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=440000,RESOLUTION=416x234,CODECS="avc1.42e00a,mp4a.40.2"
http://example.com/hi_mid/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=640000,RESOLUTION=640x360,CODECS="avc1.42e00a,mp4a.40.2"
http://example.com/high/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=64000,CODECS="mp4a.40.5"
http://example.com/audio/index.m3u8

该备用流资源指定了多种不同码率,不同格式的媒体播放列表,并且,该备用流资源也可同时提供不同版本的资源内容,比如不同语言的音频文件,不同角度拍摄的视屏文件等等。客户可以根据不同的网络状态选取合适码流的资源,并且最好根据用户喜好选择合适的资源内容。

更多详细内容,可查看:

以上,就是 m3u8 文件的大概内容。下面,我们就对 m3u8 内容格式进行讲解。

m3u8 文件格式简解

m3u8 的文件格式主要包含三方面内容:

  1. 文件播放列表格式定义:播放列表(Playlist,也即 m3u8 文件) 内容需严格满足规范定义所提要求。下面罗列一些主要遵循的条件:
  • m3u8 文件必须以 utf-8 进行编码,不能使用 Byte Order Mark(BOM)字节序, 不能包含 utf-8 控制字符(U+0000 ~ U_001F 和 U+007F ~ u+009F)。
  • m3u8 文件的每一行要么是一个 URI,要么是空行,要么就是以 # 开头的字符串。不能出现空白字符,除了显示声明的元素。
  • m3u8 文件中以 # 开头的字符串要么是注释,要么就是标签。标签以 #EXT 开头,大小写敏感。
  1. 属性列表(Attribute Lists):某些特定的标签的值为属性列表。标签后面的属性列表以 逗号 作为分隔符,分离出多组不带空格的 属性/值 对。
    属性/值 对的语法格式如下:

AttributeName=AttributeValue

其中:

  • 属性AttributeName是由 [A..Z],[0..9] 和 - 组成的不带引号的字符串。因此,属性AttributeName只能使用大写字母,不能使用小写字母,并且AttributeName=中间不能有空格,同理,=AttributeValue之间也不能有空格。
  • AttributeValue的只能取以下类型:
    • 十进制整型(decimal-interger):由 [0..9] 之间组成的十进制不带引号的字符串,范围为 0 ~ 2^{64}(18446744073709551615),字符长度为 1 ~ 20 之间。
    • 十六进制序列:由 [0..9] 和 [A..F] 且前缀为 0x 或 0X 组合成的不带引号的字符串。其序列的最大长度取决于他的属性名AttributeNames
    • 带符号十进制浮点型(signed-decimal-floating-point):由 [0..9],-.组合成的不带引号的字符串。
    • 字符串(quoted-string):由双引号包裹表示的字符串。其中,0xA,0xD 和 双引号"不能出现在该字符串中。该字符串区分大小写。
    • 可枚举字符串(enumerated-string):由AttributeName显示定义的一系列不带引号的字符串。该字符串不能包含双引号",逗号,和空白字符。
    • decimal-resolution:由字符x进行隔离的两个十进制整型数。第一个整型表示水平宽度大小,第二个整型数表示垂直方向高度大小(单位:像素)。
  1. 标签:标签用于指定 m3u8 文件的全局参数或在其后面的切片文件/媒体播放列表的一些信息。

标签的类型可分为五种类型:基础标签(Basic Tags)媒体片段类型标签(Media Segment Tags)媒体播放列表类型标签主播放列表类型标签播放列表类型标签。其具体内容如下所示:

  • 基础标签(Basic Tags):可同时适用于媒体播放列表(Media Playlist)和主播放列表(Master Playlist)。具体标签如下:
    • EXTM3U:表明该文件是一个 m3u8 文件。每个 M3U 文件必须将该标签放置在第一行。
    • EXT-X-VERSION:表示 HLS 的协议版本号,该标签与流媒体的兼容性相关。该标签为全局作用域,使能整个 m3u8 文件;每个 m3u8 文件内最多只能出现一个该标签定义。如果 m3u8 文件不包含该标签,则默认为协议的第一个版本。
  • 媒体片段类型标签(Media Segment Tags):每个切片 URI 前面都有一系列媒体片段标签对其进行描述。有些片段标签只对其后切片资源有效;有些片段标签对其后所有切片都有效,直到后续遇到另一个该标签描述。媒体片段类型标签不能出现在主播放列表(Master Playlist)中。具体标签如下:
    • EXTINF:表示其后 URL 指定的媒体片段时长(单位为秒)。每个 URL 媒体片段之前必须指定该标签。该标签的使用格式为:

      #EXTINF:<duration>,[<title>]
      

      其中:

      • duration:可以为十进制的整型或者浮点型,其值必须小于或等于 EXT-X-TARGETDURATION 指定的值。
        注:建议始终使用浮点型指定时长,这可以让客户端在定位流时,减少四舍五入错误。但是如果兼容版本号 EXT-X-VERSION 小于 3,那么必须使用整型。
    • EXT-X-BYTERANGE:该标签表示接下来的切片资源是其后 URI 指定的媒体片段资源的局部范围(即截取 URI 媒体资源部分内容作为下一个切片)。该标签只对其后一个 URI 起作用。其格式为:

      #EXT-X-BYTERANGE:<n>[@<o>]
      

      其中:

      • n是一个十进制整型,表示截取片段大小(单位:字节)。
      • 可选参数o也是一个十进制整型,指示截取起始位置(以字节表示,在 URI 指定的资源开头移动该字节位置后进行截取)。
        如果o未指定,则截取起始位置从上一个该标签截取完成的下一个字节(即上一个n+o+1)开始截取。
        如果没有指定该标签,则表明的切分范围为整个 URI 资源片段。
        注:使用 EXT-X-BYTERANGE 标签要求兼容版本号 EXT-X-VERSION 大于等于 4。
    • EXT-X-DISCONTINUITY:该标签表明其前一个切片与下一个切片之间存在中断。其格式为:

      #EXT-X-DISCONTINUITY
      

      当以下任一情况变化时,必须使用该标签:

      • 文件格式(file format)
      • 数字(number),类型(type),媒体标识符(identifiers of tracks)
      • 时间戳序列(timestamp sequence)

      当以下任一情况变化时,应当使用该标签:

      • 编码参数(encoding parameters)
      • 编码序列(encoding sequence)

      注:EXT-X-DISCONTINUITY 的一个经典使用场景就是在视屏流中插入广告,由于视屏流与广告视屏流不是同一份资源,因此在这两种流切换时使用 EXT-X-DISCONTINUITY 进行指明,客户端看到该标签后,就会处理这种切换中断问题,让体验更佳。
      更多详细内容,请查看:Incorporating Ads into a Playlist

    • EXT-X-KEY:媒体片段可以进行加密,而该标签可以指定解密方法。
      该标签对所有 媒体片段 和 由标签 EXT-X-MAP 声明的围绕其间的所有 媒体初始化块(Meida Initialization Section) 都起作用,直到遇到下一个 EXT-X-KEY(若 m3u8 文件只有一个 EXT-X-KEY 标签,则其作用于所有媒体片段)。
      多个 EXT-X-KEY 标签如果最终生成的是同样的秘钥,则他们都可作用于同一个媒体片段。
      该标签使用格式为:

      #EXT-X-KEY:<attribute-list>
      

      属性列表可以包含如下几个键:

      • METHOD:该值是一个可枚举的字符串,指定了加密方法。
        该键是必须参数。其值可为NONEAES-128SAMPLE-AES当中的一个。
        其中:
        NONE:表示切片未进行加密(此时其他属性不能出现);
        AES-128:表示表示使用 AES-128 进行加密。
        SAMPLE-AES:意味着媒体片段当中包含样本媒体,比如音频或视频,它们使用 AES-128 进行加密。这种情况下 IV 属性可以出现也可以不出现。
      • URI:指定密钥路径。
        该密钥是一个 16 字节的数据。
        该键是必须参数,除非 METHODNONE
      • IV:该值是一个 128 位的十六进制数值。
        AES-128 要求使用相同的 16字节 IV 值进行加密和解密。使用不同的 IV 值可以增强密码强度。
        如果属性列表出现 IV,则使用该值;如果未出现,则默认使用媒体片段序列号(即 EXT-X-MEDIA-SEQUENCE)作为其 IV 值,使用大端字节序,往左填充 0 直到序列号满足 16 字节(128 位)。
      • KEYFORMAT:由双引号包裹的字符串,标识密钥在密钥文件中的存储方式(密钥文件中的 AES-128 密钥是以二进制方式存储的16个字节的密钥)。
        该属性为可选参数,其默认值为"identity"
        使用该属性要求兼容版本号 EXT-X-VERSION 大于等于 5。
      • KEYFORMATVERSIONS:由一个或多个被/分割的正整型数值构成的带引号的字符串(比如:"1""1/2""1/2/5")。
        如果有一个或多特定的 KEYFORMT 版本被定义了,则可使用该属性指示具体版本进行编译。
        该属性为可选参数,其默认值为"1"
        使用该属性要求兼容版本号 EXT-X-VERSION 大于等于 5。
    • EXT-X-MAP:该标签指明了获取媒体初始化块(Meida Initialization Section)的方法。
      该标签对其后所有媒体片段生效,直至遇到另一个 EXT-X-MAP 标签。
      其格式为:

      #EXT-X-MAP:<attribute-list>
      

      其属性列表取值范围如下:

      • URI:由引号包裹的字符串,指定了包含媒体初始化块的资源的路径。该属性为必选参数。
      • BYTERANGE:由引号包裹的字符串,指定了媒体初始化块在 URI 指定的资源的位置(片段)。
        该属性指定的范围应当只包含媒体初始化块。
        该属性为可选参数,如果未指定,则表示 URI 指定的资源就是全部的媒体初始化块。
    • EXT-X-PROGRAM-DATE-TIME:该标签使用一个绝对日期/时间表明第一个样本片段的取样时间。
      其格式为:

      #EXT-X-PROGRAM-DATE-TIME:<date-time-msec>
      

      其中,date-time-msec是一个 ISO/IEC 8601:2004 规定的日期格式,形如:YYYY-MM-DDThh:mm:ss.SSSZ。

    • EXT-X-DATERANGE:该标签定义了一系列由属性/值对组成的日期范围。
      其格式为:

      #EXT-X-DATERANGE:<attribute-list>
      

      其属性列表取值如下:

      • ID:双引号包裹的唯一指明日期范围的标识。
        该属性为必选参数。
      • CLASS:双引号包裹的由客户定义的一系列属性与与之对应的语意值。
        所有拥有同一 CLASS 属性的日期范围必须遵守对应的语意。
        该属性为可选参数。
      • START-DATE:双引号包裹的日期范围起始值。
        该属性为必选参数。
      • END-DATE:双引号包裹的日期范围结束值。
        该属性值必须大于或等于 START-DATE
        该属性为可选参数。
      • DURATION:日期范围的持续时间是一个十进制浮点型数值类型(单位:秒)。
        该属性值不能为负数。
        当表达立即时间时,将该属性值设为 0 即可。
        该属性为可选参数。
      • PLANNED-DURATION:该属性为日期范围的期望持续时长。
        其值为一个十进制浮点数值类型(单位:秒)。
        该属性值不能为负数。
        在预先无法得知真实持续时长的情况下,可使用该属性作为日期范围的期望预估时长。
        该属性为可选参数。
    • X-<client-attribute>X-前缀是预留给客户端自定义属性的命名空间。
      客户端自定义属性名时,应当使用反向 DNS(reverse-DNS)语法来避免冲突。
      自定义属性值必须是使用双引号包裹的字符串,或者是十六进制序列,或者是十进制浮点数,比如:X-COM-EXAMPLE-AD-ID="XYZ123"
      该属性为可选参数。
    • SCTE35-CMD, SCTE35-OUT, SCTE35-IN:用于携带 SCET-35 数据。
      该属性为可选参数。
    • END-ON-NEXT:该属性值为一个可枚举字符串,其值必须为YES
      该属性表明达到该范围末尾,也即等于后续范围的起始位置 START-DATE。后续范围是指具有相同 CLASS 的,在该标签 START-DATE 之后的具有最早 START-DATE 值的日期范围。
      该属性时可选参数。
  • 媒体播放列表类型标签:媒体播放列表标签为 m3u8 文件的全局参数信息。
    这些标签只能在 m3u8 文件中至多出现一次。
    媒体播放列表(Media Playlist)标签不能出现在主播放列表(Master Playlist)中。
    媒体播放列表具体标签如下所示:

    • EXT-X-TARGETDURATION:表示每个视频分段最大的时长(单位秒)。
      该标签为必选标签。
      其格式为:

      #EXT-X-TARGETDURATION:<s>
      

      其中:参数s表示目标时长(单位:秒)。

    • EXT-X-MEDIA-SEQUENCE:表示播放列表第一个 URL 片段文件的序列号。
      每个媒体片段 URL 都拥有一个唯一的整型序列号。
      每个媒体片段序列号按出现顺序依次加 1。
      如果该标签未指定,则默认序列号从 0 开始。
      媒体片段序列号与片段文件名无关。
      其格式为:

      #EXT-X-MEDIA-SEQUENCE:<number>
      

      其中:参数number即为切片序列号。

    • EXT-X-DISCONTINUITY-SEQUENCE:该标签使能同步相同流的不同 Rendition 和 具备 EXT-X-DISCONTINUITY 标签的不同备份流。
      其格式为:

      #EXT-X-DISCONTINUITY-SEQUENCE:<number>
      

      其中:参数number为一个十进制整型数值。
      如果播放列表未设置 EXT-X-DISCONTINUITY-SEQUENCE 标签,那么对于第一个切片的中断序列号应当为 0。

    • EXT-X-ENDLIST:表明 m3u8 文件的结束。
      该标签可出现在 m3u8 文件任意位置,一般是结尾。
      其格式为:

      #EXT-X-ENDLIST
      
    • EXT-X-PLAYLIST-TYPE:表明流媒体类型。全局生效。
      该标签为可选标签。
      其格式为:

      #EXT-X-PLAYLIST-TYPE:<type-enum>
      

      其中:type-enum可选值如下:

      • VOD:即 Video on Demand,表示该视屏流为点播源,因此服务器不能更改该 m3u8 文件;
      • EVENT:表示该视频流为直播源,因此服务器不能更改或删除该文件任意部分内容(但是可以在文件末尾添加新内容)。
        注:VOD 文件通常带有 EXT-X-ENDLIST 标签,因为其为点播源,不会改变;而 EVEVT 文件初始化时一般不会有 EXT-X-ENDLIST 标签,暗示有新的文件会添加到播放列表末尾,因此也需要客户端定时获取该 m3u8 文件,以获取新的媒体片段资源,直到访问到 EXT-X-ENDLIST 标签才停止)。
    • EXT-X-I-FRAMES-ONLY:该标签表示每个媒体片段都是一个 I-frameI-frames 帧视屏编码不依赖于其他帧数,因此可以通过 I-frame 进行快速播放,急速翻转等操作。
      该标签全局生效。
      其格式为:

      #EXT-X-I-FRAMES-ONLY
      

      如果播放列表设置了 EXT-X-I-FRAMES-ONLY,那么切片的时长(EXTINF 标签的值)即为当前切片 I-frame 帧开始到下一个 I-frame 帧出现的时长。
      媒体资源如果包含 I-frame 切片,那么必须提供媒体初始化块或者通过 EXT-X-MAP 标签提供媒体初始化块的获取途径,这样客户端就能通过这些 I-frame 切片以任意顺序进行加载和解码。
      如果 I-frame 切片设置了 EXT-BYTERANGE,那么就绝对不能提供媒体初始化块。
      使用 EXT-X-I-FRAMES-ONLY 要求的兼容版本号 EXT-X-VERSION 大于等于 4。

  • 主播放列表类型标签:主播放列表(Master Playlist)定义了备份流,多语言翻译流和其他全局参数。
    主播放列表标签绝不能出现在媒体播放列表(Media Playlist)中。
    其具体标签如下:

    • EXT-X-MEDIA:用于指定相同内容的可替换的多语言翻译播放媒体列表资源。
      比如,通过三个 EXT-X-MEIDA 标签,可以提供包含英文,法语和西班牙语版本的相同内容的音频资源,或者通过两个 EXT-X-MEDIA 提供两个不同拍摄角度的视屏资源。
      其格式为:

      #EXT-X-MEDIA:<attribute-list>
      

      其中,属性列表取值范围如下:

      • TYPE:该属性值为一个可枚举字符串。
        其值有如下四种:AUDIOVIDEOSUBTITLESCLOSED-CAPTIONS
        通常使用的都是CLOSED-CAPTIONS
        该属性为必选参数。
      • URI:双引号包裹的媒体资源播放列表路径。
        如果 TYPE 属性值为 CLOSED-CAPTIONS,那么则不能提供 URI
        该属性为可选参数。
      • GROUP-ID:双引号包裹的字符串,表示多语言翻译流所属组。
        该属性为必选参数。
      • LANGUAGE:双引号包裹的字符串,用于指定流主要使用的语言。
        该属性为可选参数。
      • ASSOC-LANGUAGE:双引号包裹的字符串,其内包含一个语言标签,用于提供多语言流的其中一种语言版本。
        该参数为可选参数。
      • NAME:双引号包裹的字符串,用于为翻译流提供可读的描述信息。
        如果设置了 LANGUAGE 属性,那么也应当设置 NAME 属性。
        该属性为必选参数。
      • DEFAULT:该属性值为一个可枚举字符串。
        可选值为YESNO
        该属性未指定时默认值为NO
        如果该属性设为YES,那么客户端在缺乏其他可选信息时应当播放该翻译流。
        该属性为可选参数。
      • AUTOSELECT:该属性值为一个可枚举字符串。
        其有效值为YESNO
        未指定时,默认设为NO
        如果该属性设置YES,那么客户端在用户没有显示进行设置时,可以选择播放该翻译流,因为其能配置当前播放环境,比如系统语言选择。
        如果设置了该属性,那么当 DEFAULT 设置YES时,该属性也必须设置为YES
        该属性为可选参数。
      • FORCED:该属性值为一个可枚举字符串。
        其有效值为YESNO
        未指定时,默认设为NO
        只有在设置了 TYPESUBTITLES 时,才可以设置该属性。
        当该属性设为YES时,则暗示该翻译流包含重要内容。当设置了该属性,客户端应当选择播放匹配当前播放环境最佳的翻译流。
        当该属性设为NO时,则表示该翻译流内容意图用于回复用户显示进行请求。
        该属性为可选参数。
      • INSTREAM-ID:由双引号包裹的字符串,用于指示切片的语言(Rendition)版本。
        TYPE 设为 CLOSED-CAPTIONS 时,必须设置该属性。
        其可选值为:"CC1", "CC2", "CC3", "CC4""SERVICEn"n的值为 1~63)。
        对于其他 TYPE 值,该属性绝不能进行设置。
      • CHARACTERISTICS:由双引号包裹的由一个或多个由逗号分隔的 UTI 构成的字符串。
        每个 UTI 表示一种翻译流的特征。
        该属性可包含私有 UTI。
        该属性为可选参数。
      • CHANNELS:由双引号包裹的有序,由反斜杠/分隔的参数列表组成的字符串。
        所有音频 EXT-X-MEDIA 标签应当都设置 CHANNELS 属性。
        如果主播放列表包含两个相同编码但是具有不同数目 channed 的翻译流,则必须设置 CHANNELS 属性;否则,CHANNELS 属性为可选参数。
    • EXT-X-STREAM-INF:该属性指定了一个备份源。该属性值提供了该备份源的相关信息。
      其格式为:

      #EXT-X-STREAM-INF:<attribute-list>
      <URI>
      

      其中:

      • URI 指定的媒体播放列表携带了该标签指定的翻译备份源。
        URI 为必选参数。
      • EXT-X-STREAM-INF 标签的参数属性列表有如下选项:
        • BANDWIDTH:该属性为每秒传输的比特数,也即带宽。代表该备份流的巅峰速率。
          该属性为必选参数。
        • AVERAGE-BANDWIDTH:该属性为备份流的平均切片传输速率。
          该属性为可选参数。
        • CODECS:双引号包裹的包含由逗号分隔的格式列表组成的字符串。
          每个 EXT-X-STREAM-INF 标签都应当携带 CODECS 属性。
        • RESOLUTION:该属性描述备份流视屏源的最佳像素方案。
          该属性为可选参数,但对于包含视屏源的备份流建议增加该属性设置。
        • FRAME-RATE:该属性用一个十进制浮点型数值作为描述备份流所有视屏最大帧率。
          对于备份流中任意视屏源帧数超过每秒 30 帧的,应当增加该属性设置。
          该属性为可选参数,但对于包含视屏源的备份流建议增加该属性设置。
        • HDCP-LEVEL:该属性值为一个可枚举字符串。
          其有效值为TYPE-0NONE
          值为TYPE-0表示该备份流可能会播放失败,除非输出被高带宽数字内容保护(HDCP)。
          值为NONE表示流内容无需输出拷贝保护。
          使用不同程度的 HDCP 加密备份流应当使用不同的媒体加密密钥。
          该属性为可选参数。在缺乏 HDCP 可能存在播放失败的情况下,应当提供该属性。
        • AUDIO:属性值由双引号包裹,其值必须与定义在主播放列表某处的设置了 TYPE 属性值为 AUDIOEXT-X-MEDIA 标签的 GROUP-ID 属性值相匹配。
          该属性为可选参数。
        • VIDEO:属性值由双引号包裹,其值必须与定义在主播放列表某处的设置了 TYPE 属性值为 VIDEOEXT-X-MEDIA 标签的 GROUP-ID 属性值相匹配。
          该属性为可选参数。
        • SUBTITLES:属性值由双引号包裹,其值必须与定义在主播放列表某处的设置了 TYPE 属性值为 SUBTITLESEXT-X-MEDIA 标签的 GROUP-ID 属性值相匹配。
          该属性为可选参数。
        • CLOSED-CAPTIONS:该属性值可以是一个双引号包裹的字符串或NONE
          如果其值为一个字符串,则必须与定义在主播放列表某处的设置了 TYPE 属性值为 CLOSED-CAPTIONSEXT-X-MEDIA 标签的 GROUP-ID 属性值相匹配。
          如果其值为NONE,则所有的 ext-x-stream-inf 标签必须同样将该属性设置NONE,表示主播放列表备份流均没有关闭的标题。对于某个备份流具备关闭标题,另一个备份流不具备关闭标题可能会触发播放中断。
          该属性为可选参数。
    • EXT-X-I-FRAME-STREAM-INF:该标签表明媒体播放列表文件包含多种媒体资源的 I-frame 帧。
      其格式为:

      #EXT-X-I-FRAME-STREAM-INF:<attribute-list>
      

      该标签的属性列表包含了 EXT-X-I-FRAME-STREAM-INF 标签同样的属性列表选项,除了 FRAME-RATEAUDIOSUBTITLESCLOSED-CAPTIONS。除此之外,其他的属性还有:

      • URI:该属性值由双引号包裹的字符串,指示了 I-frame 媒体播放列表文件的路径,该媒体播放列表文件必须包含 EXT-X-I-FRAMES-ONLY 标签。
    • EXT-X-SESSION-DATA:该标签允许主播放列表携带任意 session 数据。
      该标签为可选参数。
      其格式为:

      #EXT-X-SESSION-DATA:<attribute-list>
      

      其中,其参数属性列表值如下可选项:

      • DATA-ID:由双引号包裹的字符串,代表一个特定的数据值。
        该属性应当使用反向 DNS 进行命名,如"com.example.movie.title"。然而,由于没有中央注册机构,所以可能出现冲突情况。
        该属性为必选参数。
      • VALUE:该属性值为一个双引号包裹的字符串,其包含 DATA-ID 指定的值。
        如果设置了 LANGUAGE,则 VALUE 应当包含一个用该语言书写的可读字符串。
      • URI:由双引号包裹的 URI 字符串。由该 URI 指示的资源必选使用 JSON 格式,否则,客户端可能会解析失败。
      • LANGUAGE:由双引号包裹的,包含一个语言标签的字符串。指示了 VALUE 所使用的语言。
  • EXT-X-SESSION-KEY:该标签允许主播放列表(Master Playlist)指定媒体播放列表(Meida Playlist)的加密密钥。这使得客户端可以预先加载这些密钥,而无需从媒体播放列表中获取。
    该标签为可选参数。
    其格式为:

    #EXT-X-SESSION-KEY:<attribute-list>
    

    其属性列表与 EXT-X-KEY 相同,除了 METHOD 属性的值必须不为NONE

  • 播放列表类型标签:以下标签可同时设置于主播放列表(Master Playlist)和媒体播放列表(Media Playlist)中。
    但是对于在主播放列表中设置了的标签,不应当再次设置在主播放列表指向的媒体播放列表中。
    同时出现在两者播放列表的相同标签必须具备相同的值。这些标签在播放列表中不能出现多次(只能使用一次)。具体标签如下所示:

    • EXT-X-INDEPENDENT-SEGMENTS:该标签表明对于一个媒体片段中的所有媒体样本均可独立进行解码,而无须依赖其他媒体片段信息。
      该标签对列表内所有媒体片段均有效。
      其格式为:

      #EXT-X-INDEPENDENT-SEGMENTS
      

      如果该标签出现在主播放列表中,则其对所有媒体播放列表的所有媒体片段都生效。

    • EXT-X-START:该标签表示播放列表播放起始位置。
      默认情况下,客户端开启一个播放会话时,应当使用该标签指定的位置进行播放。
      该标签为可选标签。
      其格式为:

      #EXT-X-START:<attribute-list>
      

      其参数属性列表的取值范围如下:

      • TIME-OFFSET:该属性值为一个带符号十进制浮点数(单位:秒)。
        一个正数表示以播放列表起始位置开始的时间偏移量。
        一个负数表示播放列表上一个媒体片段最后位置往前的时间偏移量。
        该属性的绝对值应当不超过播放列表的时长。如果超过,则表示到达文件结尾(数值为正数),或者达到文件起始(数值为负数)。
        如果播放列表不包含 EXT-X-ENDLIST 标签,那么 TIME-OFFSET 属性值不应当在播放文件末尾三个切片时长之内。
      • PRECISE:该值为一个可枚举字符串。
        有效的取值为YESNO
        如果值为YES,客户端应当播放包含 TIME-OFFSET 的媒体片段,但不要渲染该块内优先于 TIME-OFFSET 的样本块。
        如果值为NO,客户端应当尝试渲染在媒体片段内的所有样本块。
        该属性为可选参数,未指定则认为NO

到此,m3u8 相关的标签我们已经完全介绍完毕。

下面我们再简单介绍下资源文件的获取具体操作。

上文提到,m3u8 文件要么是媒体播放列表(Meida Playlist),要么是主播放列表(Master Playlist)。但无论是哪种列表,其有效内容均由两部分结构组成:

  • #EXT 开头的为标签信息,作为对媒体资源的进一步描述;
  • 剩余的为资源信息,要么是片段资源(Media Playlist)路径,要么是 m3u8 资源(Master Playlist)路径;

我们先简单介绍下 m3u8 文件媒体片段的表示方法:

  • m3u8 文件中,媒体片段可以采用全路径表示。如下所示:

#EXTINF:10.0,
http://example.com/movie1/fileSequenceA.ts

这样,获取资源片段的路径就是 m3u8 文件内指定的路径,即:http://example.com/movie1/fileSequenceA.ts

  • m3u8 文件中,媒体片段还可以使用相对路径表示。如下所示:

#EXTINF:10.0,
fileSequenceA.ts

这表示片段文件的路径是相对于 m3u8 文件路径的,即假设当前 m3u8 的路径为:https://127.0.0.1/hls/m3u8,那么,片段文件 fileSequenceA.ts 的路径即为:https://127.0.0.1/hls/fileSequenceA.ts

尽管可以在 m3u8 文件中使用绝对路径指定媒体片段资源路径,但是更好的选择是使用相对路径。相对路径相较于绝对路径更轻便,同时是相对于 m3u8 文件的 URL。相比之下,绝对路径增加了 m3u8 文件内容(更多字符),增大了文件内容,同时也增大了网络传输量。

其余一些注意事项

  • 有两种请求 m3u8 播放列表的方法:一是通过 m3u8 的 URI 进行请求,则该文件必须以 .m3u8 或 .m3u 结尾;
    二是通过 HTTP 进行请求,则请求头Content-Type必须设置为 application/vnd.apple.mpegurl或者audio/mpegurl
  • 空行和注释行在解析时都忽略。
  • 媒体播放列表(Media Playlist)的流资源总时长就是各切片资源的时长之和。
  • 每个切片的码率(bit rate)就是切片的大小除以它对应的时长(EXTINF 指定的时长)。
  • 一个标签的属性列表的同一个属性AttributeName只能出现一次。
  • EXT-X-TARGETDURATION 指定的时长绝对不能进行更改。通常该值指定的时长为 10 秒。
  • 对于指定了 EXT-X-I-FRAMES-ONLY 且 第一个媒体片段(或者第一个尾随 EXT-X-DISCONTINUITY 的片段)其资源没有立即携带媒体初始化块的切片,应当增加使用标签 EXT-X-MAP 指定媒体初始化块获取途径。
  • 使用 EXT-X-MAP 标签内含标签 EXT-X-I-FRAMES-ONLY 要求的兼容版本号 EXT-X-VERSION 要大于等于 5;只使用 EXT-X-MAP 要求的兼容版本号要大于等于 6。
  • 由标签 EXT-X-MAP 声明的媒体初始化块可使用 AES-128 方法进行加密,此时,作用于 EXT-X-MAP 标签的 EXT-X-KEY 标签必须设置 IV 属性。
  • 带有属性 END-ON-NEXT=YES 的标签 EXT-X-DATERANGE 必须携带 CLASS 属性,但不能携带 DURATIONEND-DATE 属性。其余带有相同 CLASS 的标签 EXT-X-DATERANGE 不能指定重叠的日期范围。
  • 日期范围如果未指明 DURATIONEND_DATE,END-ON-NEXT=YES 属性时,则其时长(duration)未知,即使其设置了 PLANNED-DURATION 属性。
  • 如果播放列表设置了 EXT-X-DATERANGE 标签,则必须同时设置 EXT-X-PROGRAM-DATE-TIME 标签。
  • 如果播放列表设置了拥有相同 ID 属性值的两个 EXT-X-DATERANGE 标签,则对于相同的属性名,在这两个 EXT-X-DATERANGE 中对应的值必须一致。
  • 如果 EXT-X-DATERANGE 同时设置了 DURATIONEND-DATE 属性,则 END-DATE 属性值必须等于 START-DATE 属性值加上 DURATION 属性值。
  • EXT-X-MEDIA-SEQUENCE 标签必须出现在播放列表第一个切片之前。
  • EXT-X-DISCONTINUITY-DEQUENCE 标签必须出现在播放列表第一个切片之前。
  • EXT-X-DISCONTINUITY-DEQUENCE 标签必须出现在任意 EXT-X-DISCONTINUITY 标签之前。
  • m3u8 文件如果没有设置 EXT-X-PLAYLIST-TYPE 标签,那么播放列表可以随时进行更改。比如,可以更新或删除播放列表中的媒体片段。
  • 每个 EXT-X-I-FRAME-STREAM-INF 标签必须包含一个 BANDWIDTHURI 属性。
  • 每个 EXT-X-SESSION-DATA 标签都必须包含一个 VALUEURI 属性,但不能同时包含两者。
  • 一个播放列表可以包含多个携带相同 DATA-ID 属性的 EXT-X-SESSION-DATA 标签。但是不能包含多个携带相同 DATA-ID 和相同 LANGUAGE 属性的 EXT-X-SESSION-DATA 标签。
  • 如果设置了 EXT-X-SESSION-KEY,那么其 METHODKEYFORMATKEYFORMATVERSIONS 属性值必须与任意相同 URIEXT-X-KEY 标签值相同。
  • 如果多份备用流或者多语言流使用相同的加密密钥和格式,则应当设置 EXT-X-SESSION-KEY 标签。
  • 主播放列表必须不能设置多个具有相同 METHODURIIVKEYFORMATKEYFORMATVERSIONS 属性值得 EXT-X-SESSION-KEY 标签。

附录

作者:Whyn
链接:https://www.jianshu.com/p/e97f6555a070
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。