拓扑结构如下

R2(模拟PC1) 发送ping

应用层

应用程序要求使用 ICMP 协议发送一个给 192.168.1.2 类型为 8 的回显请求

网络层

通过向 192.168.1.2 发送一个 ICMPv4 数据报，网络层尝试向远程主机发送一个请求，源 IP 为 192.168.3.2，目标 IP 为 192.168.1.2。其中 ICMP 数据中的类型字段为 8 代表这是一个 ICMPv4 的回显请求。IP 首部的协议为 1 即 ICMP。

路由选择

Pre: 优先级，优先级越高取值越小

1
2
3
4
5
6
7
8
9
10
11
12
13

<R2>dis ip rou
Route Flags: R - relay, D - download to fib
------------------------------------------------------------------------------
Routing Tables: Public
         Destinations : 5        Routes : 5        

Destination/Mask    Proto   Pre  Cost      Flags NextHop         Interface

        0.0.0.0/0   Static  60   0          RD   192.168.3.1     GigabitEthernet0/0/0
      127.0.0.0/8   Direct  0    0           D   127.0.0.1       InLoopBack0
      127.0.0.1/32  Direct  0    0           D   127.0.0.1       InLoopBack0
    192.168.3.0/24  Direct  0    0           D   192.168.3.2     GigabitEthernet0/0/0
    192.168.3.2/32  Direct  0    0           D   127.0.0.1       GigabitEthernet0/0/0

当 TCP/IP 需要向某个 IP 地址发起通信时，它会对路由表进行评估，以确定如何发送数据包。

TCP/IP 使用需要通信的目的 IP 地址和路由表中每一个路由项的掩码进行按位与运算，如果与运算后的结果，匹配对应路由项的网络地址，则记录下次路由项。当计算完路由表中所有的路由项后。

• 会使用最长匹配路由（掩码中具有最多 1 的路由项）来和此目的 IP 地址进行通信
• 如果存在多个最长匹配路由，那么选择具有最高优先级（值最小）的路由表
• 如果存在多个具有最高优先级的最长匹配路由，那么选择最开始找到的最长匹配路由（如果是其它设备的话，一般会看接入方式，有线>无线>移动信号4G）

在这里它就选择了 0.0.0.0/0 的默认路由，决定了会把该数据包交给 192.168.3.1 帮忙传下去。

ARP

1
2
3
4
5
6

<R2>dis arp
IP ADDRESS      MAC ADDRESS     EXPIRE(M) TYPE        INTERFACE   VPN-INSTANCE VLAN/CEVLAN PVC                      
------------------------------------------------------------------------------
192.168.3.2     5489-98da-3e52            I -         GE0/0/0
------------------------------------------------------------------------------
Total:1         Dynamic:0       Static:0     Interface:1

通过上面的路由选择过程后，确认了该数据包的下一跳为 192.168.3.1 但是在交给链路层包装以太帧之前，会先使用 ARP 用于确定目标 IP 对应的 MAC 地址。

查询 ARP 表后，发现 ARP 表中没有与之相对应的项目，所以就需要发起 ARP 请求。寻找 192.168.3.1 的 MAC 地址。

发送 ARP 请求

ARP 向 192.168.3.0/24 广播 ARP 请求，其中源 MAC 地址和源 IP 地址都是自己对应接口的，目标 IP 就分别是 192.168.3.2，同时目标 MAC 为全 0。

链路层封装该 ARP 数据包时，使用源地址为端口的 MAC 地址，目标地址使用全 1，并将其中的类型字段设置为 0x0806 也就是 ARP 对应的值。

收到 ARP 请求

R1 收到该 ARP 请求后，发现该请求的目标 IP 是自己。它首先会更新自己的 ARP 表，将该请求的源 IP 和源 MAC 地址写入 ARP 表中。这样可以减少一次 ARP 请求，提升效率。

1
2
3
4
5
6
7
8
9
10

<R1>dis arp
IP ADDRESS      MAC ADDRESS     EXPIRE(M) TYPE        INTERFACE   VPN-INSTANCE VLAN/CEVLAN PVC                      
------------------------------------------------------------------------------
192.168.0.1     5489-989b-51f2            I -         Eth0/0/0
192.168.1.1     5489-989b-51f3            I -         Eth0/0/1
192.168.1.2     5489-982b-3b01  20        D-0         Eth0/0/1
192.168.3.1     5489-989b-51f4            I -         GE0/0/0
192.168.3.2     5489-98da-3e52  20        D-0         GE0/0/0  // 新写入的条目
------------------------------------------------------------------------------
Total:5         Dynamic:2       Static:0     Interface:3    

回复 ARP 请求

R1 收到该 ARP 请求后，发现该请求的目标 IP 是自己，然后就会调换源地址和目标地址，并且将自己的 MAC 地址写入源地址的字段中，发送该 ARP 回复。

链路层封装该 ARP 数据包时，使用源地址为自己的 MAC 地址，目标地址为发送该请求的 MAC 地址。

收到 ARP 回复

1
2
3
4
5
6
7

<R2>dis arp
IP ADDRESS      MAC ADDRESS     EXPIRE(M) TYPE        INTERFACE   VPN-INSTANCE VLAN/CEVLAN PVC                      
------------------------------------------------------------------------------
192.168.3.2     5489-98da-3e52            I -         GE0/0/0
192.168.3.1     5489-989b-51f4  20        D-0         GE0/0/0
------------------------------------------------------------------------------
Total:2         Dynamic:1       Static:0     Interface:1    

R2 将回复的 MAC 地址写入自己的 ARP 缓存中。

然后 R2 就继续发送引起这次 ARP 请求/应答交换过程的数据报。把数据转发出去的时候，还会将 TTL - 1。

链路层

收到网络层的 ICMP 数据包，将其包装为以太网帧，其中源地址为 R2 的 MAC 地址，目标地址为刚刚通过 ARP 请求得到的 MAC 地址。

R1 转发数据包

路由器收到了由 192.168.3.2 发来 ICMP 数据帧，对其进行解析。

网络层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[Huawei]dis ip rou
Route Flags: R - relay, D - download to fib
------------------------------------------------------------------------------
Routing Tables: Public
         Destinations : 8        Routes : 8        

Destination/Mask    Proto   Pre  Cost      Flags NextHop         Interface

      127.0.0.0/8   Direct  0    0           D   127.0.0.1       InLoopBack0
      127.0.0.1/32  Direct  0    0           D   127.0.0.1       InLoopBack0
    192.168.0.0/24  Direct  0    0           D   192.168.0.1     Ethernet0/0/0
    192.168.0.1/32  Direct  0    0           D   127.0.0.1       Ethernet0/0/0
    192.168.1.0/24  Direct  0    0           D   192.168.1.1     Ethernet0/0/1
    192.168.1.1/32  Direct  0    0           D   127.0.0.1       Ethernet0/0/1
    192.168.3.0/24  Direct  0    0           D   192.168.3.1     GigabitEthernet0/0/0
    192.168.3.1/32  Direct  0    0           D   127.0.0.1       GigabitEthernet0/0/0

R1 查询自己的路由表，发现目的 IP 192.168.1.2 有匹配的项目，所以该数据包会向 Ethernet0/0/1 发送。

ARP

路由器查询自己的 ARP 表，源 IP 的 MAC 地址已存在与 ARP 表中，因为之前回复它的 ARP 请求的时候，也在自己的 ARP 表中存了一份。

目的 IP 192.168.3.2 的 MAC 不在 ARP 表中，所以和上一次一样也需要经过 ARP 请求/回复获取其 MAC 写入 ARP 表，再继续执行后面操作。

链路层

收到网络层的 ICMP 数据包，将其包装为以太网帧，其中源地址为 R1 的 MAC 地址，目标地址为刚刚通过 ARP 请求得到的 MAC 地址。

PC2 回复ping

收到来自 192.168.3.2 发送的 ICMPv4 请求，而且目标 IP 是自己，所以回复该 ICMP 请求。

网络层

将接收到的数据返回给发送者，调换源 IP 和目的 IP，IGMP 数据中的类型为 0 代表这是一个回复。

发送回复的时候，还是和之前一样，要先查自己的路由表。然后因为路由表中的默认路由匹配了，所以就会将该数据包交给默认网关处理。

ARP

再次通过 ARP 表，找到默认网关 192.168.1.1 的 MAC 地址。

链路层

封装以太网帧的时候，使用目的地址为默认网关的 MAC 地址。

R1 转发数据包

• 查询路由表，发现目的 IP 在路由表中
• 查询 ARP 表，找到目的 IP 的 MAC 地址
• 链路层封装数据帧，发送给 R2

R2 收到应答

收到回复后，将当前时间与应答中的时间相减，也就获得了到达被 ping 主机的 RTT 估计值。

对于 ICMPv4 来说，类型为 0/8 的应答与请求，时间戳为可选的字段。而类型为 14/13 的应答和请求就需要带时间戳，但是现在已经作废不用。

后续

当 PC1 继续发送 ICMP 包的话，他会将序列号 +1，然后继续发送。此时因为 ARP 缓存都已存在，所以不会需要 ARP 请求/回复，链路层会直接调用 ARP 缓存中的 MAC 地址进行发送。

参考

• 华为文档中心 路由协议基础
• TCP/IP详解 卷1：协议（原书第2版）
• CSDN@–Allen– 96-ICMP 协议（时间戳请求与应答）

写在最前面

本系列文章都会遵守 中文文案排版指北，愿各位看官和我都能够跟自己爱的人结婚😀。

「有研究显示，打字的时候不喜欢在中文和英文之间加空格的人，感情路都走得很辛苦，有七成的比例会在 34 岁的时候跟自己不爱的人结婚，而其余三成的人最后只能把遗产留给自己的猫。毕竟爱情跟书写都需要适时地留白。

与大家共勉之。」——vinta/paranoid-auto-spacing

绪论

基本术语

假设收集了一批关于西瓜的数据

数据集：上面这一组数据的集合。

样本：每一条（行）记录是关于一个时间或对象（这里是西瓜）的描述。

属性/特征：反映时间或对象在某方面的表现或性质，例如「色泽」、「根蒂」、「敲声」。

属性值：属性上的取值，例如「青绿」、「乌黑」。

属性空间/样本空间：属性张成的空间，比如把“色泽” “根蒂” “敲声”作为三个坐标轴，则他们张成一个用于描述西瓜的三维空间。这个空间就是属性空间。

特征向量：把每个属性作为一个坐标轴，则它们能够组成一个多维空间，那么每一个实例都能够在空间中找到自己的坐标位置。因为每个点都对应一个坐标向量，因此一个实例也称特征向量。

维数：因为每个属性都作为一个坐标轴，而又因为有多少个坐标轴我们就将这个空间叫做几维空间，所以维数也就是样本有多少个属性。

学习/训练：从数据中学的模型的过程，学习的过程是通过执行某个学习算法来完成的。

训练数据：训练过程中使用的数据。

训练样本：训练过程中每个样本。

训练集：训练样本组成的集合。

假设：学得模型对应关于数据的某种潜在的规律。

标记：样本的好或坏，一般都是布尔值。

样例：拥有标记值的样本。

标记空间/输出空间：所有标记的集合。

分类任务：预测的结果是离散值的任务。

回归任务：预测的是连续值，比如西瓜的成熟度 0.95、0.37。

二分类任务：只要涉及的类别只有两个，通常一个为正类，另一个为反类。

多分类任务：涉及多个类别，也即是大于两个吧。

测试：使用学得的模型进行预测。

测试样本：被预测的样本。

聚类：将训练集中的西瓜分成若干组，例如高工资、低工资。

簇：被聚类成分成的组，每一组就是一个簇。

监督学习：有标记信息，分类任务和回归任务。

半监督学习：监督学习与无监督学习相结合的一种学习方法。半监督学习使用大量的未标记数据，以及同时使用标记数据，来进行模式识别工作。

无监督学习：无标记信息，聚类任务。

泛化能力：学的模型适用于新样本的能力。具有强泛化能力的模型能很好地适应于整个样本空间。

独立同分布：可以先假设样本空间都服从一个未知的分布，我们获得的每个样本都是独立的从这个分布上采样获得的，即独立同分布。一般而言，训练样本越多，我们获得关于该分布的信息越多，就越有可能通过学习获得具有强泛化能力的模型。

术语例题

• 上表中样本是？
• 一共有多少样本？
• 样本的属性都是？
• 样本标记是？
• 用户「周六」属性值和标记值是？

假设空间

科学推理的两个基本手段：演绎、归纳。

演绎：从一般到特殊的特化，即从基础原理推演出具体状况，例如数学公式就是从一些常识和推理逻辑，推导出了相洽的定理。

归纳：从特殊到一般的泛化过程，就是从具体的事实归结出一般性规律。机器学习也就是用的这种推理方法。

广义的归纳学习：从样例中学习。

狭义的归纳学习：从训练数据中学得概念。

狭义的归纳学习，有时候也成为概念学习。概念学习中最基础的就是布尔概念学习，也就是对「是」「不是」这样的目标概念的学习。

假设的确定

我们可以把学习的过程看做一个在所有假设组成的空间中进行搜索的过程，搜索的目标是 找到与训练集匹配的假设，也就是能够将训练集中的瓜判断正确的假设。

假设的表示一旦确定下来，假设空间及其规模大小就确定了。

简单的讲，假设就是所有属性的所有取值情况（不受数据集约束）。

与数据集匹配的假设就是

色泽 = *; 根蒂 = 蜷缩； 敲声 = 浊响

也就是好瓜就是，根蒂蜷缩、敲声浊响，什么色泽都行的瓜。

这个能够判断所有数据集的“假设集合”已经非常接近版本空间，版本空间与这个“假设集合”的区别主要是因为。版本空间是将所有假设全部列出来后，然后用数据集一个一个去进行搜索，然后将删除与正例不一致的假设。这里主要的问题就是，对于一些属性它无法进行判断，因为数据集没有覆盖完整。

在做题的时候，也只有尽可能的往上面再想一层，看看它那个属性的上一层就算取任意值也算正例。

版本空间例题1

给出上表所对应的版本空间，用符号 * 表示取任何值都可以。

版本空间例题2

该数据集的版本空间是？

归纳偏好

通过上面的 版本空间例题2 可以了解到，我们通过学习获得了 3 个与训练集一致的假设（版本空间里面有 3 种不同的假设）。但是有一个问题，就是它在面临新样本的时候，可能会输出不同的结果。

比如这里有个新瓜

色泽 = 青绿； 根茎 = 蜷缩； 敲声 = 沉闷

如果使用 B 条件（点开上面的答案）判断，那么它会把这个新瓜判断为好瓜。

但是如果使用 C 条件判断，那么它会把这个新瓜判断为坏瓜。

如果在我们使用机器学习算法的时候，遇到这种样本它每次都随机挑选一个条件进行判断，进而导致每次预测的时候结果时而好又时而坏，这样的学习结果显然是没有意义的。

所以我们需要让机器学习算法在学习的过程中，要对于某种类型的假设有偏好。我们就称其为归纳偏好，或简称为偏好。

比如它的偏好如果是“尽可能特殊”的模型，那么它就会选择版本空间右上角那一个，因为这个模型确定了 3 种属性分别都是一个具体的取值。

又比如它的偏好是“尽可能一般”的模型，并且由于某种原因它更相信根蒂，那么它就会选择版本空间左上角那一个。因为这个模型更多的使用了 * 来确认取值，同时它指定了根茎是蜷缩。

奥卡姆剃刀

奥卡姆剃刀就是一种用来，评判哪一种“偏好”更好的原则。也即是若有多个假设与观察一致，则选择最简单的那个。

可以总结为，简单的就是最好的

这里的每个训练样本是图中的一个点（x，y），要学习一个与训练集一致的模型，相当于找到一条穿过所有训练样本的曲线。

在这里我们就列举出了两条曲线，其中 A 是较为平滑的一条它的方程式是 $y=-x^2+6x+1$ ，而 B 曲线是要复杂很多。

假设我们认为“更平滑”意味着“更简单”，所以在上面的图中我们会自然的偏好于选择更平滑的曲线 A。

但是奥卡姆剃刀并不是唯一可行的原则，因为在很多问题中，我们并不能找到哪一种假设更简单。同时也有一个问题，万一所有的样本都比较刁钻，他们都正好和 B 完全重合了呢？这个也正是下面这个定理要说明的。

没有免费的午餐

首先你不要被这个定理的名字所迷惑，可以先把这个命名放在另一边，看看定理的内容。

简单的描述这个定理就是，没有任何一个机器学习算法适合所有情况。

这个定理也很符合我们的直觉，就和上面奥卡姆剃刀举例的那两个曲线一样。A 曲线所代表的的机器学习算法，比 B 曲线的机器学习算法要牛逼些吗？并不是，因为 没有免费的午餐 定理证明了他们两种及其学习算法的正确率是完全一致的。

说人话就是，对于所有机器学习问题，任何一种算法的期望性能都是相等的。

但是也不要因为这个定理就觉得机器学习没意思了，因为这个定理有一个前提。也就是，所有问题出现的机会相同、或所有问题同等重要。但是在实际情况中，我们的很多问题都不是这样的，你只需要关注自己需要解决的问题就行了。

比如在学校里面有个电瓶车代步是一个很方便的选择，但是你如果要去外地又或是去国外，那么你可能坐飞机会更好一些。但是你就是想在学校里面找个代步工具，那么买飞机的事情你就不需要关心了。

返回到这个定理上面来，其实它想说的和丢了芝麻捡西瓜一样，也就是有得必有失。某一个机器学习算法在某一个领域非常好用，但是换到另一个地方却完全不好使了。

也就是说，当天上突然掉馅饼的时候你现在吃到了，但是你之后就会遇到很倒霉的事情。这么说应该就能理解没有免费的午餐是什么意思了。

经验误差与过拟合

如果在 m 个样本中有 α 个样本分类错误，则错误率 $E=\frac{a}{m}$

精度：$1-\frac{a}{m}$，也即是精度=1-错误率。

误差：学习器的实际预测输出与样本的真实输出之间的差异。（对单个样本的学习）

训练误差/经验误差：学习器在训练集上的误差。（整个数据集）

泛化误差：在新样本上的误差。

我们希望得到泛化误差小的学习器。然而，我们事先并不知道新样本是什么样，实际能做的是努力使经验误差最小化。

过拟合：当学习器把训练样本学得”太好”了的时候，很可能巳经把训练样本自身的一些特点当作了所有潜在样本都会具有的一般性质，这样就会导致泛化性能下降。这就是过拟合。

过拟合是无法彻底避免的，我们所能做的只是“缓解”，或者说减小其风险。

欠拟合：这是指对训练样本的一般性质尚未学好。

欠拟合比较容易克服，例如在决策树学习中扩展分支、在神经网络学习中增加训练轮数等。

留出法

这是评估方法的一种，使用测试集来测试学习器对新样本的判别能力，在测试集上面的测试误差就可以作为泛化误差的近似。同时要使测试集应尽可能的与训练集互斥，也就是测试样本尽量不在训练集中出现、未在训练过程中使用过。

假定数据集包含 1000 个样本，将其划分为一个 S 集合包含 700 个样本，另一个 T 集合包含 300 个样本。用 S 集合进行训练后，在使用 T 集合进行测试。通过统计测试结果的正确率，就能知道精度和错误率了。这个方法就是留出法。

划分的时候一般都是 训练集样本数 > 测试集样本数。 $\frac{2}{3} \text{~} \frac{4}{5}$ 的样本用于训练，剩下的测试。

划分训练集和测试集时，要尽可能保持数据分布的一致性。

比如整个数据集有 500 个正例、500 个反例，则划分时 S 应包含 350 个正例、350 个反例，而 T 则包含150 个正例和 150 个反例。这个也叫分层采样，若 S、T 中样本类别比例差别很大，则误差估计将由于训练/测试数据分布的差异而产生偏差。

还有一个问题，如果初始数据集里面样本的顺序很极端，前 500 个全是正例，后 500 个全是反例。直接划分的话就不准确，所以单次使用留出法得到的估计结果往往不够稳定可靠，在使用留出法时，一般要采用若干次随机划分、重复进行实验评估后取平均值作为留出法的评估结果。

交叉检验法

先将数据集划分为 k 个大小相似的互斥子集，也就是每一个子集都尽可能保持数据分布的一致性（都不重复）。

然后每次都只取其中的最后一个为测试集，前面几个都用来做训练集。

最终返回的是这 k 个测试结果的均值。显然，交叉验证法评估结果的稳定性和保真性在很大程度上取决于 k 的取值，为强调这一点，通常把交叉验证法称 k 折交叉验证。k 最常用的取值为 10，此时称为 10 折交叉验证。

假定数据集 D 中包含 m 个样本，若令 k=m ， 则得到了交叉验证法的一个特列：留一法。也就是每一个子集只包含一个样本。测试集就取整个数据集的最后一个。

留一法的评估结果往往被认为比较准确，但是他也有缺陷，留一法在数据集比较大时训练模型的计算开销可能是难以忍受的。另外，留一法的估计结果也未必永远比其他评估方法准确，“没有免费的午餐”定理对实验评估方法同样适用。

自助法

给定包含 m 个样本的数据集 D ， 我们对它进行采样产生数据集 D’:

每次随机从 D 中挑选一个样本， 将其拷贝放入 D’ 然后再将该样本放回初始数据集 D 中，使得该样本在下次采样时仍有可能被采到;这个过程重复执行 m 次后，我们就得到了包含 m 个样本的数据集 D’，这就是自助采样的结果。

我们还可以估计样本在 m 次采样中始终不被采到的概率

$$
\begin{aligned}
P&=\lim\limits_{m→∞}(1-\frac{1}{m})^m \
&=\frac{1}{e} \
&≈0.368
\end{aligned}
$$

自助法在数据集较小、难以有效划分训练/测试集时很有用;此外，自助法能从初始数据集中产生多个不同的训练集，这对集成学习等方法有很大的好处.然而，自助法产生的数据集改变了初始数据集的分布，这会引入估计偏差。因此，在初始数据量足够时，留出法和交叉验证法更常用一些。

性能度量

对模型泛化能力的评价标准就是性能度量。

因为对于不同的模型，使用不同的性能度量方法会导致不同的评判结果。这意味着模型的“好坏”是相对的，一个好的模型不只是它的算法好坏，还取决于它的任务需求。

比如回归任务最常用的性能度量是“均方误差”（mean squared error）

$$
E(f;D) = \frac{1}{m}\sum_{i = 1}^m (f(x_i) - y_i)^2
$$

$E$：数学期望，也就是均值。是一种概率论概念，样本出现的情况结合出现的概率，是一种加权平均。（最后一步都是求平均值，这个公式其实和平均值有点类似）

$f$：代指我们训练的模型。

$D$：数据集。

$m$：样本的总数量。

$i$：当前样本的下标。

$x_i$：第 i 个样本的预测结果的标签（好瓜/坏瓜）。

$y_i$：第 i 个样本的标签真实值。

$\displaystyle\sum_{i=1}^m(x_i)$：通过下标将所有 x 相加起来。和 for 循环差不多。

1
2
3
4
5

int sum = 0;
int list[] = {0, 1, 2, 3, 4};
for(i=1; i<=m; i++){
    sum = sum + list[i];
}

简单来说，就是把所有预测值和真实值相减，然后在求他们的平方之和。最后再求个平均值。

错误率与精度

错误率和精度是分类任务（预测的结果是布尔值的任务）中最常用的两种性能度量。

他们既适用于二分类任务，也适用于多分类任务。

错误率

对样例集 $D$，分类错误率定义为

$$
E(f;D) = \frac{1}{m}\sum_{i = 1}^m \text{Ⅱ}(f(x_i) \ne y_i)
$$

$E(f;D)$：对模型 $f$ 和数据集 $D$ 的数学期望。

$m$：样本的总数量。

$i$：当前样本的下标。

$x_i$：第 i 个样本的预测结果的标签（好瓜/坏瓜）。

$y_i$：第 i 个样本的标签真实值。

$Ⅱ$：相当于定义的一个函数，和 $f(x)$ 概念类似，只是它这个符号比较迷惑。

$$
Ⅱ(f({x_i}) \ne {y_i}) = \begin{cases}
1 ,&\text{if }f(x_i) \ne y_i \
0 ,&\text{if }f(x_i) = y_i
\end{cases}
$$

也就是：

• 如果预测值和实际值相等，那么这个函数输出 0。
• 如果预测值和实际值有偏差，那么这个函数输出 1。

最后又把他们输出的所有值全部加起来，再求个平均值。

精度

精度也就是正确率，上面求出来了错误率，那么直接用 1 减去它就行了。

$$ acc(f;D) = 1-E(f;D) $$

$acc(f;D)$：acc 是 Accuracy 的缩写，意思是 准确/精确 率。

$E(f;D)$：就是上面的错误率。

当然了你也可以通过改写上面的 $Ⅱ$ 函数，直接计算精度。

$$ E(f;D) = \frac{1}{m}\sum\limits_{i = 1}^m Ⅱ(f({x_i}) \color{blue}= \color{black}{y_i}) $$

将 $Ⅱ$ 函数改成：

• 如果预测值和实际值相等，那么这个函数输出 1。
• 如果预测值和实际值有偏差，那么这个函数输出 0。

$$
Ⅱ(f({x_i}) \color{blue}=\color{black} {y_i}) = \begin{cases}
1 ,&\text{if }f(x_i) \color{blue}=\color{black} y_i \
0 ,&\text{if }f(x_i) \color{blue}\ne\color{black} y_i
\end{cases}
$$

注意这里的 $=$ 和 $\ne$ 与上面错误率的公式有差别。

通过改写后，我们就相当于通过 $Ⅱ$ 直接求出了正确样本的总个数，再通过最外面的 $\frac{1}{m}$ 就直接可以求出正确率的百分比了。

查准率与查全率

查准率（Precision）：判定是对的样例中，到底有多少真是对的。

查全率（Recall）：所有对的样例，你找出了多少，或者说你判断对了多少。

这个就叫混淆矩阵

查准率 P 与 查全率 R 分别定义为

$$ p=\frac{TP}{TP+FP} $$

$$ R=\frac{TP}{TP+FN} $$

查准率和查全率是一对矛盾的变量。一般来说，其中一个高另一个就会低。

比如，要尽可能将好瓜选出来，那么就增加选瓜的数量，如果把所有瓜都选上了，好瓜肯定也都选上了。但是这样的话查准率就会很低。反之亦然。

F1 度量

F1 度量是用于找到一个查全率和查准率的平衡点算法。

$$
F1 = \frac{2×P×R}{P+R} = \frac{2×TP}{样例总数+TP-TN}
$$

F1 度量还可以通过调整参数，让他向查全率偏重，或者是向查准率偏重。

$$
F_β = \frac{(1+β^2)×P×R}{(β^2×P)+R}
$$

$$
F_β = \begin{cases}
偏重查全率 &β>1\
标准 F1 &β=1\
偏重查准率 &β<1
\end{cases}
$$

宏/微F1

很多时候我们有多个二分类混淆矩阵(忘了混淆矩阵是什么的去这里看看)，然后我们有一个方法可以在 n 个二分类混淆矩阵上综合考察查准率和查全率。

• 宏：先计算查准率和查全率再求平均值。
• 微：先计算 TP、FP、TN、FN 的平均值再求查准率和查全率。

宏

你要先回想以前之前的，查准率（Precision）和查全率（Recall）。

$$ P=\frac{TP}{TP+FP} $$

$$ R=\frac{TP}{TP+FN} $$

宏查准率与宏查全率就是把他们求了个平均值。

宏（macro）查准率：

$$
macro-P = \frac{1}{n}\sum_{i=1}^nP_i
$$

宏查全率：

$$
macro-R = \frac{1}{n}\sum_{i=1}^nR_i
$$

可以理解为，先把每一个混淆矩阵的 P 和 R 都求出来，然后再把他们求个平均值就行了。

后面的宏 F1 也就比较好理解，还是回想之前计算 F1 的公式。

$$
F1 = \frac{2×P×R}{P+R}
$$

令上面式子的 $P=macro-P$ 同时令 $R=macro-R$ 那么就可以得到下面的式子了

$$
macro-F1 = \frac{2×macro-P×macro-R}{macro-P+macro-R}
$$

微

介绍完了宏，再来介绍一下微（micro）。还是放一下这个混淆矩阵.

当有多个混淆矩阵的时候，你也会有很多个 TP、FN、FP、TN。那么你可以先分别计算所有混淆矩阵的 TP、FN、FP、TN 的平均值。我们将求过平均值后的数上面画一个横线，那么就有。

$TP$ 的平均值为 $\overline{TP}$

$FN$ 的平均值为 $\overline{FN}$

$FP$ 的平均值为 $\overline{FP}$

$TN$ 的平均值为 $\overline{TN}$

有了这四个参数，我们再回头看看之前的查准率和查全率公式：

$$ P=\frac{TP}{TP+FP} $$

$$ R=\frac{TP}{TP+FN} $$

把里面的变量都用计算平均值过后的替换一下，就可以计算微（micro）查准率：

$$
micro-P = \frac{\overline{TP}}{\overline{TP}+\overline{FP}}
$$

微查全率也很简单啦：

$$
micro-R = \frac{\overline{TP}}{\overline{TP}+\overline{FN}}
$$

后面的微 F1 也是把每一位的都替换一下就行了：

$$
micro-F1 = \frac{2×micro-P×micro-R}{micro-P×micro-R}
$$

P-R ROC AUC

P-R

P-R 曲线横坐标是查全率：

$$ R=\frac{TP}{TP+FN} $$

纵坐标是查准率：

$$ P=\frac{TP}{TP+FP} $$

ROC

横坐标的两个参数，都是混淆矩阵的第二行，这个分子的 FP 是我们不想要的。

ROC 曲线的横坐标是假正例率（Flase Positive Rate）：

$$ FPR=\frac{FP}{FP+TN} $$

纵坐标的两个参数，都是混淆矩阵的第一行，这个分子的 TP 是我们想要的。

纵坐标是真正例率（True Positive Rate），这个公式和 $R$ 是一摸一样的。

$$ TPR=\frac{TP}{TP+FN} $$

我们最想要的就是横坐标很小，但是纵坐标很大的模型。

左边这个图在绘制的时候，是人工美化让他变光滑了的。

但是右边这个图才是实际情况下的图，因为样本数量是有限的，两个点之间的距离也都是直线，所以就会有很多锯齿。

左边那个图，中间的虚线不用去理解它。同时你也要注意，左图的 AUC 指的是阴影部分，和那个虚线没有任何关系。

AUC

AUC（Area Under ROC Curve）指的 ROC 曲线下面的面积，而这个面积越大，这个模型就越好。

虽然 AUC 这个概念只是说的 ROC 但是 P-R 曲线也是曲线下面的面积越大越好。

术语中英对照

参考

奥卡姆剃刀和没有免费的午餐定理@LogM’s Blog

今天我会继续讲四个复杂度分析方面的知识点，最好情况时间复杂度（best case time complexity）、最坏情况时间复杂度（worst case time complexity）、平均情况时间复杂度（average case time complexity）、均摊时间复杂度（amortized time complexity）。如果这几个概念你都能掌握，那对你来说，复杂度分析这部分内容就没什么大问题了。

最好、最坏情况时间复杂

先上代码

1
2
3
4
5
6
7
8
9

// n表示数组array的长度
int find(int[] array, int n, int x) {
  int i = 0;
  int pos = -1;
  for (; i < n; ++i) {
    if (array[i] == x) pos = i;
  }
  return pos;
}

这段代码在一个无序的数组（array）中，查找 变量 x 出现的位置。如果没有找到就返回 -1。

使用上一篇文章的方法进行分析，这段代码的复杂度是 $O(n)$，其中 n 代表数组的长度。

我们在数组中查找一个数据，并不需要每次都把整个数组都遍历一遍，因为有可能中途找到就可以提前结束循环了。但是，这段代码写得不够高效。我们可以这样优化一下这段查找代码。

1
2
3
4
5
6
7
8
9
10
11
12

// n表示数组array的长度
int find(int[] array, int n, int x) {
  int i = 0;
  int pos = -1;
  for (; i < n; ++i) {
    if (array[i] == x) {
       pos = i;
       break;
    }
  }
  return pos;
}

这个时候，问题就来了。我们优化完之后，这段代码的时间复杂度还是 $O(n)$ 吗？很显然，咱们上一节讲的分析方法，解决不了这个问题。

如果要查找的元素就在第 1 个位置，那么时间复杂度就是 $O(1)$。

但是如果元素不在数组内，那么它会把整个数组都循环一遍，时间复杂度就是 $O(n)$。

为了表示代码在不同情况下的不同时间复杂度，我们需要引入三个概念：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。

顾名思义，最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。就像我们刚刚讲到的，在最理想的情况下，要查找的变量正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。

同理，最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。就像刚举的那个例子，如果数组中没有要查找的变量，我们需要把整个数组都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。

平均情况时间复杂度

我们都知道，最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，发生的概率其实并不大。

为了更好地表示平均情况下的复杂度，我们需要引入另一个概念：平均情况时间复杂度，后面我简称为平均时间复杂度。

平均时间复杂度又该怎么分析呢？我还是借助刚才查找变量 x 的例子来给你解释。要查找的变量 x 在数组中的位置，有 n+1 种情况：在数组的 0～n-1 位置中和不在数组中。我们把每种情况下，查找需要遍历的元素个数累加起来，然后再除以 $n+1$，就可以得到需要遍历的元素个数的平均值，即：

$$ \frac{1+2+3+\dots+n+n}{n+1}=\frac{n(n+3)}{2(n+1)} $$

我们知道，时间复杂度的大 O 标记法中，可以省略掉系数、低阶、常量，所以，咱们把刚刚这个公式简化之后，得到的平均时间复杂度就是：

$$ O(n) $$

这个结论虽然是正确的，但是计算过程稍微有点儿问题。究竟是什么问题呢？我们刚讲的这 n+1 种情况，出现的概率并不是一样的。（这里要稍微用到一点儿概率论的知识）

我们知道，要查找的变量 x，要么在数组里，要么就不在数组里。

这两种情况对应的概率统计起来很麻烦，为了方便你理解，我们假设在数组中与不在数组中的概率都为 $\frac{1}{2}$。

另外，要查找的数据出现在 0～n-1 这 n 个位置的概率也是一样的，为 $\frac{1}{n}$。所以，根据概率乘法法则，要查找的数据出现在 0～n-1 中任意位置的概率就是：

$$ \frac{1}{2}\cdot\frac{1}{n}=\frac{1}{2n} $$

算出了数据出现在任意位置的概率，又因为执行次数的也是会在 1~n 之内变化的，所以把每一种情况出现的概率也要考虑进去，那么平均时间复杂度的计算过程变成了这个样子：

$$ 1\times\frac{1}{2n}+ 2\times\frac{1}{2n}+ 3\times\frac{1}{2n}+ \dots+n\times\frac{1}{2n}+n\times\frac{1}{2}=\frac{3n+1}{4} $$

最后面一个 $n$ 是不在数组中的概率，它独占 $\frac{1}{2}$，所以最后一个是 $n\times\frac{1}{2}$。

这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

引入概率之后，前面那段代码的加权平均值为 $(3n+1)/4$。用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是 $O(n)$。

你可能会说，平均时间复杂度分析好复杂啊，还要涉及概率论的知识。实际上，在大多数情况下，我们并不需要区分最好、最坏、平均情况时间复杂度三种情况。

像上一节的那些例子一样，很多时候，我们使用一个复杂度就可以满足需求了。只有同一块代码在不同的情况下，时间复杂度有量级的差距，我们才会使用这三种复杂度表示法来区分。

均摊时间复杂度

到此为止，你应该已经掌握了算法复杂度分析的大部分内容了。下面我要给你讲一个更加高级的概念，均摊时间复杂度，以及它对应的分析方法，摊还分析（或者叫平摊分析）。

均摊时间复杂度，听起来跟平均时间复杂度有点儿像。这两个概念确实非常容易弄混。我前面说了，大部分情况下，我们并不需要区分最好、最坏、平均三种复杂度。平均复杂度只在某些特殊情况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。

老规矩，我还是借助一个具体的例子来帮助你理解。（当然，这个例子只是我为了方便讲解想出来的，实际上没人会这么写。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// array表示一个长度为n的数组
// 代码中的array.length就等于n
int[] array = new int[n];
int count = 0;

void insert(int val) {
   if (count == array.length) {
      int sum = 0;
      for (int i = 0; i < array.length; ++i) {
         sum = sum + array[i];
      }
      array[0] = sum;
      count = 1;
   }

   array[count] = val;
   ++count;
}

我先来解释一下这段代码。这段代码实现了一个往数组中插入数据的功能。当数组满了之后，也就是代码中的 count == array.length 时，我们用 for 循环遍历数组求和，并清空数组，将求和之后的 sum 值放到数组的第一个位置，然后再将新的数据插入。但如果数组一开始就有空闲空间，则直接将数据插入数组。

最理想的情况下，数组中有空闲空间，我们只需要将数据插入到数组下标为 count 的位置就可以了，所以最好情况时间复杂度为 $O(1)$。

最坏的情况下，数组中没有空闲空间了，我们需要先做一次数组的遍历求和，然后再将数据插入，所以最坏情况时间复杂度为 $O(n)$。

平均时间复杂度也可以用上面的方法计算出来，假设数组的长度是 n，根据数据插入的位置的不同，我们可以分为 n 种情况，每种情况的时间复杂度是 $O(1)$。除此之外，还有一种“额外”的情况，就是在数组没有空闲空间时插入一个数据，这个时候的时间复杂度是 $O(n)$。而且，这 n+1 种情况发生的概率一样，都是 $1/(n+1)$。所以，根据加权平均的计算方法，我们求得的平均时间复杂度就是：

$$
\begin{align}
T(n) &= 1\times\frac{1}{n+1}+ 1\times\frac{1}{n+1}+ \dots+ 1\times\frac{1}{n+1}+ n\times\frac{1}{n+1}\
&= \frac{(n+1)\times1}{n+1}+n\times\frac{1}{n+1}\
&= 1+n\times\frac{1}{n+1}\
&= \frac{n}{n}\
&= O(1)
\end{align}
$$

至此为止，前面的最好、最坏、平均时间复杂度的计算，理解起来应该都没有问题。但是这个例子里的平均复杂度分析其实并不需要这么复杂，不需要引入概率论的知识。这是为什么呢？我们先来对比一下这个 insert() 的例子和前面那个 find() 的例子，你就会发现这两者有很大差别。

首先，find() 函数在极端情况下，复杂度才为 $O(1)$。但 insert() 在大部分情况下，时间复杂度都为 $O(1)$。只有个别情况下，复杂度才比较高，为 $O(n)$。这是 insert() 第一个区别于 find() 的地方。

我们再来看第二个不同的地方。对于 insert() 函数来说，$O(1)$ 时间复杂度的插入和 $O(n)$ 时间复杂度的插入，出现的频率是非常有规律的，而且有一定的前后时序关系，一般都是一个 $O(n)$ 插入之后，紧跟着 n-1 个 $O(1)$ 的插入操作，循环往复。

所以，针对这样一种特殊场景的复杂度分析，我们并不需要像之前讲平均复杂度分析方法那样，找出所有的输入情况及相应的发生概率，然后再计算加权平均值。

针对这种特殊的场景，我们引入了一种更加简单的分析方法：摊还分析法，通过摊还分析得到的时间复杂度我们起了一个名字，叫均摊时间复杂度。

那究竟如何使用摊还分析法来分析算法的均摊时间复杂度呢？

我们还是继续看在数组中插入数据的这个例子。每一次 $O(n)$ 的插入操作，都会跟着 n-1 次 $O(1)$ 的插入操作，所以把耗时多的那次操作均摊到接下来的 n-1 次耗时少的操作上，均摊下来，这一组连续的操作的均摊时间复杂度就是 $O(1)$。这就是均摊分析的大致思路。

均摊时间复杂度和摊还分析应用场景比较特殊，所以我们并不会经常用到。为了方便你理解、记忆，我这里简单总结一下它们的应用场景。如果有遇到了，知道是怎么回事儿就行了。

对一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高，而且这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一块儿分析，看是否能将较高时间复杂度那次操作的耗时，平摊到其他那些时间复杂度比较低的操作上。

而且，在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。

内容小结

今天我们学习了几个复杂度分析相关的概念，分别有：最好情况时间复杂度、最坏情况时间复杂度、平均情况时间复杂度、均摊时间复杂度。

之所以引入这几个复杂度概念，是因为，同一段代码，在不同输入的情况下，复杂度量级有可能是不一样的。

参考

极客时间@王争 - 数据结构与算法之美

katex Docs

Wikipedia - 加權平均數

CSDN@Mr.Q - LaTex 点乘，叉乘，点除，分数等常用算法

知乎@alven - 如何证明概率论的乘法公式？

为什么需要复杂度分析

在写代码的时候，我总是会有意识的想要提升运行效率，但是我在写完了一段代码后我也不知道它的速度是快还是慢。我甚至会在满足一些自己所谓的高效率，而花费太多不必要的时间。

通过对空间、时间复杂度的分析，可以让我写代码时更佳自信。

大 O 复杂度表示法

先上代码

1
2
3
4
5
6
7
8

public static int cal(int n) {
   int sum = 0;
   int i = 1;
   for (; i <= n; ++i) {
     sum = sum + i;
   }
   return sum;
 }

一个简单的 计算数列和 的代码，也就是 1, 2, 3, ... ， n-1, n 所有数字的和。

虽然计算机运行代码的时间，会比想象中的难以计算。因为每一行代码都是不同的，还会有很多不确定的情况。但是在计算复杂度时，都会大致将其看作一行代码，花了一个单位时间。

所以在这段代码中，L2-3 分别运行了一次，L4-5 分别运行了 n 次。那么我将这个代码的运行时间大概估计为 $2n+2$ 次，同时得出了一个结论，所有代码的执行时间 T(n) 与每行代码的执行次数成正比。

再看一段代码

1
2
3
4
5
6
7
8
9
10
11
12

public static int cal(int n) {
   int sum = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       sum = sum +  i * j;
     }
   }
   return sum;
 }

在这一段代码中，L2-4 一共运行了 3 次（L1 初始化就不计了），L5 和 L6 都运行了 n 次，那么一共需要 $2n$ 次。L7 和 L8 都运行了 $n^2$ 次，那么一共运行了 $2n^2$ 次。如果把运行一次的时间设为 RunTime ，这段代码一共运行的时间 T(n) 为。

$$ T(n)=(2n^2+2n+3)*RunTime $$

通过对这两段代码的分析，我们可以得到一个非常重要的规律，即，所有代码的执行时间 T(n) 与每行代码的执行次数 n 成正比。

我们可以把这个规律总结成一个规律，也就是

$$ T(n)=O(f(n)) $$

第一段代码的 $T(n)=O(2n+2)$ 和 第二段代码的 $T(n)=O(2n^2+2n+3)$ 也就是大 O 时间复杂度表示法。

大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了，如果用大 O 表示法表示刚讲的那两段代码的时间复杂度，就可以记为

$$ T(n) = O(n) $$

$$ T(n) = O(n^2) $$

时间复杂度分析

在进行时间复杂度分析时，可以使用这三个比较使用的方法。

只关注循环执行次数最多的一段代码

我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。

还是第一段代码为例

1
2
3
4
5
6
7
8

public static int cal(int n) {
   int sum = 0;
   int i = 1;
   for (; i <= n; ++i) {
     sum = sum + i;
   }
   return sum;
 }

因为在这段代码中，L2-3 都是常量级的执行时间，与 n 的数据大小无关，所以在我们进行时间复杂度分析时可忽略不计。而循环次数最多的 L4-5 才是我们需要关系的。在前面分析的时候也说了，它被执行了 n 次，所以时间复杂程度也就是 $O(n)$ 。

加法法则：总复杂度等于量级最大的那段代码的复杂度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public static int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       sum_3 = sum_3 +  i * j;
     }
   }
 
   return sum_1 + sum_2 + sum_3;
 }

不难看出来第一段循环它的运行次数是固定的 100 次，所以是一个常量的执行时间，这是与 n 无关的。

第二段代码的循环次数是根据输入的 n 来决定的，所以它的时间复杂度为 $O(n)$ 。

第三段代码也就是在第二段的基础上，又加了一次，也就是 $O(n^2)$ 。

我们在计算的时候，只选取其中时间复杂度最大的一个。所以这段代码的时间复杂度为 $O(n^2)$ 。

也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度

乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public static int cal(int n) {
   int ret = 0; 
   int i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 int f(int n) {
  int sum = 0;
  int i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }

我们单独看 cal() 函数。假设 f() 只是一个普通的操作，那第 4～6 行的时间复杂度就是，$T1(n) = O(n)$。但 f() 函数本身不是一个简单的操作，它的时间复杂度是 $T2(n) = O(n)$，所以，整个 cal() 函数的时间复杂度就是，$T(n) = T1(n) * T2(n) = O(n*n) = O(n^2)$。

几种常见时间复杂度实例分析

虽然代码千差万别，但是常见的复杂度量级也就只有几个。大致可以分为两类。

多项式量级：

• 常量阶 $O(1)$
• 对数阶 $O(logn)$
• 线性阶 $O(n)$
• 线性对数阶 $O(nlogn)$
• 平方阶 $O(n^2)$、立方阶 $O(n^3)$ … K次方阶 $O(n^k)$

非多项式量级：

• 指数阶 $O(2^n)$
• 阶乘阶 $O(n!)$

我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。

当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。因此，关于 NP 时间复杂度我就不展开讲了。我们主要来看几种常见的多项式时间复杂度。

O(1)

需要注意的是，$O(1)$ 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即使有 3 行，它的时间复杂度也是 $O(1)$，而不是 $O(3)$。

1
2
3

int i = 8;
int j = 6;
int sum = i + j;

可以说，只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作$O(1)$。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是 $O(1)$。

O(logn)、O(nlogn)

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。看代码。

1
2
3
4

i=1;
while (i <= n)  {
  i = i * 2;
}

根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。还记得我们高中学过的等比数列吗？实际上，变量 i 的取值就是一个等比数列。如果我把它一个一个列出来，就应该是这个样子的：

$$ 2^0, 2^1, 2^2, … 2^{x-1}, 2^x = n $$

每一个数都是前一个数再乘一个 2。

所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 $2^x=n$ 求解 x 就是 $x=log_2n$，所以，这段代码的时间复杂度就是

$$ O(log_2n) $$

再看一段代码

1
2
3
4

i=1;
while (i <= n)  {
  i = i * 3;
}

根据我刚刚的思路，很简单就能看出来，这段代码的时间复杂度为 $O(log_3n)$。

实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 $O(logn)$。为什么呢？

我们知道，对数之间是可以互相转换的，$log_3n$ 可以进行以下转换。以下所有变换均使用了如下的换底公式。

$$ log_bN = \frac{log_aN}{log_ab} $$

下面开始进行互换，首先设 a 为 2 将所有数换为以 2 为底的。将含有 n 的分母移出来。再使用换底公式将 $log_23$ 换为以 3 为底的。又因为分母的 $log_33=1$ 所以我们换底就成功拉。

$$
\begin{align}
log_3n &= \frac{log_2n}{log_23}\
&= \frac{1}{log_23} \cdot log_2n\
&= \frac{1}{\frac{log_33}{log_32}}\cdot log_2n\
&= \frac{log_32}{log_33}\cdot log_2n\
&= \frac{log_32}{1}\cdot log_2n\
&= log_32\cdot log_2n
\end{align}
$$

因为 $log_3n$ 等于 $log_32 * log_2n$，所以 $O(log_3n) = O(C*log_2n)$，其中 $C = log_32$ 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，$O(log_2n)$ 就等于 $O(log_3n)$。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 $O(logn)$。

如果你理解了我前面讲的 $O(logn)$，那 $O(nlogn)$ 就很容易理解了。还记得我们刚讲的乘法法则吗？如果一段代码的时间复杂度是 $O(logn)$，我们循环执行 n 遍，时间复杂度就是 $O(nlogn)$ 了。而且，$O(nlogn)$ 也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 $O(nlogn)$。

O(m+n)、O(m*n)

我们再来讲一种跟前面都不一样的时间复杂度，代码的复杂度由两个数据的规模来决定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public static int cal(int m, int n) {
  int sum_1 = 0;
  int i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  int sum_2 = 0;
  int j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }

  return sum_1 + sum_2;
}

从代码中可以看出，m 和 n 是表示两个数据规模。我们无法事先评估 m 和 n 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是 $O(m+n)$。

针对这种情况，原来的加法法则就不正确了，我们需要将加法规则改为：$T1(m) + T2(n) = O(f(m) + g(n))$。但是乘法法则继续有效：$T1(m)*T2(n) = O(f(m) * f(n))$。

空间复杂度分析

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

先看一段有点傻的代码

1
2
3
4
5
6
7
8
9
10
11

public static void print(int n) {
  int i = 0;
  int[] a = new int[n];
  for (i; i <n; ++i) {
    a[i] = i * i;
  }

  for (i = n-1; i >= 0; --i) {
    print out a[i]
  }
}

跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。

我们常见的空间复杂度就是 $O(1)$、$O(n)$、$O(n2)$，像 $O(logn)$、$O(nlogn)$ 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，这样就够了。

小结

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：$O(1)$、$O(logn)$、$O(n)$、$O(nlogn)$、$O(n2)$。

参考

极客时间@王争 - 数据结构与算法之美

katex Docs

简书@胜负55开 - LateX：对数表示

简书@PursueLuo - Latex 公式等号对齐

百度百科 - 换底公式

前言

依赖

• 需要一个能够刷 OpenWrt 的路由器(需具有数据包镜像和 udpxy 功能/插件)用于抓包和后续的使用，因为其功耗较低且价格比较便宜 Newifi D2 拼多多 100 以下就可以拿下
• 能够正常播放节目的 IPTV 机顶盒，如果自己家里都没有能用的那就没有融合一说了

环境

因为不同地区网络环境不同，我这里是四川电信，但是可能在同一个省环境都会不一样，所以并不一定在其他地区可用。

无需电信 IPTV 机顶盒，也可在任何设备上通过 http 链接直接播放直播节目。下图分别为 PotPlayer(PC) 和 超级直播(Android) 播放节目效果图。

iGMP 与 RTSP

在 IPTV 中常见的两种用于播放直播节目的协议分别为 IGMP 和 RTSP，他们之间的差异如下。

IGMP

网路群组管理协议（英语：Internet Group Management Protocol，缩写：IGMP）是用于管理网路协议多播组成员的一种通信协议，有时候我也会将其称为组播。

在电信这边，组播地址通常很少变化，但是很重要的是它只能看直播不能看回放。又因为它的地址是内网地址，所以你必须要获取到电信的内网IP才能正常播放。我比较倾向于使用组播地址，因为电视节目回放有啥可看的，一般都是爱奇艺什么的了，而且最重要的是它的地址很少变化，这样就给不会倒腾的家人减少了很多麻烦。

原理上组播和广播(给网络里的所有人都发送一个消息)有点相似，但是组播会划分一个更小的范围，并且这个范围里面设备的名单会同时由客户端和主机端进行维护，路由器会根据不同的组别来转发不同的数据。

下面假装这个网络里面，有 3组 人正在分别在看 3个 节目。

正在收看 CCTV-251 的朋友说，这太假了。我想看点正能量的、让人血脉喷张的。然后请求换到 正在播放 CCTV-1 的 igmp://239.93.22.133:9260

路由器随后听到了这位朋友的呼唤，然后就将它放进了 CCTV-1 的组里。

通过上面的例子你大致能了解到 IGMP 协议的工作原理，可以简单的总结为 IGMP 就是 一对多，下面的一个例子则是和 IGMP 相反。

RTSP

实时流协议（Real Time Streaming Protocol，RTSP）是一种网络应用协议，专为娱乐和通信系统的使用，以控制流媒体服务器。该协议用于创建和控制终端之间的媒体会话。媒体服务器的客户端发布VCR命令，例如播放，录制和暂停，以便于实时控制从服务器到客户端（视频点播）或从客户端到服务器（语音录音）的媒体流，有时候我也会将其称为时移。

原理上 RTSP 和常见的 HTTP 协议比较相似，也就是 一对一，下面这个图可以帮助你理解。

你在观看节目的时候，可以随意的后退暂停，也可以自己想看什么就看什么，不用加入别人的组，整个资源都被你一个人享用。就和你平时看爱奇艺，B站什么的没区别。

正如上面的介绍一样，RTSP 的主要特点就是可以时移，也就是可以拖动进度条。而且大部分地区的 RTSP 地址都是公网 IP，甚至还可以在获取到地址后，不需要任何授权都可以直接正常播放。

所以网络上流传的 IPTV 直播源基本都是 RTSP 地址。不过四川电信这边 RTSP 有鉴权，必须要以电信的内网 IP 访问才行。

同时又因为有部分套餐的 IPTV 是没有回放权限的，所以电信应该还需要验证是谁在播放，这就让观看它成为了比较麻烦的事情(不同地区情况不同，这里只针对我所在的地区)。

目标

通过了我上面对 IGMP 和 RTSP 协议的介绍，相信你对他俩都有了一定的了解。接下来我将为你详细介绍本次教程的内容。

• 适合本项目的硬件设备
• 软件安装及环境配置
• 抓包获取 IPTV 的 IGMP 和 RTSP 播放地址
• 使用 igmpproxy 将所有 IGMP 数据转发到 IPTV 口
• 使用 udpxy 将 IGMP 地址转换为 HTTP
• 在电视盒子、手机和 PC 上正常播放
• 在外欣赏自家 IPTV 直播源

你可以通过点击右侧边栏，来快速跳跃到你需要的章节或查阅你当前的浏览进度。

硬件

本章节会介绍你所需要的硬件设备，在抓包和使用融合网络时不可避免的会使用到，生活中平时少见的设备。

路由器

IPTV与互联网融合，的主要设备也就是路由器了。一款合适的路由器，可以和电脑一起直接走通整个教程。对于本教程而言，一个能够刷 OpenWrt 或 Lede 同时还能安装 igmpproxy 和 udpxy 最好还支持 交换机端口镜像 就完美了。当然也有一些教程是通过 Padavan 来实现的，但是我个人没有尝试过，这里就不做评价了。

如果你目前没有具有此功能的路由器，我推荐你购买 新三 它还有其他的名字 新路由3、Newifi D2、Newifi 3、Newifi 3 D2。也都是同一款，得益于所谓的矿难，这款路由器目前淘宝、拼多多和转转之类的，100元以内都可以拿下，同时购买的时候推荐你加钱让卖家刷好 Breed 和我使用一样的硬件设备，这也能让你配置的时候少走一些弯路。

Breed 相当于 Android 里面的 Recovery，Windows 里面的 PE。可以让你在刷机的时候不会轻易翻车。

抓包工具

通过抓包获取 IPTV 的组播地址也是必不可少的一步。如果你的路由器没有 交换机端口镜像 的功能，你就需要淘宝单独购买一个 网络抓包工具，下图为 Amazon 搜索 Throwing Star LAN Tap 的外观图。

动手能力比较强的朋友，也可以参考恩山无线论坛的这个帖子小白的IPTV折腾教程（1）—0元DIY抓包神器，利用两根网线和4个水晶头就可以做出一个具有同样功能的抓包工具。

不过我还是比较推荐刷一个具有 交换机端口镜像 功能的固件，毕竟直接就可以上手用。如果你是比较热门的机型，比如斐讯又或是我之前说到的 Newifi D2 或是其他搭载了 MT7621 芯片的路由器，应该都不难在恩山找到具有该功能的固件。

软件

下面列出了本次教程中所有需要的软件，我使用软件的版本，以及和下载链接。

下面介绍了每个软件的用途。

这里还有个友华 WR1200JS 可用的固件：youhua_wr1200js.zip

抓包

首先将来自光猫的互联网和往常一样连接到路由器的 WAN 口，将 ITV 口连接到路由器的 LAN 4 口，将 IPTV 盒子连接到路由器的 LAN 3 口，最后将 LAN 1 口连接至电脑。

随后配置路由器的流量镜像功能（我提供的固件中路由器 IP 为 192.168.1.1），将接有 IPTV 盒子的 LAN 3 口（如果抓出来的包只有请求没有回复，那么就改抓 LAN 4）设置为 数据包镜像源端口，将接有电脑的 LAN 1 口设置为 数据包镜像监听端口。其他 VLAN 设置无需改动。

要把光猫上网模式设置为桥接模式，并使用路由器进行拨号。否则当启动数据镜像后，IPTV 盒子会无法正常工作

保存并应用设置后，请严格按照以下步骤进行抓包：

• 确认已经关闭电脑中所有程序，也包括 Wireshark
• 切断 IPTV 盒子电源
• 启动 Wireshark 并监听以太网接口
• 接通 IPTV 盒子电源
• 使用 IPTV 盒子遥控器，选择直播，并播放一个节目
• 让节目保持正常播放 2~3 秒
• 停止 Wireshark 抓包并保存抓包数据
• 切断 IPTV 盒子电源

要关闭电脑中的其他联网程序，不然它也会被抓进来，干扰分析。

关闭 Wireshark 并重开，是方便定位 IPTV 盒子的初始化信息。让 IPTV 盒子初始化的信息，就在最初的几个数据包里面。

切断 IPTV 盒子电源并重开，是为了能够抓到有关初始化的信息，比如获取 IP 的方法，是 DHCP 获取 IP，还是 PPPOE 之类的。

启动 IPTV 盒子后，应不停的有数据显示在窗口中。

如果你没有看到任何数据跳动，或者是特别少，应注意是否端口插错，或者是在设置流量镜像的地方有错。

播放节目是为了让 IPTV 盒子去拉取直播节目列表，我们最需要的也就是直播节目列表信息。

分析抓包数据

因为不同地区的数据样式差异较大，我这里是四川电信，其他地区可供参考

获取地址

在过滤器栏输入

1

http.request.uri contains "frameset_builder.jsp"

四川成都电信可以尝试

1

http.request.uri contains "AuthenticationURL"

右键第一个请求，追踪流 - HTTP 流

再弹出的新窗口中查找

1

igmp://

如果你找到了类似下图 igmp://239.93.22.133:9260 的连接，那么恭喜你，你的数据抓包已经完成了最重要的定位了！（不难发现旁边也获取到了 rtsp:// 开头的时移地址）

单击链接，主窗口就会自动定位到该请求。

单击展开该请求的完整内容，查看里面的内容是不是含有 igmp:// 之类的重要数据。

右键 Line-based text data 导出分组字节流，随便取个名字保存到你能找到的地方。

用 notepad++ 打开，查看是否显示正常(前几行都是回车，会一片空白，往后滑一点就能看到了)。

无法获取到地址

如果你在窗口中一个数据都未获取到，那么请检查数据镜像设置或网线位置是否有错。

如果你是四川省，请仔细检查是不是，在过滤的时候复制错了或漏了内容。

如果你非四川省，可以在过滤器中输入

1

http

进行检索，一条一条的看，里面总会有 igmp:// 之类获取节目单的数据（我也是这样找出来的），如果找不到你也可以向我求助 blackyau426@gmail.com

格式化数据

开始格式化之前，建议保存好原始文件。

替换完毕后可以将名字带有 PIP 的删除，这是用于机顶盒画中画功能的，说白了就是降低了分辨率的，我们就留下正常的和高清的就行了。

M3U8

此格式文件可以在 PC 中直接使用 VLC media player 和 PotPlayer 打开并播放

查找目标

1

.*ChannelName="(.*)",UserChannelID="(.*)",ChannelURL="igmp://(.*)",TimeShift=.*

替换为

1

#EXTINF:-1, \1\r\nhttp://192.168.10.1:8888/udp/\3

将文档中被格式化了的数据，复制到新文档，并在文档首行写入

1

#EXTM3U

处理完毕后效果如图，最后将文件另存为 .m3u8 即可。

超级直播

此文件可以在 Android 端的超级直播使用，电脑打开 在软件里面按返回时提示的网址，可以将自定义源上传至该软件。

查找目标

1

.*ChannelName="(.*)",UserChannelID="(.*)",ChannelURL="igmp://(.*)",TimeShift=.*

替换为

1

\1,http://192.168.10.1:8888/udp/\3

再次查找目标，删除空白行

1

\n\s*\r

替换为空白

全选该文本所有内容后复制，在顶部 编码 - 编码字符集 - 中文 - GB2312，确认切换到该字符集。然后删除文本所有内容，并粘贴。最后将文件保存为 txt 即可。

超级直播中文本编码格式必须为 GB2312 否则中文会乱码

处理完毕后效果如图

获取 IPTV 内网地址

四川电信是 DHCP 获取，我在网上看很多地方都是 PPPOE 所以用户名和密码你们就需要自己翻翻 IPTV 盒子的设置拉~

这边也会使用到抓包的数据，应该就是前几个了，找到 Dynamic Host Configuration Protocol (Request) 请求，展开 Option: (60) Vendor class identifier 和Option: (12) Host Name 以及 Client MAC address 。都需要右键 - 复制 - 值 。

如果你没有找到 DHCP 的数据包，可以通过 IPTV 盒子底部的贴纸查看。我这款盒子，最后一个就是 Option: (12) Host Name 当然了 MAC 地址上面也有，而 Option: (60) Vendor class identifier 我已经在上图给你了，就是 SCITV 。

接下来就开始路由器的设置了。

首先进入路由器设置 - 网络 - 交换机，将之前用于抓包的 数据包镜像 功能关掉。随后将插有 ITV 口的 LAN 4 在 VLAN 1 中设置为 关 。添加一个 VLAN 3 ，将 CPU (eth0) 设置为 tagged ，然后将 VLAN 3 的 LAN 4 设置为 untagged 。设置完毕后，效果如下图。

进入路由器设置 - 网络 - 接口 - 添加新接口。命名为 IPTV 注意全部大写，接口协议为 DHCP 客户端 包括接口 VLAN:eth0.3 。设置如下图。

然后设置端口的 请求 DHCP 时发送的主机名 对应的就是之前获取的 Option: (12) Host Name，以及高级设置里面的 请求 DHCP 时发送的 Vendor Class 选项 也就是之前获取的 Option: (60) Vendor class identifier 即 SCITV，最后是 重设 MAC 地址 填入 Client MAC address 也就是你 IPTV 盒子的 MAC 地址。

还有不要勾选 使用内置的 IPv6 管理，使用网关跃点为 20 。

保存并应用设置后，再进入你的 WAN 接口设置，将它的 网络跃点设置为 10，否则你会无法正常使用互联网。

进行到这里，你的 IPTV 接口应该就可以正常的获取到 10 开头的内网 IP 了。如果你不是四川的朋友，那么你地区的运营商可能是 PPPOE 验证或验证逻辑与我这里不同，如果你是四川的朋友，那么请你检查 之前抓包或者是在机顶盒上面看到的 Option: (12) Host Name 以及 Option: (60) Vendor class identifier 和 MAC 地址是否填写正确。如果你是通过抓包获取的数据，那应该不会有错，如果你是抄的机顶盒上面的，那么可能是因为你所在的地区与我的验证逻辑不同。

所以我强烈建议，还是通过抓包来分析 IPTV 盒子获得内网 IP 的全过程，因为不管你是 PPPOE 还是 DHCP 它都可以分析出来。

配置 igmpproxy 和 udpxy

使用 SSH 连接到路由器

修改配置文件时需要使用 SSH 连接到路由器进行修改，进入路由器设置 - 系统 - 管理权，在接口 lan 下设置端口为 22，同时打开 密码验证和允许 root 用户凭密码登录。

下载 Xshell https://www.netsarang.com/zh/free-for-home-school/ ，官网提供了免费的供家庭和学校使用的版本，足够本次教程所用。

新建连接，名称随意，主机填上路由器的 IP。点击左侧连接中的用户身份验证，将方法设置为 Password 用户名为 root 密码则为登录 Web 端后台时的密码，我提供的固件默认是 password。

安装 igmpproxy 和 udpxy

如果你的路由器使用的我提供的固件则无需安装，因为固件是自带该软件包的。

我建议在安装之前，在 Web 端后台的系统 - 备份/升级 中备份当前配置文件。因为我尝试了多个固件，在安装了 udpxy 后 Web 端就会无法正常使用，有很多报错。只有恢复到出厂设置才恢复正常。最后找到了一个自带 udpxy 的固件才解决我的问题。

使用 Xshell 连接到路由器后执行以下命令。

1

opkg update && opkg install igmpproxy udpxy luci-app-udpxy

opkg update 是用来更新软件列表的，因为大陆对 OpenWrt 软件源地址连通性不佳，所以可能需要等很久或者是多次尝试。

查看命令返回的结果或查看系统 - 软件包中的已安装软件包中是否存在 igmpproxy udpxy luci-app-udpxy 来判断是否安装成功。

配置 igmpproxy

关于 igmpproxy 它主要是将所有来自 lan 的 IGMP 数据都传到 IPTV 接口去，为了防止组播的 udp 数据在 lan 里面乱串，影响网络效率。但是我这里在 lan 里面是无法播放 igmp:// 地址的数据的，我也不清楚是什么情况。而且从 lede issues 可知 lede 的 igmpproxy 是失效的，如果有人在 lan 里面观看组播地址视频或者是使用 IPTV 盒子，都会导致局域网内的组播风暴，会导致网络堵塞。所以主要是后面的 udpxy 在起作用，你完全可以不配置 igmpproxy 使用 http 地址播放依然是可行的。

执行以下命令，一定要复制全一起粘贴进去然后再回车执行。

1
2
3
4
5
6
7
8
9
10
11
12

echo "config igmpproxy
option quickleave 1

config phyint
option network IPTV
option direction upstream
list altnet 0.0.0.0/0

config phyint
option network lan
option zone lan
option direction downstream" > /etc/config/igmpproxy

配置 udpxy

在路由器 Web 端设置 - 服务 - udpxy 中，勾选启动、Respawn、状态。将端口设置为 8888，将 Source IP/Interface 设置为 IPTV 接口的 ifname，也就是在路由器 Web 端设置 - 网络 - 接口 中 IPTV 接口图标下方的小字。在我这里为 eth0.3 。

如果你有多设备同时播放的需求，那么请根据情况设置 Max clients 选项的值，它可以控制同时播放的终端数，该值默认为 3 ，最大可为 5000 。

感谢 @xujuntc 的提醒。

udpxy 配置项介绍

在路由器设置的 Web 端不知为什么后面 4 个选项，保存时都说值有误。如果有需要修改的朋友，只有手动修改 /etc/config/udpxy 配置文件了。下面是我的配置，可供参考。

1
2
3
4
5
6
7
8
9

config udpxy
        option respawn '1'
        option verbose '0'
        option status '1'
        option disabled '0'
        option port '8888'
        option source 'eth0.3'
        option buffer_size '2097152'

保存并应用后，打开 http://路由器IP:8888/status 查看 udpxy 运行是否正常。当你在播放视频的时候，这个页面也会显示正在播放客户端的 IP 与它的实时流量。

然后你就可以在 PotPlayer 和 VLC media player 播放之前处理好的连接了，可以直接打开 M3U8 播放列表，也可以播放一个单独的地址。

例如你获取的地址为 igmp://239.93.22.6:6666

那么使用 udpxy 转换后的地址为 http://192.168.10.1:8888/udp/239.93.22.6:6666

如果你仍然无法播放，请将下面的防火墙规则添加进 /etc/config/firewall

如果你会使用 vim 那么直接在 Xshell 里面修改即可，如果你不会可以在 Xshell 窗口中点击 新建文本传输（Ctrl+Alt+F），将该文本下载到本地使用 notepad++ 进行修改，再上传上去。请注意你的防火墙配置可能已经存在，请你仔细的排查每一个设置项。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

config rule
        option name 'Allow-IGMP'
        option target 'ACCEPT'
        option family 'ipv4'
        option src 'iptv'
        option proto 'IGMP'

config rule
        option name 'Allow-UDP-udpxy'
        option target 'ACCEPT'
        option src 'iptv'
        option proto 'udp'
        option dest_ip '224.0.0.0/4'

config rule
        option name 'Allow-UDP-igmpproxy'
        option target 'ACCEPT'
        option family 'ipv4'
        option src 'iptv'
        option proto 'udp'
        option dest 'lan'
        option dest_ip '224.0.0.0/4'

最后，为了防止路由器断电后 udpxy 没有自动启动，还需要使用 hotplug 功能，在 IPTV 接口拨号成功后都检测 udpxy 是否正常工作，如果没有就启动一下 udpxy

在 Xshell 中使用 SSH 连接到路由器，新建脚本文件

1

vim /etc/hotplug.d/iface/100-udpxy

将以下内容全文粘贴进去

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/bin/sh

if [ "${INTERFACE}" = "IPTV" ]; then # IPTV status change
        if [ "${ACTION}" = "ifup" ]; then # Interface up
                flag=$(ps | grep udpxy | grep -v "grep" | wc -l)
                if [ $flag = "1"]; then
                        logger -t udpxy -s "udpxy Running"
                else
                        /etc/init.d/udpxy start
                fi
        fi
fi

然后使用 :wq 保存文件即可

如何在外播放家中 IPTV 源

首先需要公网 IP，你可以在 在路由器 Web 端设置 - 网络 - 接口中，查看 WAN 获得的 IP 是否与你在 https://ip.sb/ 看到的 IP 一致。如果不一致的话，可以向电信人工客服反映「我需要公网 IP」即可。

首先你需要在 udpxy 配置中将 Bind IP/Interface 配置为 0.0.0.0 。

在路由器 Web 端设置 - 网络 - 防火墙 - 端口转发 中，添加协议为 tcp，外部区域为 wan，外部端口为 8888，内部 IP 地址为 192.168.10.1，内部端口为 8888 的规则即可。

那么你在外要播放的话，只需要把路由器的 IP 地址换为你的公网 IP 即可。

例如你的本地播放地址为 http://192.168.10.1:8888/udp/239.93.22.6:6666

那么当你的公网 IP 为 125.60.90.40 时

你的互联网播放地址则为 http://125.60.90.40:8888/udp/239.93.22.6:6666

因为公网 IP 都在变，你可以使用 DDNS 也就是 动态 DNS 使用域名来访问，你可以使用路由器内自带的服务商。如果你和我一样将域名放置于 DNSPod 管理，也可以使用我制作的 DdnsWithDnspod 使用一个子域名来专供 IPTV 的播放。

结语

首先非常感谢各位前辈，我也是通过阅读现有的教程总结出来的。本文用了接近 5000 字，详细的介绍了有关 IPTV 与互联网的融合，希望能够对需要的朋友有帮助。因为本人能力有限，文中难免有一些问题也希望有发现的朋友能够及时的指出，我将感激不尽。

参考

GitHub@coolsnowwolf - Lean’s OpenWrt source

恩山无线论坛@鲲翔 - IPTV融合进普通网络一般步骤

恩山无线论坛@footlog - K2P/K2 padavan双线接入，宽带+IPTV，udpxy+xupnpd详细设置

恩山无线论坛@lcsuper - 小白的IPTV折腾教程(3)—双网融合、IPTV共享

恩山无线论坛@kangtao022 - 最新四川南充电信IPTV组播地址，及整理出地址列表的方法！

恩山无线论坛@橙子_MAX - 【附固件】全网首发，新三OpenWRT路由器IPTV内网融合视频教程

橙子的个人博客 - IPTV内网融合，实现任意设备观看IPTV

恩山无线论坛@angelkyo - 四川电信DHCP抓包能获取到IP，但是抓不到option60信息

恩山无线论坛@wengmingao - 简单的的IPTV 0成本抓包！

恩山无线论坛@莫问归期 - 在openwrt里安装udpxy后主题界面就会乱

恩山无线论坛@xtwz - OpenWrt 编译 LuCI -> Applications 添加插件应用说明-L大

恩山无线论坛@happyzhang - OpenWrt入门编译 make menuconfig配置参考说明与自动生成脚本

Github@MitchellJo - DdnsWithDnspod

恩山无线论坛@hayate - ppp拨号后自动运行脚本的问题

Demon’s Blog@Demon - OpenWrt中的Hotplug脚本

痞客邦@Kai-Cho - [OpenWRT] hotplug

恩山无线论坛@ghostry - hotplug的iface脚本不执行怎么办?

OpenWrt Documentation - Hotplug

OpenWrt Documentation - udpxy

3mile博客 - 编译UDPXY新版本

Github@xingsiyue - udpxy无法保存缓存大小等参数

Github@jow- - luci-app-udpxy bug

LVM 介绍

图片来自 Wikimedia Logical Volume Manager (Linux)

• PV：物理卷，PV处于LVM系统最低层，它可以是整个硬盘，或者与磁盘分区具有相同功能的设备（如RAID），但和基本的物理存储介质相比较，多了与LVM相关管理参数
• VG：卷组，创建在PV之上，由一个或多个PV组成，可以在VG上创建一个或多个“LVM分区”（逻辑卷），功能类似非LVM系统的物理硬盘
• LV：逻辑卷，从VG中分割出的一块空间，创建之后其大小可以伸缩，在LV上可以创建文件系统（如/var,/home）
• PE：物理区域，每一个PV被划分为基本单元（也被称为PE），具有唯一编号的PE是可以被LVM寻址的最小存储单元，默认为4MB

本次扩容就是将设备转换为物理卷，然后将其加入卷组，最后再将卷组的剩余空间划分给逻辑卷

安装硬盘

这一步没啥可说的了吧，直接把硬盘接上主板就行了

系统环境

这里我会将 /dev/sdc 划分进 all 卷组中以扩大它的可用容量

查询磁盘空间信息

1

df -H

1
2
3
4
5
6
7
8
9

Filesystem               Size  Used Avail Use% Mounted on
/dev/mapper/centos-root   54G  2.1G   52G   4% /
devtmpfs                 889M     0  889M   0% /dev
tmpfs                    902M     0  902M   0% /dev/shm
tmpfs                    902M   18M  884M   2% /run
tmpfs                    902M     0  902M   0% /sys/fs/cgroup
/dev/mapper/all-home     3.8T  3.6T  252G  94% /home
/dev/sdd1                1.1G  143M  811M  15% /boot
tmpfs                    181M     0  181M   0% /run/user/1000

查询物理卷信息

1

sudo pvs

1
2
3
4
5

PV         VG     Fmt  Attr PSize    PFree
/dev/sda1  all    lvm2 a--  <465.76g    0 
/dev/sdb1  all    lvm2 a--    <2.73t    0 
/dev/sdd2  all    lvm2 a--  <245.08g    0 
/dev/sdd3  centos lvm2 a--    52.00g 4.00m

查询硬盘分区表情况

1

sudo fdisk -l

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

Disk /dev/sdc: 500.1 GB, 500107862016 bytes, 976773168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk label type: dos
Disk identifier: 0x95fe95fe

   Device Boot      Start         End      Blocks   Id  System
/dev/sdc1   *        4096   976773119   488384512    7  HPFS/NTFS/exFAT

Disk /dev/sdd: 320.1 GB, 320072933376 bytes, 625142448 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk label type: dos
Disk identifier: 0x00084660

   Device Boot      Start         End      Blocks   Id  System
/dev/sdd1   *        2048     2099199     1048576   83  Linux
/dev/sdd2         2099200   516073471   256987136   8e  Linux LVM
/dev/sdd3       516073472   625141759    54534144   8e  Linux LVM
WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.

Disk /dev/sdb: 3000.6 GB, 3000592982016 bytes, 5860533168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk label type: gpt
Disk identifier: BDF3367A-EECA-4A93-BE0B-10D867E87AF1


#         Start          End    Size  Type            Name
 1         2048   5860532223    2.7T  Linux LVM       

Disk /dev/sda: 500.1 GB, 500107862016 bytes, 976773168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk label type: dos
Disk identifier: 0x000c3c53

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1            2048   976773119   488385536   8e  Linux LVM

Disk /dev/mapper/centos-root: 53.7 GB, 53687091200 bytes, 104857600 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes


Disk /dev/mapper/centos-swap: 2147 MB, 2147483648 bytes, 4194304 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes


Disk /dev/mapper/all-home: 3763.8 GB, 3763842580480 bytes, 7351255040 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

开始扩展

首先将 /dev/sdc1 转换为物理卷(PV)

1

sudo pvcreate /dev/sdc1 /dev/sde

1
2
3

WARNING: ext4 signature detected on /dev/sdc1 at offset 1080. Wipe it? [y/n]: y
  Wiping ext4 signature on /dev/sdc1.
  Physical volume "/dev/sdc1" successfully created.

查看物理卷(PV)信息

1

sudo pvs

1
2
3
4
5
6

PV         VG     Fmt  Attr PSize    PFree   
/dev/sda1  all    lvm2 a--  <465.76g       0 
/dev/sdb1  all    lvm2 a--    <2.73t       0 
/dev/sdc1         lvm2 ---  <465.76g <465.76g
/dev/sdd2  all    lvm2 a--  <245.08g       0 
/dev/sdd3  centos lvm2 a--    52.00g    4.00m

将物理卷加入卷组(VG) all

1

sudo vgextend all /dev/sdc1

1

Volume group "all" successfully extended

查看物理卷(PV)信息

1

sudo pvs

1
2
3
4
5
6

PV         VG     Fmt  Attr PSize    PFree   
/dev/sda1  all    lvm2 a--  <465.76g       0 
/dev/sdb1  all    lvm2 a--    <2.73t       0 
/dev/sdc1  all    lvm2 a--  <465.76g <465.76g
/dev/sdd2  all    lvm2 a--  <245.08g       0 
/dev/sdd3  centos lvm2 a--    52.00g    4.00m

查看逻辑卷(LV)信息

1

sudo lvs

1
2
3
4

LV   VG     Attr       LSize  Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
home all    -wi-ao----  3.42t                                                    
root centos -wi-ao---- 50.00g                                                    
swap centos -wi-ao----  2.00g  

看起来容量并没有变大，这是因为还需要将卷组中的空闲空间扩展到 /home 中

1

sudo lvextend -L +465.75g /dev/mapper/all-home

1
2

Size of logical volume all/home changed from 3.42 TiB (897370 extents) to <3.88 TiB (1016602 extents).
Logical volume all/home successfully resized.

查看逻辑卷信息(LV)，可以发现空间已经变大了

1

sudo lvs

1
2
3
4

LV   VG     Attr       LSize  Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
home all    -wi-ao---- <3.88t                                                    
root centos -wi-ao---- 50.00g                                                    
swap centos -wi-ao----  2.00g   

查看物理卷(PV)信息，可以发现物理卷的可用空间已经变小了

1

sudo pvs

1
2
3
4
5
6

PV         VG     Fmt  Attr PSize    PFree
/dev/sda1  all    lvm2 a--  <465.76g    0 
/dev/sdb1  all    lvm2 a--    <2.73t    0 
/dev/sdc1  all    lvm2 a--  <465.76g 8.00m
/dev/sdd2  all    lvm2 a--  <245.08g    0 
/dev/sdd3  centos lvm2 a--    52.00g 4.00m

使扩容生效 xfs_groufs 针对 xfs文件系统

1
2

mount
sudo xfs_growfs /dev/mapper/all-home

查看剩余空间信息

1

df -h

1
2
3
4
5
6
7
8
9

Filesystem               Size  Used Avail Use% Mounted on
/dev/mapper/centos-root   50G  2.0G   49G   4% /
devtmpfs                 848M     0  848M   0% /dev
tmpfs                    860M     0  860M   0% /dev/shm
tmpfs                    860M   17M  843M   2% /run
tmpfs                    860M     0  860M   0% /sys/fs/cgroup
/dev/mapper/all-home     3.9T  3.2T  701G  83% /home
/dev/sdd1                976M  136M  774M  15% /boot
tmpfs                    172M     0  172M   0% /run/user/1000

/home 空间变大了0.4T,扩容成功

参考

https://blog.csdn.net/yaofengyaofeng/article/details/82353282

https://blog.csdn.net/u012439646/article/details/73380197

http://lzw.me/a/linux-lvm.html

https://blog.csdn.net/youjin/article/details/79137203

https://blog.csdn.net/qq_27281257/article/details/81603410

https://blog.csdn.net/weixin_42350212/article/details/80570211

项目介绍

这次开发的是一个公交的实时位置查询工具，当时的灵感来自我使用 APP 的时候。因为坐车这个事儿，其实每天也就是坐那几条线不会有太多变化，但是那 APP 每次都需要手动输入线路点击一下查询。而且 APP 的冷启动速度那也是相当的感人，从点击到出现首页广告都需要 4s 左右。然后就想自己来试试能不能解决这个问题，用抓包软件看了看这软件也是从 API 获取信息，而且调用 API 也没有经过鉴权传入的参数也都是固定的几个。

本来在这之前，一直都想体验一下 微信小程序 的开发。因为我平时在使用的时候，给我的体验还是挺不错的。启动速度也不赖，而且不用单独的下载其他 APP 。还可以轻松的做到跨平台，对于轻度的工具类应用来说，这个平台看起来是那么的美好。在加上和友人在聊天的时候，也说到了现在的 APP 对于普通人来说确实太「重」了，所以也就更加坚定了这次开发要使用微信小程序。

可行性分析

首先分析抓包的数据，它到底需要传给它什么信息，同时又会传回什么数据。简单的用 Postman 试了试，发现所有的 API 传入的数据都只有 3 个。

• 线路唯一标识
• 上下行状态
• 城市代码

用 Python 的 requests 简单的尝试了一下，数据还是挺好抓取下来的。然后就开始咸鱼了十几天，等到7月15号的时候才开始认认真真的开始写代码。

网络请求

微信小程序的网络请求这方面，都是有提供 API 可以直接调用。我这里因为是第一次用 JavaScript 所以还是淌了不少浑水。

刚开始的时候最困惑我的就是，它不能二次调用经过传值了一次的 request Object。因为公交查询 API 这里，它的站点信息和车辆当前的运行状态是两个单独的，虽然车辆当前运行状态也有站台的标识，但是我做不到把他们关联起来。所以我在二次调用的时候，总是会提示错误。

1
2

Cannot read property 'xxx' of undefined;at api request success callback function
TypeError: Cannot read property 'xxx' of undefined

真的让人挺头疼的，到了后面我还是使用的全局变量解决这个问题了的。每次都把获取到的数据放进全局变量，然后其他 function 在调用的时候也直接从全局变量里面取值。每次从全局变量里面取值都还挺讲究，每次都要写 this.data.xxx 。不知道这是 JavaScript 在作妖，还是微信小程序在作妖。用不同的名字区分不好吗，非要弄个 this 怪怪的。

逻辑层

做逻辑层的前端数据展示花了挺多时间，对于静态数据的处理还是可以轻松的应对。但是一方面自己又懒，不想为每个线路都写一个不同的页面去做展示（后面想想好恐怖，这样搞的话不知道冗余的代码量得有多少），后面还是使用微信提供的 API 来解决这个问题。也就是给点击这个方法传参，然后将参数拼接成带有完整数据的 url 在交给线路查询页进行显示。

还有点击切换按钮切换线路上下行的时候，我也是发现 API 有一些怪怪的问题。有个别环线它的起点和终点是一摸一样的，所以切换线路的时候不只是上下行这个值有变化，同时线路的唯一标识也在变化，当然线路的名字也有变化，名字一般都是 A和B 来回切换。而且我发现，官方 APP 这个地方他也没作对，它对于环线是不能切换的，估计也是切换的时候单纯的切换了一下上下行状态。这大概就是前端和后端不打好招呼的后果？

界面层

界面的数据写法和我以前接触的 Jinja2 特别相似，不过我接触 Jinja2 的时候也只是和 ECharts 配合做了一些简单的数据展示。做这个公交线路的显示的前端，代码量倒是非常的小，但真的是每一行都是比较费脑子的感觉。大概也是我对某些地方有着莫名的偏执，所以带来了这些麻烦。

也就比如在线路查询页的地方，我就必须想让公交车的图标要和站点名字处在同一行上，而且站点名字必须要在页面接近居中的文字左对齐。当时我在写这个页面的时候，一开始是使用的 条件渲染 也看这个站点有没有车，如果有就显示没有就不显示。使用这个方法就会导致，有公交车的和没公交车的站点名字他们的缩进是不一样的。然后我就很魔性的想到了使用控制透明度来解决这个问题，每个位置上默认都是要显示图标的，但是会根据这个位置有没有车然后改变透明度。刚刚想到这个方法的时候，都在想为什么我这么聪明233。

后面还有个问题，就是有的站点他会有停很多车，一般都是在收车的时候，始发站就会停很多车。车多了的话，界面显示会抽风。一开始是想直接吧车辆直接 for 开始，然后一个一个的判断 >5、<=5 、=0 这种情况，但是写半天都不会。因为这个也没法设断点，看 Debug 信息它到底现在循环到了多少之类的。所以就直接在 js 里面吧数据处理了，吧站点当前停留的车辆 >5 的全部都只显示 5 。

还有问题个问题就是，微信小程序官方的 开发者工具 在显示图标的时候对大小写不敏感。但是在真实设备上，对大小写是敏感的。我一开始调试的时候，车辆图标用的 Bus.png 开发工具上模拟一直没问题，就是到了真机死活显示不出来。最后检查出来是这个问题，挺福气的。而且 Git 也很奇怪，我改了个大小写他都显示我没有任何变动。最后是我强行改了个别的名字，打了个 commit 再改回小写。

后端

后端的开发这次倒是没什么技术，就只是单纯的吧数据转发过去然后把拿回来的数据返回过去。因为微信小程序官方不允许使用 http 协议，所以我就只能使用服务器去代理转发流量。官方什么时候要是把我服务器的 IP ban 了那就麻烦了。

总结

最深的感觉还是在开发的时候，因为官方文档都是中文所以查文档还是方便不少。但是搜索一些怪怪的问题的时候，反而用 Google 搜不出来太好的结果，还得要用百度在 CSDN 里面的一大堆重复文章中去找解决方法。

后面看看有没有时间再完善一下，增加个根据当前位置判断车还有多久到底最近站点的功能。

环境介绍

软件版本如下：

目标

• 完成 Standalone 集群搭建
• 在 YARN 上运行 Spark
• 在 Mesos 上运行 Spark

基础环境配置

参考 Hadoop HA 搭建 目前已完成 Hadoop/ZooKeeper 环境搭建

下载解压

1
2
3

curl -O http://archive.apache.org/dist/spark/spark-2.0.0/spark-2.0.0-bin-hadoop2.6.tgz
tar xf spark-2.0.0-bin-hadoop2.6.tgz -C /usr/local/src/
mv /usr/local/src/spark-2.0.0-bin-hadoop2.6 /usr/local/src/spark

Standalone Mode

使用这种模式搭建，不需要借助其他外部工具(高可用性需要 ZooKeeper)

手动启动集群

先搭建一个最简单的

不需要修改任何配置，直接启动即可。

1
2
3

# master
cd /usr/local/src/spark/sbin
./start-master.sh

用浏览器打开的 Web UI 看看 http://master:8080/

其中的 URL 是让其他的 Workers 连接到 master 的重要参数

将程序传到另外两台机子上

1
2

scp -r /usr/local/src/spark slave1:/usr/local/src/
scp -r /usr/local/src/spark slave2:/usr/local/src/

接下来在另外两台机子上启动 workers 并连接到 master

1
2
3

# 两台机子都要运行
cd /usr/local/src/spark/sbin
./start-slave.sh spark://master:7077

如图出现了两个 Worker 且 State 处于 ALIVE 搭建完毕

脚本启动集群

首先将之前启动的服务都手动关掉

1
2

# master
./stop-master.sh

1
2

# 两个 slave 都需要关闭
./stop-slave.sh

将默认的配置文件改名为正式使用

1
2
3

cd /usr/local/src/spark/conf/
cp spark-env.sh.template spark-env.sh
cp slaves.template slaves

修改 slaves 文件删掉里面的所有内容写入以下内容

1
2

slave1
slave2

修改 spark-env.sh 文件指定 master，写入以下内容

1
2

SPARK_MASTER_HOST=master
JAVA_HOME=/usr/local/src/jdk1.8.0_211

如果不写 JAVA_HOME 的话，在启动 slave 的时候会报 JAVA_HOME is not set 估计是因为我的 JAVA_HOME 设置的仅对 root 生效的原因吧

将配置文件同步给另外两台机子

1
2

scp -r /usr/local/src/spark/conf/ slave1:/usr/local/src/spark/
scp -r /usr/local/src/spark/conf/ slave2:/usr/local/src/spark/

在 master 上面启动 master 和 slaves

1
2
3

cd /usr/local/src/spark/sbin/
./start-master.sh
./start-slaves.sh

启动成功后浏览器打开 http://master:8080/ 看看，应该和上面的图片是一样的

下面的命令可以关闭

1
2

./stop-master.sh
./stop-slaves.sh

高可用

编辑配置文件

1

vi /usr/local/src/spark/conf/spark-env.sh

在配置文件中新增以下内容

1

SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=master:2181,slave1:2181,slave2:2181 -Dspark.deploy.zookeeper.dir=/sparkha"

注意如果你之前添加了 SPARK_MASTER_HOST=master 要删掉，因为 master 的任命被 ZooKeeper 接管了这个配置没用了

将配置同步到另外两台机器上

1
2

scp -r /usr/local/src/spark/conf/ slave1:/usr/local/src/spark/
scp -r /usr/local/src/spark/conf/ slave2:/usr/local/src/spark/

启动 ZooKeeper，如果你还没有配置可以参考这篇文章Hadoop HA 配置 - ZooKeeper 配置

1
2

# 每台机子都要启动
zkServer.sh start

在 mastrt 上启动 master 和 slaves

1
2

./start-master.sh
./start-slaves.sh

在 slave1 上启动 备用 master

1

./start-master.sh

参考

Apache Kafka

Kafka 中文文档

博客园@Mr.心弦 - Kafka【第一篇】Kafka集群搭建

CSDN@运维白菜鹏 - kafka搭建入门（手把手教你搭建）

CSDN@360linker - kafka如何彻底删除topic及数据

环境介绍

软件版本如下：

目标

• 正确启动 Storm
• 有冗余

基础环境配置

参考 Hadoop HA 搭建 目前已完成 ZooKeeper 环境搭建

zoo.cfg

zoo.cfg 配置如下

1
2
3
4
5
6
7
8
9
10
11

tickTime=2000
initLimit=10
syncLimit=5

dataDir=/usr/local/src/zookeeper-3.4.5/data
dataLogDir=/usr/local/src/zookeeper-3.4.5/logs

clientPort=2181
server.1=master:2888:3888
server.2=slave1:2888:3888
server.3=slave2:2888:3888

启动 ZooKeeper

在每台主机上都要执行该命令

1

zkServer.sh start

执行完毕后查看他们的运行状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[root@master ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

[root@slave1 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: leader

[root@slave2 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

当有一台主机处于 leader 状态，其他的都处于 follower 时即启动成功

下载解压

1
2
3

curl -O https://archive.apache.org/dist/storm/apache-storm-1.0.4/apache-storm-1.0.4.tar.gz
tar xf apache-storm-1.0.4.tar.gz -C /usr/local/src/
mv /usr/local/src/apache-storm-1.0.4 /usr/local/src/kafka

配置

Storm 的配置还是挺简单的，因为配置文件就只有一个

1

vi /usr/local/src/storm/conf/storm.yaml

修改配置文件如下

1
2
3
4
5
6
7
8
9
10
11
12

storm.zookeeper.servers:
     - "master"
     - "slave1"
     - "slave2"

nimbus.seeds: ["master", "slave1"]

supervisor.slots.ports:
    - 6700
    - 6701
    - 6702
    - 6703

需要留意下 yaml 配置文件的格式，和我之前经常见的 json 和 xml 不太一样。不过因为 hexo 配置文件也是用的这个格式，所以感觉还行

运行

在 master 上执行

1
2
3

cd /usr/local/src/kafka
./storm nimbus &
./storm ui

在 slave1 上执行

1

./storm nimbus &

在 slave2 上执行

1

./storm supervisor &

因为这个程序在运行的时候不会在控制台显示 Log 还不会自动到后台去，就后面加个 & 让它到后台去运行了，也可以使用 ctrl z 吧它放到后台去。使用 fg 可以把它拉到前台，当后台有多个任务的时候用 jobs 看看有哪些程序，然后用 fg id 把它拉起就行了。

参考

Storm 1.0.6 Documentation

CSDN@奔跑-起点 - storm1.x支持主节点nimbus高可用 多master集群部署

CSDN@Lnho - CentOS下Storm 1.0.0集群安装详解

环境介绍

软件版本如下：

目标

• 正确启动 Kafka
• 完成 生产者(producer) 配置
• 完成 消费者(consumer) 配置

基础环境配置

参考 Hadoop HA 搭建 目前已完成 ZooKeeper 环境搭建

zoo.cfg

zoo.cfg 配置如下

1
2
3
4
5
6
7
8
9
10
11

tickTime=2000
initLimit=10
syncLimit=5

dataDir=/usr/local/src/zookeeper-3.4.5/data
dataLogDir=/usr/local/src/zookeeper-3.4.5/logs

clientPort=2181
server.1=master:2888:3888
server.2=slave1:2888:3888
server.3=slave2:2888:3888

启动 ZooKeeper

在每台主机上都要执行该命令

1

zkServer.sh start

执行完毕后查看他们的运行状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[root@master ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

[root@slave1 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: leader

[root@slave2 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

当有一台主机处于 leader 状态，其他的都处于 follower 时即启动成功

下载解压

1
2
3

curl -O http://archive.apache.org/dist/kafka/1.0.0/kafka_2.11-1.0.0.tgz
tar xf kafka_2.11-1.0.0.tgz -C /usr/local/src/
mv /usr/local/src/kafka_2.11-1.0.0 /usr/local/src/kafka

配置

这里我直接就使用我自己，已经安装好的 ZooKeeper 作为服务端不使用 Kafka 自带的 ZooKeeper ，如果你需要使用自带的可以参考以下文档:

Kafka Quickstart English

Kafka Quickstart 中文文档

编写配置文件

新建 master 配置文件

1

vi /usr/local/src/kafka/config/server-1.properties

写入以下内容

1
2
3
4

broker.id=1
listeners=PLAINTEXT://master:9093
log.dir=/root/kafka/logs
zookeeper.connect=master:2181,slave1:2181,slave2:2181

新建 slave1 配置文件

1

vi /usr/local/src/kafka/config/server-2.properties

写入以下内容

1
2
3
4

broker.id=2
listeners=PLAINTEXT://slave1:9093
log.dir=/root/kafka/logs-2
zookeeper.connect=master:2181,slave1:2181,slave2:2181

新建 slave2 配置文件

1

vi /usr/local/src/kafka/config/server-3.properties

写入以下内容

1
2
3
4

broker.id=3
listeners=PLAINTEXT://slave2:9093
log.dir=/root/kafka/logs-3
zookeeper.connect=master:2181,slave1:2181,slave2:2181

同步配置

将程序和配置分发到所有主机上

1
2

scp /usr/local/src/kafka slave1:/usr/local/src/
scp /usr/local/src/kafka slave2:/usr/local/src/

设置环境变量

1

vi ~/.bash_profile

在文件底部新增以下内容

1
2

export KAFKA_HOME=/usr/local/src/kafka
PATH=$PATH:$KAFKA_HOME/bin

使其生效

1

source ~/.bash_profile

运行

在 master 上执行

1

kafka-server-start.sh /usr/local/src/kafka/config/server-1.properties

在 slave1 上执行

1

kafka-server-start.sh /usr/local/src/kafka/config/server-2.properties

在 slave2 上执行

1

kafka-server-start.sh /usr/local/src/kafka/config/server-3.properties

出现类似以下输出内容说明启动成功了

1

[2019-06-04 19:18:04,467] INFO [KafkaServer id=1] started (kafka.server.KafkaServer)

创建Topic

在一个新的窗口打开 master 的 shell 执行

1

kafka-topics.sh --create --zookeeper master:2181 --replication-factor 2 --partitions 1 --topic my-replicated-topic

–replication-factor 2 #复制两份
–partitions 1 #创建1个分区
–topic #主题为my-replicated-topic

查看所有 topic

1

kafka-topics.sh --list --zookeeper master:12181

应输出

1

my-replicated-topic

查看 my-replicated-topic 详细信息

1

kafka-topics.sh --describe --zookeeper master:2181 --topic my-replicated-topic

应输出

1
2

Topic:my-replicated-topicPartitionCount:1ReplicationFactor:2Configs:
Topic: my-replicated-topicPartition: 0Leader: 2Replicas: 2,3Isr: 2,3

• “leader”是负责给定分区所有读写操作的节点。每个节点都是随机选择的部分分区的领导者。
• “replicas”是复制分区日志的节点列表，不管这些节点是leader还是仅仅活着。
• “isr”是一组“同步”replicas，是replicas列表的子集，它活着并被指到leader。

不知到为啥有两个 Leader ，而且看起来 master 好像离线了一样。感觉应该是我设置 --replication-factor 2 导致的,也可以能是我刚刚调试的时候没有把这个 topic 删干净导致的

生产者&消费者

在 master 上面执行

1

kafka-console-producer.sh --broker-list master:9093 --topic my-replicated-topic

输入任意字符

在 slave2 上面执行

1

kafka-console-consumer.sh --bootstrap-server master:9093 --from-beginning --topic my-replicated-topic

看到消息同步出现，即成功。

参考

Apache Kafka

Kafka 中文文档

博客园@Mr.心弦 - Kafka【第一篇】Kafka集群搭建

CSDN@运维白菜鹏 - kafka搭建入门（手把手教你搭建）

CSDN@360linker - kafka如何彻底删除topic及数据

环境介绍

软件版本如下：

关于版本的问题，我这里使用的环境并不是官方推荐的组合。在官方文档上面有关 Hadoop 不同版本与 HBase 的兼容性有介绍，可以看这里

在 Hadoop 2.6.x 中的 Hadoop 2.6.0 版本下运行 HBase 可能会导致集群故障和数据丢失，请使用 Hadoop 2.6.1+ 版本

目标

• 完成 HBase 单机模式配置
• 完成 HBase 分布模式配置
• HBase 数据的导出/导入

基础环境配置

参考 Hadoop HA 搭建 目前已完成 Hadoop HA 环境搭建

| HostName | Function | IP |
| — | — | — | — |
| master | DataNode/NameNode/ResourceManager | 192.168.66.128 |
| slave1 | DataNode/NameNode/JobHistoryServer | 192.168.66.129 |
| slave2 | DataNode/ResourceManager | 192.168.66.130 |

下载解压

首先下载，解压 HBase

1
2

curl -O http://archive.apache.org/dist/hbase/1.2.0/hbase-1.2.0-bin.tar.gz
tar xf hbase-1.2.0-bin.tar.gz -C /usr/local/src/

系统环境变量

配置 HBase 环境变量，只对当前用户生效

1

vi ~/.bash_profile

添加以下内容

1
2

export HBASE_HOME=/usr/local/src/hbase-1.2.0
PATH=$PATH:$HBASE_HOME/bin

使其生效

1

source ~/.bash_profile

测试是否配置成功

1

hbase version

输出以下信息说明配置成功

1
2
3
4

HBase 1.2.0
Source code repository git://asf-dev/home/busbey/projects/hbase revision=25b281972df2f5b15c426c8963cbf77dd853a5ad
Compiled by busbey on Thu Feb 18 23:01:49 CST 2016
From source with checksum bcb25b7506ecf5d62c79d8f7193c829b

hbase-env

把 JAVA_HOME 写进 HBase 环境变量

1

vi /usr/local/src/hbase-1.2.0/conf/hbase-env.sh

添加以下内容

1

export /usr/local/src/jdk1.8.0_211/

单机模式

hbase-site.xml单机模式

打开主配置文件

1

vi /usr/local/src/hbase-1.2.0/conf/hbase-site.xml

将光标放在第一行，输入以下命令清空配置文件

1

:.,$d

写入以下内容,配置来自 HBase Doc v1.2

1
2
3
4
5
6
7
8
9
10
11
12

<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>file:///root/standalone/hbase</value>
    <!-- 设置储存目录 -->
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/root/standalone/zookeeper</value>
    <!-- ZooKeeper目录 -->
  </property>
</configuration>

运行单机模式

1

start-hbase.sh

查看进程是否在运行

1
2
3

[root@master ~]# jps
10082 HMaster
10346 Jps

到这里单机模式就配置完成了

分布式模式

hbase-site.xml分布式模式

1

vi /usr/local/src/hbase-1.2.0/conf/hbase-site.xml

将光标放在第一行，输入以下命令清空配置文件

1

:.,$d

写入以下内容,配置来自 HBase Doc v1.2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
  <property>
    <name>hbase.zookeeper.quorum</name>
    <value>master,slave1,slave2</value>
    <!-- 集群主机的 hostname -->
    <description>The directory shared by RegionServers.
    </description>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/export/zookeeper</value>
    <description>Property from ZooKeeper config zoo.cfg.
    The directory where the snapshot is stored.
    </description>
  </property>
  <property>
    <name>hbase.rootdir</name>
    <value>hdfs://nscluster:8020/hbase</value>
    <!-- 注意这里要和你 Hadoop hdfs-site.xml 配置中的 fs.defaultFS 设置相同 -->
    <description>The directory shared by RegionServers.
    </description>
  </property>
  <property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
    <description>The mode the cluster will be in. Possible values are
      false: standalone and pseudo-distributed setups with managed Zookeeper
      true: fully-distributed with unmanaged Zookeeper Quorum (see hbase-env.sh)
    </description>
  </property>
</configuration>

regionservers

修改集群节点信息配置文件

1

vi /usr/local/src/hbase-1.2.0/conf/regionservers

清空所有内容，写入以下内容

1
2
3

master
slave1
slave2

拷贝Hadoop配置

因为我 Hadoop 使用了 ZooKeeper 高可用模式， HBase 在没有 Hadoop 配置的情况下会找不到 HDFS 的地址。所以需要将配置拷贝到它的目录。

1
2

cp $HADOOP_HOME/etc/hadoop/core-site.xml $HBASE_HOME/conf/
cp $HADOOP_HOME/etc/hadoop/hdfs-site.xml $HBASE_HOME/conf/

集群同步配置

将配置文件同步到集群中的其他机器中去

1
2

scp -r /usr/local/src/hbase-1.2.0 slave1:/usr/local/src/
scp -r /usr/local/src/hbase-1.2.0 slave2:/usr/local/src/

参考 HBase配置-系统环境变量 在其他机器中也设置好系统环境变量

运行分布式模式

在运行之前要先启动 Hadoop ，启动 Hadoop 的命令根据你自己的环境而定

1

start-hbase.sh

使用 jps 查看正在运行的进程是否存在 HMaster 和 HRegionServer

1
2
3
4
5
6
7
8
9
10
11

[root@master ~]# jps
11538 HMaster
10692 DataNode
10884 NodeManager
10517 JournalNode
11221 DFSZKFailoverController
12008 Jps
11657 HRegionServer
10795 ResourceManager
10446 QuorumPeerMain
10574 NameNode

WEB端

http://master:16010

HBase Shell

启动 HBase Shell

1

hbase shell

如果出现以下报错

1
2
3
4
5

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/local/src/hbase-1.2.0/lib/slf4j-log4j12-1.7.5.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/local/hadoop-2.6.0/share/hadoop/common/lib/slf4j-log4j12-1.7.5.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]

是因为 HBase 自带的 Jar 包和 Hadoop 的包有冲突，删除冲突包即可

接下来开始创建 数据库/表 插入数据。注意，创建表的时候如果不指定数据库，表就会被放进 default 表中

表结构如下:

1
2
3

create_namespace 'test' --创建数据库
create 'test:emp', 'inside', 'outside' --在test库中创建emp表
list_namespace_tables 'test' --查看test中的表

1
2
3

TABLE
emp
1 row(s) in 0.0130 seconds

查看表结构

1

desc 'test:emp'

1
2
3
4
5
6

Table test:emp is ENABLED
test:emp
COLUMN FAMILIES DESCRIPTION
{NAME => 'inside', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'}
{NAME => 'outside', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'}
2 row(s) in 0.0410 seconds

插入数据

1
2
3
4
5
6
7
8

put 'test:emp', '1', 'inside:name', 'tom'
put 'test:emp', '1', 'inside:age', '3'
put 'test:emp', '1', 'outside:slang', 'cat'
put 'test:emp', '1', 'outside:zh', 'mao'
put 'test:emp', '2', 'inside:name', 'jerry'
put 'test:emp', '2', 'inside:age', '2'
put 'test:emp', '2', 'outside:slang', 'rat'
put 'test:emp', '2', 'outside:zh', 'laoshu'

扫描表

1

scan 'test:emp'

1
2
3
4
5
6
7
8
9
10
11

ROW    COLUMN+CELL

 1     column=inside:age, timestamp=1559458876365, value=3
 1     column=inside:name, timestamp=1559458822328, value=tom
 1     column=outside:slang, timestamp=1559459016767, value=cat
 1     column=outside:zh, timestamp=1559459100544, value=mao
 2     column=inside:age, timestamp=1559459253516, value=2
 2     column=inside:name, timestamp=1559459242949, value=jerry
 2     column=outside:slang, timestamp=1559459336624, value=rat
 2     column=outside:zh, timestamp=1559459347676, value=laoshu
2 row(s) in 0.0190 seconds

删除表数据之前要先禁用

1
2

disable 'test:emp' --禁用表
drop 'test:emp' --删除表(先别删,后面导出了再删)

退出 HBase Shell

1

quit

导入导出数据

使用 HBase 自带的类 导出 二进制格式文件

如果不加 file:// 就会导出到 HDFS 上面去，如果带了数据库名一定要加 '' 不然导出的数据是空白。

1
2

hbase org.apache.hadoop.hbase.mapreduce.Export `test:emp` file:///root/emp_out
ls /root/emp_out/

1

part-m-00000  _SUCCESS

之前导出文件后一直找不到,结果是因为我启用的 Hadoop HA 把这个任务分配给了别的机器，所以不在 master 上面。上 http://master:8088 看看也能知道是谁在运行。

删除表，为导入数据做准备

1

hbase shell

1
2
3
4

disable 'test:emp' --禁用表
drop 'test:emp' --删除表
create 'test:emp', 'inside', 'outside' --新建表(没有同名表无法导入数据)
quit

导入之前导出的数据

注意你的 MapReduce 任务会被分配到那台机器上运行，文件要放对位置。

1

hbase org.apache.hadoop.hbase.mapreduce.Import `test:emp` file:///root/emp_out

参考

Apache HBase ™ Reference Guide Version 1.2.12

CSDN@奔跑的豆子_ - HBase-单机模式安装

博客园@huanlegu0426 - hadoop2.5.1+hbase1.1.2安装与配置

CSDN@jjshouji - hbase 1.2.6 安装

CSDN@疯子. - 大数据系列之数据库Hbase知识整理（三）Hbase的表结构，基本操作，元数据表meta

易白教程@张新发 - HBase教程

Stack Overflow@Nanda - How to import/export hbase data via hdfs (hadoop commands)

简书@冯宇Ops - HBase入坑须知(一)

CSDN@芙兰泣露 - hbase导入导出数据

CSDN@Data_IT_Farmer - Hbase表两种数据备份方法-导入和导出示例

CSDN@weixin_4065234 - Hbase数据库的常用操作命令

CSDN@niugeblog - hbase 命令详解之namespace与table

3NICE - 解决在Markdown中的表格单元格合并的问题

环境介绍

本次搭建的目标为，搭建 3 个 DataNode ，2个 NameNode ，2个 yarn 。并让两个 NameNode 做到能够异常自动切换， yarn 也同理。如下表：

软件版本如下：

本文不会介绍理论性的东西，更多关于 ZooKeeper 和 Hadoop HA 定义相关的信息可以参考这个文章 SegmentFault@Snailclimb - 可能是全网把 ZooKeeper 概念讲的最清楚的一篇文章

基础环境配置

参考 Hadoop 伪分布部署 和 Hadoop 完全分布部署 吧，这里不再多说。在开始配置之前吧所有相关服务都停止了再继续。

ZooKeeper 配置

首先下载，解压 ZooKeeper

1
2
3

curl -O http://archive.apache.org/dist/zookeeper/zookeeper-3.4.5/zookeeper-3.4.5.tar.gz
tar xf zookeeper-3.4.5.tar.gz -C /usr/local/src/
vi ~/.bash_profile

在文本中添加以下内容

1
2

export ZOOKEEPER_HOME=/usr/local/src/zookeeper-3.4.5
PATH=$PATH:$ZOOKEEPER_HOME/bin

更新使其生效

1

source ~/.bash_profile

编辑 ZooKeeper 配置文件

1
2

cp /usr/local/src/zookeeper-3.4.5/conf/zoo_sample.cfg /usr/local/src/zookeeper-3.4.5/conf/zoo.cfg
vi /usr/local/src/zookeeper-3.4.5/conf/zoo.cfg

修改后如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial 
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between 
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just 
# example sakes.
dataDir=/usr/local/src/zookeeper-3.4.5/data
dataLogDir=/usr/local/src/zookeeper-3.4.5/logs
# the port at which the clients will connect
clientPort=2181

server.1=master:2888:3888
server.2=slave1:2888:3888
server.3=slave2:2888:3888

#
# Be sure to read the maintenance section of the 
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
# The number of snapshots to retain in dataDir
#autopurge.snapRetainCount=3
# Purge task interval in hours
# Set to "0" to disable auto purge feature
#autopurge.purgeInterval=1

注意这里的 dataDir 不要放在 /tmp 或 $HADOOP_HOME/tmp 里面去，因为这两个目录都不能长久的保存数据，而 ZooKeeper 需要数据被长期保存。请注意，这里的配置需要在另外两台机子(slave1/slave2)上做同样的配置。可以直接使用 scp 传过去，然后手动配置 ~/.bash_profile ，同时还需要手动创建一下文件夹。

1
2
3

# 在 master
scp -r /usr/local/src/zookeeper-3.4.5 slave1:/usr/local/src/
scp -r /usr/local/src/zookeeper-3.4.5 slave2:/usr/local/src/

1
2
3

# 每台机子都需要
mkdir /usr/local/src/zookeeper-3.4.5/logs
mkdir /usr/local/src/zookeeper-3.4.5/data

1
2
3
4

# 接下来在每台机子上都建立 myid 文件,并分别写入数字 1、2、3
[root@master ~]# echo 1 > /usr/local/src/zookeeper-3.4.5/data/myid
[root@slave1 ~]# echo 2 > /usr/local/src/zookeeper-3.4.5/data/myid
[root@slave2 ~]# echo 3 > /usr/local/src/zookeeper-3.4.5/data/myid

接下来每台机子上都启动一下同时查看运行是否正常。

1
2

zkServer.sh start
zkServer.sh status

如下有服务器进入了 leader 或 follower 模式即为启动成功

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[root@master ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

[root@slave1 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: leader

[root@slave2 ~]# zkServer.sh status
JMX enabled by default
Using config: /usr/local/src/zookeeper-3.4.5/bin/../conf/zoo.cfg
Mode: follower

Hadoop HA 配置

core-site.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>

<!--指定nameservice的名称，自定义，但后面必须保持一致-->
<property>
 <name>fs.defaultFS</name>
 <value>hdfs://nscluster</value>
</property>

<property>
 <name>hadoop.tmp.dir</name>
 <value>/root/hadoop/tmp</value>
</property>

<!-- ZooKeeper服务器地址列表 -->
<property>
 <name>ha.zookeeper.quorum</name>
 <value>master:2181,slave1:2181,slave2:2181</value>
</property>

<!-- 主备NameNode切换时使用ssh登录上去杀掉进程 -->
<property>
 <name>dfs.ha.fencing.methods</name>
 <value>sshfence</value>
</property>

<!-- 指定ssh的密钥 -->
<property>
 <name>dfs.ha.fencing.ssh.private-key-files</name>
 <value>/root/.ssh/id_rsa</value>
</property>

</configuration>

hdfs-site.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79