kirito の site

9.raft共识性算法-Part.1

2026-03-17T14:23:00.000Z

raft共识性算法-Part.1

最近在做 MIT 6.824 的 lab，其中 lab3 要求我们基于给出的代码框架，实现自己的 raft 算法。做该 lab 的时候遇到了不少困难，这是一个相当有趣又充满挑战的任务，有些地方必须要反复阅读论文并揣摩其中的意思才能理解。

如果你也在做这个 lab，不建议用 AI 逃课，论文中的 Part5 是必须要读的，否则实现代码的时候思路会很混乱。

论文连接：https://raft.github.io/raft.pdf

本篇文章主要聚焦于论文的第五部分，也就是 raft 算法的核心实现部分给出个人的理解。

The Raft consensus algorithm 核心总结

这张图（原文 Figure2）简明地总结了该算法，也是全文最重要的部分。总结为下面的文字部分：

State

所有服务器上的持久化状态（在响应 RPC 之前就更新到稳定存储）：

currentTerm：服务器看到的最新 term（初始为0，之后单调递增）
voteFor：在当前term下，服务器把票投给了谁？candidateId
log[]：log entries；其中每个 log entry 包括 - command（要发给状态机的命令）、term（leader 收到 log entry 时的 term）

所有服务器上的易变状态：

commitIndex：提交过的 log entry 的最高索引 index（commit 标识着共识，committed log entry 最终会被执行）
lastApplied：已应用于状态机的 log entry 的最高索引 index（apply 表示真正执行了）

leader 上的易变状态（选举后重置）：

nextIndex[]：对每个服务器 i，nextIndex[i] 是下一个应该发送到该服务器的 log entry 的索引 index
matchIndex[]：对每个服务器 i，matchIndex[i] 是已在该服务器上复制过的 log entry 的最高索引 index（初始为0，之后单调递增）

RequestVote RPC（candidate 用它来请求其他 server 投票）

Arguments：

term：candidate 的 term
candidateId
lastLogIndex：candidate 的最新 log entry 的索引 index
lastLogTerm：candidate 的最新 log entry 的 term

Results：

term：currentTerm，用于 candidate 发现自己可能不是最新的，更新自己
voteGranted：bool，是否收到该服务器的票

接收方需要实现：

如果 term < currentTerm，返回 false
如果 voteFor == null or voteFor == candidateId，并且 candidate 的 log 与接收方的 log 一样新，就投票给它

这里的一样新：谁的 log 更新，取决于谁的 term 更新，如果 term 相同，取决于 index 更大，一样新就是 log 的 term 和 index 都一样

AppendEntries RPC（leader 用它来追加日志和发送心跳）

Arguments：

term：leader 的 term
leaderId：便于将 client 打到 follower 的请求重定向给 leader
prevLogIndex：leader 要发送新的 log entry 给 follower，prevLogIndex 是紧接着这些要发送的日志的前一条 log entry 的索引
prevLogTerm：和上一条类似，prevLogIndex 索引处的 log entry 的 term
entries[]：要发送的 log entries（心跳时为空，为了提高效率可能一次性发送多个日志条目）
leaderCommit：leader 的 commitIndex

Results：

term：currentTerm，用于 leader 发现自己可能不是最新的，更新自己
success：bool，判断 follower 的 log entry 是否匹配 prevLogIndex 和 prevLogTerm

接收方需要实现：

如果 term < currentTerm，返回 false
如果接收方在匹配的 prevLogTerm 下 log entry 的索引不与 prevLogIndex 匹配，返回 false
如果已经存在 log entry 和发送方发送的 log entry 冲突（索引相同但是 term 不同），删除已经存在的 log entry 及其后面的所有 log entries
添加 log 中不存在的任何新的 log entries
如果 leaderCommit > commitIndex，更新接收方的 commitIndex = min(leaderCommit, 最新 log entry 的 index)

Rules for Servers

All Servers:

如果 commitIndex > lastApplied：递增 lastApplied，状态机执行这些 log[lastApplied]
如果 RPC request or reply 中的 term > currentTerm：更新当前服务器 currentTerm = term，降级为 follower

Followers：

响应 RPC from candidate and leader
如果选举计时器超时：convert to candidate

Candidates：

升级为 candidates 时，发起选举：
- currentTerm++
- 给自己投一票
- 重置选举计时器
- 发送 RequestVote RPC 给其他所有的服务器
如果收到了超过半数服务器的票，成为 leader
如果收到了来自另外一个新 leader 的 AppendEntries RPC，降级为 follower（新 leader：指 term 新）
如果选举计时器超时：发起新的选举

Leader：

选举时：不断发送心跳给每个服务器，以防选举计时器超时
如果从客户端收到了命令：添加 log entry 到本地 log，在 log entry 被实际执行之后再返回response
对于要发送的 follower，如果 leader 最新的 log entry 索引 >= nextIndex[i]（说明 follower 落后），发送从 nextIndex[i] 索引开始的log entries AppendEntries RPC
- 如果成功发送，更新 nextIndex[i] 和 matchIndex[i]
- 如果由于日志不一致导致发送失败，递减 nextIndex 然后重试
如果存在 N，满足 N > commitIndex && 超过半数的 matchIndex[i] >= N && log[N].term == currentTerm，设置 commitIndex = N

始终成立的属性

原文 Figure3 的内容：

Election Safety：在同一 term 最多只有一个 leader 当选
Leader Append-Only：leader 从来不会覆盖或者删除 log 中已经存在的条目，只会追加新的条目
Log Matching：如果两个 log 包含了一个相同 term 且相同 index 的条目，那么在该索引之前的所有条目也全部相同
Leader Completeness：如果在一个给定的 term 内提交了一个 log entry，那么后续其他更高 term 的 leader 的日志中都会包含该 log entry
State Machine Safety：如果一个服务器执行了一条给定索引处的 log entry，那么其他服务器永远不会在这个索引处执行不同的 log entry

Raft basics 5.1

一个 raft 集群包含一些服务器，5个是一个经典的数字，可以容忍有两个服务器出错。在任何时间，每个服务器都处于三个状态中的一种：leader，follower，candidate。在正常情况下，有一个服务器是 leader，其他都是 follower。follower 是被动的：他们不会主动发送请求，只会简单的响应从 leader 和 candidate 发送的请求。leader 处理客户端的所有请求（如果一个客户端尝试与 follower 通信，follower 会把请求重定向到 leader）。第三种状态：candidate，用于选举新的 leader。下图展示了状态转换情况：

服务器状态图。followers 只会接受其他服务器的请求，如果一个 follower 接受不到任何联系，他会变成 candidate 并发起一次选举。candidate 如果收到了集群中过半服务器的选票就会变成新的 leader。leader 通常会一直运行直到自身故障。

raft 把时间分成特定长度的 terms，如下图所示：

时间被分成了 terms，每个 term 开始于一次选举。在一轮选举成功之后，单个 leader 会管理整个集群直到这个 term 结束（term 没有固定时长的，如果系统运行正常，那么就会一直处于这个 term）。如果选举失败了，那么该 term 这段时期没有 leader（下个 term 会重新选举）。terms 的转换可能在不同的服务器上于不同的时间被观察到。

Terms 被用连续的整数编号，每个 term 开始于一次选举，在这次选举内，一个或者多个 candidate 尝试竞争成为 leader。如果其中一个 candidate 赢得了选举，他就会成为这个 term 剩余期间的 leader。在某些情况下，一次选举可能会发生分票。此时，这个 term 可能会没有 leader，一个新的 term（便随着一个新的选举）将会很快发生。raft 确保在一个 term 内最多只有一个 leader。

不同的服务器可能在不同的时间观察到 terms 的转换，在某些情况下一个服务器可能没有观察到选举，甚至没有观察到整个 term。terms 在 raft 中扮演着逻辑时钟的角色，允许服务器检测过时的信息，比如过期的leader。每个服务器存储了 currentTerm 字段（自增字段）。任何情况下，服务器之间通信都需要交换 currentTerm 信息，如果一个服务器的 currentTerm 比其他服务器小，那么它就会更新它的 currentTerm 为更大值。如果一个 candidate 或者 leader 发现它的 currentTerm 过期了，他会立刻降级为 follower。如果一个服务器接受了一个带有过期 term 的请求，他会拒绝这次请求。

raft 服务器通过 RPCs 相互通信，基础的共识性算法只需要两种 RPCs（RequestVote 和 AppendEntries）。RequestVote RPCs 在选举时被 candidate 执行；AppendEntries RPCs 被 leader 执行，用于复制日志或者提供心跳给其他服务器。高阶段提供了第三种 RPCs 用于在服务器之间做快照传输。如果服务器在规定时间内没有收到响应，它们会重试 RPCs 请求。为了更好的性能，服务器通常并行发送 RPCs 请求。

Leader election 5.2

Raft 使用心跳机制来触发选举。当服务器启动的时候，它们最初作为 followers，只要服务器能从 leader 或 candidate 收到合法的 RPCs 请求，就会一直保持 follower 状态。leader 定期发送心跳（不带有日志条目的 AppendEntries RPCs）给所有 followers 以维护它们的状态。如果一个 follower 在一定时间内（称为 election timeout）没有收到请求，它就会认为 leader 出故障了，然后发起新的一轮选举来选出一个新的 leader

开启一次选举时，follower 会自增它的 currentTerm，然后转化为 candidate。他会先给自己投一票，然后通过并发的 RequestVote RPCs 请求，发送请求给集群中的所有其他服务器，candidate 会保持 candidate 状态，直到出现下面三种情况：

它赢得了选举
另一个服务器成为了 leader
一段时间过去了，选举no winner

以下段落将分别讨论这三种情况：

candidate 赢得了选举条件是他收到了当前 term 下整个集群中的大多数选票（过半的票）。每个 server 在一个 term 中最多给 candidate 投一票，基于先到先得原则（5.4 添加了投票的额外限制）。过半原则确保了在一个 term 内最多只有一个 candidate 会赢得选举。一旦一个 caniddate 赢得了选举，就会变为 leader。然后这个 leader 对其他的所有服务器发送心跳来建立起他的 leader 身份，并且防止新的选举
在等待其他服务器投票的过程中，candidate 可能收到来自另外一个server的 AppendEntries RPC，这个 server 宣称自己已经成为了 leader。如果这个 leader 的 term（RPC 的参数）比当前 candidate 的 term 更大或相等，candidate 会认可这个 leader，自己降级为 follower。如果 RPC 参数中的 term 比当前 candidate 的 term 小，candidate 会拒绝这次 RPC 请求然后继续保持 candidate 状态
如果 candidate 即没有 win 也没有 lose 这次选举：因为很多 followers 在同一时间成为 candidate，出现了分票，导致没有 candidate 能获取过半的票。这种情况下，每个 candidate 将会超时过期，然后开始一轮新的选举（term++），并执行另外一次 RequestVote RPCs。然而，如果不采取额外措施，这种分票现象可能会不断重复出现。

raft 通过随机的 election timeout 来确保分票现象是低概率的，并且可以被快速的修复。为了避免第一次分票现象，election out 被设置为一个固定区间内的随机值（例如：150 - 300 ms）。这样可以分散服务器，便于在大多数情况下，仅仅只有一个服务器会超时。它赢得了选举然后在其他服务器触发超时之前发送心跳。同样的机制也被用于处理已经发生的分票现象，每个 candidate 在一次选举开始时重置它的随机 election timeout，等待其中一个 candidate 的 election timeout 超时，然后开启下一次选举。

Log replication 5.3

一旦 leader 被选举产生，它就开始接受客户端的请求。每个客户端请求包含一条将会被复制状态机执行的命令，leader 把命令作为一个新的 log entry 添加到 log 中。然后并发向其他的服务器发送 AppendEntries RPCs 来复制这条 log entry。当这条 entry 被安全地复制了（下文有提及），leader 会执行这条 enrty 然后返回执行结果给客户端。如果 followers 崩溃了或者运行缓慢，或者网络包丢失，leader 会无限期地重新尝试发送 AppendEntries RPCs （即便是在 leader 已经响应了客户端之后），直到所有的 follower 最终都储存了所有日志条目。

logs 用下图所示的方式组织：

logs 有许多条目（entries）组成，这些条目按次序编号。每个 enrty 包含了他被创建时的 term（图中方框内的数字）和一条指令（用于给状态机执行）。如果一个 entry 可以被状态机安全地执行，这条 entry 被认为是 committed 的。

每个 log entry 存储了状态机指令和 term（当这条 entry 被 leader 接受时的 leader term）。log entry 中的 term 用于检测日志之间的不一致，确保 Figure3 中的某些属性成立。每个 log entry 同样有一个整数索引来明确他在该 log 中的位置。

leader 决定了何时为在状态机上执行 log entry 的安全的时机，此时的 log entry 被视为 committed 的。raft 保证了 committed entries 具有持久性，确保这些 entries 最终会被所有可用的状态机执行。一旦创建这条 log entry 的 leader 把它复制到了过半的服务器上，这条 log entry 就是 committed 的（例如上图中的 entry 7，在 3 个 server 中存储）。这也会提交 leader 的 log 中的所有先前的 entries，包括被先前旧 leader 创建的 entries。这种提交是安全的。leader 会跟踪它所知的被提交过的 log entry 的最高索引，并在未来的 AppendEntries RPCs（包括心跳）中包含该索引，以便其他服务器最终能够获知。一旦 follower 知道一条 log entry is committed，它就会将这条 entry 在本地的状态机上执行（按照 log 的顺序）。

我们设计的 raft 日志机制旨在在不同的服务器上维持日志的高一致性。这不仅简化了系统的行为，使其更加容易预测，而且这是确保安全性的重要组成部分。raft 维护了以下属性，这些属性构成了 Figure3 种的日志匹配属性：

如果在不同 log 中的两个 entries 有相同的索引和 term，则它们存储相同的命令
如果在不同 log 中的两个 entries 有相同的索引和 term，则 log 在此之前的所有 entries 都是相同的

第一条属性来源于以下事实：一个 leader 基于给定的 index 和 term 最多创建一个 entry，并且 entry 在 log 中的位置永远不会改变。第二条属性来源于：AppendEntries 的简单一致性检查。当发送一个 AppendEntries RPC 时，leader 会在发送信息中包含 prevLogIndex 和 prevLogTerm（prevLogIndex 和 prevLogTerm 是 leader 的 log 中，他接下来要发送的新 entries 的前一条 entry 的索引和 term）。如果 follower 在自己的 log 中没有找到给定 prevLogIndex 和 prevLogTerm 对应的 entry，她就会拒绝这些新的 entries。一致性检查起到归纳步骤的作用：初始 logs 的空状态满足 Log Matching Property，一致性检查在 logs 扩展时维持了 Log Matching Property。结果，只要 AppendEntries 返回 success，leader 就会知道 follower 的 log 和 leader 自身的 log 在新的 entries 之前完全相同。

通常情况下，leader 和 follower 的日志是保持一致的，因此 AppendEntries 的一致性检查将永远不会失败。然而，leader 故障可能会导致日志的不一致（旧 leader 可能没有来得及复制它 log 中的所有 entries）。这种不一致性可能会在一系列的 leader 和 follower 故障中不断累积。下图展示了 follower 和新的 leader 的 log 之间可能存在的差异。follower 中可能缺失 leader 中有的 entries，follower 中也可能包含 leader 中没有的 entries，甚至这两种情况可以同时发生。这些 log 中缺失或多余的 entries 可能跨越多个 terms。

当 leader 任职时，下面 a - f 的情况都可能发生在 follower 的 logs 中。每个方框代表一个 log entry，其中的数字代表这条 entry 的 term。一个 follower 可能缺少 entries（如 a - b），可能有多余的未提交的 entries（如 c - d），或者两种情况同时发生（如 e - f）。例如，情况（f）可能由以下产生：f 的服务器从 term2 开始作为 leader，在它自己的 log 中添加了一些 entries，但在提交它们之前崩溃了。它很快又重启了，重新成为了 term3 的 leader，然后又在它自己的 log 中添加了更多的 entries。但 term2 和 term3 中的 entries 都还没被来得及提交，该服务器再次崩溃并在接下来的几个 term 中持续宕机。

在 raft 中，leader 通过强制让 follower 的 log 复制 leader 自己的 log 来解决这种不一致。这意味着 follower logs 中冲突的 entries 将会被 leader 的 log 覆盖。5.4 证明这种行为是安全的（当和另外一个限制条件结合使用）

为了让 follower 的日志和 leader 自己保持一致，leader 必须找到它与 follower 匹配的最新的 log entry，删除在此之后的 follower 的 log 中所有的 entries，然后把 leader 在此之后的所有 entries 发送给 follower。这些行为发生在响应 AppendEntries 的一致性检查的 response 中。leader 为每个 follower 维护一个 nextIndex[i] 字段，标识了 leader 将要发送给 follower 的下一个 entry 的索引。当 leader 第一次任职时，他会初始化所有 nextIndex 的值为它最新 log entry 索引的下一个索引（以上图为例，nextIndex[i]就是 11）。如果 follower 的 log 和 leader 不一致（一致的判断是通过 AppendEntries 中的 prevLogIndex 和 prevLogTerm 与 follower 中的 log entries 匹配），在下一次 AppendEntries RPC 中 AppendEntries 一致性检查会失败。在拒绝 AppendEntries 之后，leader 会递减 nextIndex[i] 然后重试 AppendEntries RPC。最终 nextIndex[i] 会到达一个索引，使 leader 和 follower 的 logs 相匹配，此时 AppendEntries 会成功，这会移除 follower 的 log 中后面所有冲突的 entries，然后从 leader 的 log 中添加 entries。一旦 AppendEntries 成功，follower 的 log 就和 leader 一致了，并在这个 term 的后续时间保持这种状态。

如果需要，可以优化协议来减少 AppendEntries RPCs 的拒绝次数。例如，当拒绝一个 AppendEntries 请求时，follower 可以在返回值中包含冲突 entry 的 term 和这个 term 任期存储的第一个 entry 的索引。laeder 可以通过这条信息来递减 nextIndex[i] 来跳过该 term 的所有冲突 entries，而不是每个 entry 都要通过 RPC 确认一次。但实际上，这种优化不是必要的，因为故障发生的频率很低，也不会存在大量不一致的条目

通过这种机制，当 leader 任职时，不需要采取特殊的行为来恢复日志的一致性。它只需要正常运行，日志根据给 AppendEntries 一致性检查返回的错误，自动整理汇聚。leadr 永远不会覆盖或者删除它自己已经存在的 log entries

这种日志复制机制体现了理想的共识机制特性：只要过半的服务器正常运行，raft 就可以接受、复制、执行新的 log entries。通常情况下一条新的 entry 可以通过一轮 RPCs 调用复制到集群中的过半的节点上，某个运行缓慢的 follower 不会影响整个系统的表现。

Safety 5.4

先前的章节描述了 raft 的 leader 选举和日志复制机制。然而，这些机制目前不足以确保每个状态机都会精确地按照相同的顺序，执行相同的指令。例如，某个 follower 发生故障变得不可用，同时 leader 提交了一系列的 log entries，后来这个故障的节点恢复并被重新选举为了 leader，它追加了新的 entries。结果，不同的状态机可能会执行不同的命令序列。

这个章节完善了 raft 算法，添加了一个节点可以被选为 leader 的限制条件。这个限制条件确保了任何 term 下的 leader 拥有在此 term 之前的所有 committed entries。基于该限制条件，我们为提交制定了更精确的规则。最后，我们给出了 Leader Completeness（领导者完备属性）的证明概要，展示了它是如何引导复制状态机做出正确的行为的。

Election restriction 5.4.1

在任何基于 leader 的共识算法中，leader 必须最终保存所有已经提交的 log entries。在某些共识算法中，例如 Viewstamped Replication，即使 leader 最初并不包含所有已提交的条目，也可以被选出。这些算法包含额外的机制来识别缺失的条目，并在选举过程中或选举后不久将其传输给新的领导者。然而，这会导致大量的额外机制和复杂性。raft 采用了一种更简单的方式，确保在选举之时，任何新的 leader 就都必须具备先前 terms 中所有已经提交的 entries，而不需要发送额外的 entries 给 leader。这意味着 log entries 是单向传输的，只能从 leader 传输到 follower，并且 leader 从来不会覆盖它们的 logs 中已经存在的 entries。

raft 使用投票过程来确保只有拥有全部 committed entries 的 candidate 才会被选为 leader。一个 candidate 必须与集群中的过半服务器通信才能胜出，意味着每个 committed entry 都必须出现在这些过半服务器中的至少一个。如果 candidate 的 log 至少与这些过半服务器中任何 log 一样新（新的定义见下文），那么这个 candidate 就会包含全部的 committed entries。RequestVote RPC 实现了该限制：RPC 中包含了 cadidate 的日志信息，如果 follower 发现自己的 log 比 candidate 的 log 更新，follower 就会拒绝投票。

raft 判断两个 logs 哪一个更新是通过比较最后一条 log entry 的 index 和 term，如果 last entries 有不同的 term，那么拥有更大 term 的就更新；如果 term 相同，谁的日志更长（index 更大）谁就更新

Committing entries from previous terms 5.4.2

正如像 5.3 节描述的那样，在当前 term 下，一旦一条 entry 存在于过半的服务器上，leader 就会认为这条 enrty 是 committed 的。如果 leader 在提交这条 entry 之前故障了，未来的 leader 将会尝试完成这条 entry 的复制任务。然而，新的 leader 不能因为这条 entry 在先前任期 term 中存在于过半的服务器上就认为这个 entry 在新的 term 内是 committed 的。下图展示了一种情况：旧的 log entry 存储在了过半的服务器上，但是新的 leader 仍然可能把这些 log entries 覆盖掉。

一种情况展示了为什么 leader 不能使用来自旧 terms 的 log entries 来确定提交状态。在（a）中，S1 是leader，把 term2 的 log entry 复制到了部分服务器上。在（b）中，S1 崩溃了，S5 被选举为了 term3 新的 leader（收到了来自 S3，S4 的选票），接着 S5 在 index = 2 处接受到了一条新的 log entry（不同于之前的 term2，用颜色区别），在（c）中，S5 崩溃了，S1 恢复并成为了新的 leader，继续他的复制任务。在这种情况下，来自 term2 的 log entry 被复制到了过半的服务器上，但是还没有提交。此时在（d）中，S1 再次崩溃了，S5 又被选举为了新的 leader（S5 的 log entry 的 term 更新），然后他开始复制日志到其他服务器上，用 term3 的日志覆盖掉了其他服务器上的日志。然而，如果 S1 在第二次崩溃之前，把 term4 的 log entry 复制到了过半的服务器上，如（e）中所示，那么这条 entry is committed，在 S1 发生第二次崩溃时，S5就无法赢得选举。这种情况下所有先前的 log entries 才会全部提交。

为了消除图8中的情况，raft 永远不会仅仅通过复制数目提交来自先前 terms 的 log entries。只有当 log entries 来自当前 leader 任期时才会通过判断复制数目过半来提交；一旦一个来自当前 term 的 entry 被以这种方式提交，那么所有先前的的 entries 都也会被间接提交（由于 Log Matching 属性）。有一些这样的情况：leader 可以安全地推断出一条旧的 log entry 是 committed 的（比如所有服务器上都储存了这条 log entry），但是 raft 采用了更加保守的简化方式。

Safety argument 5.4.3

这部分是关于 leader completeness 的证明，感兴趣可以自己看原文。

Follower and candidate crashes 5.5

目前为止我们聚焦于 leader 故障。相对于 leader 故障，follower 和 candidate 的故障更加简单，它们被用同样的方式来处理。如果一个 follower 或者 candidate 发生故障，未来发送到该服务器的 RequestVote 和 AppendEntries RPCs 将会失败。raft 通过无限期不断重试来解决这些故障。如果故障的服务器重启，RPC 就会成功完成。如果一个服务器在处理 RPC 成功，但是在 responde RPC 之前故障，它将会在重启后收到一个相同的 RPC 请求。raft RPCs 是幂等的，因此这不会有错。例如，一个 follower 收到了一个 AppendEntries 请求，请求包含了已经存在于该服务器的 log entries，服务器会简单的忽略这些 entries。

Timing and availability 5.6

我们对 raft 的要求之一是：safty 必须不能依赖时间。系统不能因为某些事件发生的比预期时间快或者慢就产生错误的结果。然而，可用性（系统及时响应客户端的能力）不可避免地依赖于时间。例如，如果信息交换花费了太长时间，超过了服务器通常崩溃之间的时间，candidate 将没有足够的时间来赢得一次选举。没有稳定的 leader，系统就会不可用。

raft 中时间是很关键的，leader 选举只体现了其中一方面。只要系统满足下面的时间要求，raft 将会顺利选举并维护一个 leader：

1	broadcastTime <= electionTimeout <= MTBF

broadcastTime 是一个 server 并行向集群中所有 server 发送 RPCs 并收到回复所需要的平均时间
electionTimeout 是选举计时器的超时时间
MTBF 是每两个服务器发生故障的平均时间

broadcastTime 应该比 electionTimeout 小一个数量级，以便 leader 可以稳定发送心跳来防止 follower 发起新的选举；由于 electionTimeout 采用随机生成的方式，这种不确定性也降低了分票的概率。electionTimeout 应该比 MTBF 小几个数量级以便系统可以稳定运行。当 leader 故障时，系统将会有一段时间变得不可用，大概是 electionTimeout 的时长，我们希望这段时间只占据系统全部运行时间的一小部分。

broadcastTime 和 MTBF 是系统的潜在属性，而 electionTimeout 是我们可以实际控制的。raft 的 RPCs 通常需要接受者把信息持久化到稳定存储，因此 broadcastTime 可能在 0.5 —— 20 ms 范围内，取决于存储技术。结果，electionTimeout 可能会在 10 —— 500 ms 范围内。通常 MTBFs 长达几个月甚至更长，很容易满足时间规定要求。

8.Linux-Part.3

2026-03-17T02:23:00.000Z

Linux-Part.3

TODO

7.Linux-Part.2

2026-02-28T02:23:00.000Z

Linux-Part.2

Linux 总是无处不在的，或许我对他并不陌生，但从未系统学习过，这篇文章将记录我系统学习 Linux 的过程经历，遇到的问题，总结的笔记，便于我留存记录，也供大家参考学习

学习路线可参考：https://labex.io/zh/linuxjourney

设备

/dev 目录
在 Linux 中，连接到系统的各种硬件设备（键盘、硬盘等），都由一个特殊文件表示，这些文件被称为设备文件，位于 /dev 目录下，可以使用正常的标准命令来和这些文件进行交互
1
ls /dev
这将显示许多条目，每个条目对应一个硬件设备或者虚拟设备，例如我们之前已经与 /dev/null 这个虚拟设备进行过交互
早期的 /dev 目录是静态的，所有可能的硬件的设备文件都是在安装过程中创建的，导致可能某个设备文件对应于甚至不存在的硬件。此外，在重启系统时根据内核检测设备的顺序，设备名称可能会发生变化，导致设备文件的配置出现混乱
现代的 /dev 目录使用动态方法，根据硬件的连接状态动态的创建和删除设备文件，确保 /dev 只包含当前正在使用的设备的相应文件，并提供了一个持久的命名方案，使系统更可靠、更易于管理
1
ls -l /dev
使用长选项查看 /dev 目录的文件信息，文件类型不仅以 - 表示，设备文件的独特文件类型有助于我们识别：
- c：字符设备。这些设备一次传输一个字符的数据，许多伪设备被表示为字符设备，例如 /dev/null
- b：块设备。这些设备以固定大小的数据块进行传输，例如硬盘等，他们对基于块的数据访问进行了优化
- p：管道。FIFO（先进先出），允许进程间通信，作用类似字符设备，但他将输出引导到另一个进程而不是设备
- s：套接字（socket）。也促进了进程间通信，更加通用，支持多个进程之间的通信，甚至跨网络通信
原本的文件大小字段被替换成了两个字段，表示主设备号和次设备号，例如对于 8, 0 的设备，8 通常用于表示 SCSI 磁盘驱动器，而 0 表示这个驱动程序的特定实例，0 通常表示第一个驱动器
关于常见的设备名称，参考：https://labex.io/zh/lesson/device-names

/sys 目录

sysfs 是一个虚拟文件系统，通常挂载在 /sys，它将内核对象、硬件设备和驱动程序的信息从内核模型导出到用户空间。/sys 目录的主要作用是提供对系统上所有设备的结构化视图，/sys 能反映出内核和设备的当前状态，当内核与设备状态发生变化时，/sys 能即时反应这种变化

  ~/mysrc ❯ ls -l /dev/sda                                                                   
brw-rw---- 1 root disk 8, 0  3月  1 09:12 /dev/sda
  ~/mysrc ❯ ls /sys/block/sda                                                                 
alignment_offset  dev                diskseq       events_poll_msecs  holders    mq        queue      ro     sda16   stat       uevent
bdi               device             events        ext_range          inflight   partscan  range      sda1   size    subsystem
capability        discard_alignment  events_async  hidden             integrity  power     removable  sda15  slaves  trace

可以看到，/sys 比 /dev 提供了更详细的视图，他们作用不同，/dev 提供设备节点，允许用户通过这些设备文件与设备交互；/sys 用于查看有关设备的详细信息，暴露设备的底层模型

udev
在旧的 Linux 系统中，我们可以手动创建设备节点：
1
mknod /dev/sdb1 b 8 3
如果要删除设备，只需要在 /dev 目录中 rm 该设备文件
现在的 Linux 版本中，我们不需要这样做，udev 系统会根据设备是否连接来动态地为我们创建和删除设备文件。系统上运行着一个 udev 守护进程，它监听来自内核中关于连接到系统的设备的信息，依据 /etc/udev/rules.d 中的规则自动创建和删除设备文件。我们也可以编写自己的 udev 规则（通常不需要）
你还可以使用 udevadm info 命令查看设备的详细信息，例如：
1
udevadm info --query=all --name=/dev/sda
列出硬件设备
类似 ls 列出文件，第三方工具提供了 ls 的衍生命令：
1
2
3
lsusb# sudo apt install usbutils
lspci# sudo apt install pciutils
lsscsi# sudo apt install lsscsi
- USB 设备：通常指一些支持热插拔的外设，例如U盘、鼠标、摄像头等
- PCI 设备：直接连接在主板上的高速总线设备，例如显卡、网络设备器、声卡等
- SCSI 设备：Linux SCSI 子系统管理的存储设备（即使是 SATA、USB 等现代存储设备，Linux 也使用 SCSI 子系统统一管理），大多数存储设备设备都采用 SCSI 协议管理
dd
dd 是一个强大而危险的命令，可以用来复制文件内容（按字节复制）
1
dd if=~/mysrc/pic/kirito.jpg of=~/mysrc/pic/kirito-cp.jpg bs=1024
这个会将 kirito.jpg 的内容复制到 kirito-cp.jpg 中，它每次读取 1024 个字节，循环完成复制整个文件
- if：in file，表示输入文件
- of：out file，表示输出文件
- bs：每次传输的数据大小，默认是 512 字节（b），可以使用后缀表示更大的单位，例如 1k, 1M, 1G
- count：如果你不想复制整个文件，可以用 count = 2 来制定复制 2 块
dd 可以很方便的用来备份服务器数据，备份和恢复磁盘数据，但要注意输入命令的正确性，防止数据丢失

文件系统

文件系统层次结构
大家都知道 Linux 的文件系统是树状的，具体常见目录如下：
根目录
- /：根目录，无须多言
关键系统目录
- bin：包含所有用户可以使用的基本命令程序（二进制文件），如 ls 等
- sbin：存放基本的系统二进制文件，这些文件主要由系统管理员使用，通常只能由 root 运行
- /etc：核心系统配置文件目录，包含操作系统和已安装应用程序的配置文件，不应该包含任何可执行的二进制文件
- /boot：存放系统启动过程中所需要的文件，包括 Linux 内核和引导加载程序文件
用户和应用程序数据目录
- /home：每个用户的个人目录，存放你的文档、应用程序设置和其他个人文件
- /root ：root 用户的家目录
- /opt：用于存放完整的第三方应用程序软件包（不由发行版“官方仓库策略”管理，自己包含完整目录）
- /usr：包含用户安装的各种软件和应用程序。/usr 有它自己的目录结构，例如 /usr/bin 下存放发行版提供的二进制文件，例如使用包管理器安装的 java 二进制文件位于 /usr/bin/java，而 /usr/local 下常存放从外部源下载的软件，例如下载的 golanag.tar.gz 常解压到 /usr/local/go中，以及 /usr/local/bin/kubectl，还有自己手动编译的 /usr/local/bin/hello
动态和临时目录
- /var：表示“可变”目录，存储预期会发生大小和内容变化的文件，比如 /var/log/ 目录下的日志文件，还有缓存文件，假脱机文件（系统为了“排队等待处理”的任务而创建的临时文件）等。/var/www 目录是 Linux 的 Web 服务默认静态文件的存放位置，Apache 和 Nginx 的默认挂载点（Nginx 也常用 /usr/share）
- /tmp：存放临时文件，每个人都可以写入，且不能删除和移动其他人的文件。重启系统后该目录中的文件通常会被删除
- /run：包含自上次启动以来，有关正在运行的系统的信息，例如进程 PID 等
设备和挂载点目录
- /dev：设备文件，上有介绍
- /media：可移动媒体（如 USB 驱动器、SD 卡等）的标准挂载点
- /mnt：临时挂载文件系统的通用挂载点（一般要手动挂载）
系统信息目录
- /proc：虚拟文件系统，提供内核和进程的实时详细信息，part1 有介绍
- /srv：用于提供一个目录，存放“对外提供的服务”的数据，一般普通用户不需要在这里存放个人资料
文件系统类型
使用 df -T 命令，df 命令报告文件系统磁盘空间使用情况，-T 标志专门显示文件系统类型
文件系统是操作系统用来管理存储设备上的数据等一套规则和结构，一些常见的 Linux 文件系统类型：
- ext4：Linux 扩展文件系统（extended file system）的最新版本，是许多 Linux 发行版的默认设置。它向后兼容前身版本（ext3 ext2），支持非常大的磁盘卷
- Btrfs：B 树文件系统（B-tree file system），一种现代文件系统，具有内置快照、备份、改善性能等高级功能，作为某些发行版的默认文件系统，仍在积极开发中
- XFS：一种高性能的日志文件系统，在处理大文件和并行 I / O 操作方面表现出色。它是管理大量数据的系统的绝佳选择（如媒体服务器）
- NTFS 和 FAT：标准的 windows 文件系统类型，Linux 对他们的读写完全支持，对双系统启动十分有用
- HFS+：macOS 的主要文件系统类型，Linux 默认对其只提供只读支持
有着许多不同的文件系统实现，Linux 采用**虚拟文件系统（VFS）**来与他们进行统一交互，VFS 是 Linux 内核中的一个抽象层，位于应用程序和各种文件系统之间。它提供了一个单一的、统一的接口，确保应用程序可以无缝工作，而无需关心底层的文件系统类型
大多数现代文件系统默认包含日志记录功能，要理解它的重要性，想象一下在您电脑突然断电时复制一个大文件。在非日志文件系统中，这种中断可能导致文件损坏和文件系统状态不一致。重新启动后，您的系统需要执行完整的磁盘检查 (fsck)，这对于大容量磁盘来说可能非常耗时。日志文件系统可以防止这个问题。在执行写入操作之前，它首先将预期的更改记录在一个特殊的日志文件中，一旦操作成功完成，日志就会被更新以标记任务已完成。如果发生崩溃，系统可以在重新启动时简单地读取日志，查看哪些操作正在进行中，并快速将文件系统恢复到一致状态
TODO…

启动系统

启动系统概述
Linux 系统的启动过程可以分为四个阶段：
- Part1. BIOS
  BIOS（基本输入 / 输出系统）或 UEFI（代替传统 BIOS）是打开计算机电源时运行的第一个软件。它执行开机自检（POST）来初始化和验证CPU、内存、磁盘等系统硬件。硬件检查通过后，BIOS 的主要任务是从存储设备定位并加载引导加载程序
- Part2. 引导加载程序
  引导加载程序从 BIOS 接管控制权。它的主要作用是将 Linux 内核加载到内存中，Linux 系统常见的引导加载程序是 GRUB，通常 GRUB 会显示一个菜单，允许你选择要启动的操作系统或内核版本。在用户选择后或超时后，它会将选定的内核和初始 RAM 加载到内存中，然后将控制权传递给内核
- Part3. 内核
  内核一旦加载到内存中，就接管了系统的控制权。它先解压缩自身并初始化核心硬件和内存管理，然后挂载根文件系统，启动第一个进程：init 进程
- Part4. Init
  init 进程是内核启动的第一个进程，也是系统上其他所有进程的祖先，它的工作主要是根据配置启动必要的服务和后台进程（守护进程）。init 有几种实现，例如传统的 System V、Upstart 和现代的 systemd
TODO…

内核

初始化

init 系统的主要作用是启动和停止必要的进程。Linux 经历了三种 init 实现：System V、Upstart、``

进程利用率

日志

6.Linux-Part.1

2026-02-23T04:17:00.000Z

Linux-Part.1

学习路线可参考：https://labex.io/zh/linuxjourney

什么是 Linux ？

回溯到 1969 年，当时贝尔实验室的 Ken Thompson 和 Dennis Ritchie 开发了 UNIX 操作系统，十多年后，Richard Stallman 发起了 GNU 项目，目标是创建一个完全自由和开源的类 UNIX 操作系统，但统一的内核始终未能完成

内核是操作系统的核心，它充当桥梁，使硬件能够与软件通信。内核管理系统资源，例如 CPU、内存和外围设备

到 1991 年，Linus 发明了 Linux 内核，填补了 GNU 操作系统缺失的那一块拼图

尽管我们通常说 Linux 操作系统，但从技术层面来讲，Linux 指的是 Linux 内核，而使用 Linux 作为内核的操作系统，确切来说成为 Linux 的发行版

比较流行的发行版有很多，本篇文章笔者采用的是 Ubuntu 24.04.3 LTS

关于如何在 MacOS 安装 Ubuntu 虚拟机，可以参考我之前的博客：https://kirito.cloud/2025/2.%E5%88%9D%E5%A7%8B%E5%8C%96multipass%E8%99%9A%E6%8B%9F%E6%9C%BA/

命令行操作

什么是 Shell ？

Shell 是一个强大的应用程序，它可以接受你输入的命令，传递给操作系统执行

或许你也听过“终端”这样的词汇，终端只是一个普通的应用程序，他的作用是为你打开一个 Shell 会话

Shell 有很多，大部分发行版的默认 Shell 是 bash ，其他常见的 Shell 还有 zsh，fish 等

常用命令

echo 输出命令行参数
1
echo Hello World
pwd 打印当前工作目录的绝对路径
Linux 中，整个文件目录以根目录（用/表示）作为顶级目录，每个子目录分支成多个子目录，形成目录树
1
pwd
cd 切换工作目录
支持绝对路径和相对路径
- .：当前目录
- ..：当前目录的上一级目录
- ~：用户目录，通常是/home/xxx
- -：上一次你所在的目录
1
cd ~

Linux 命令都可以在后面加上选项参数，--后跟选项全名，-后跟选项简写

例如ls --all和ls -a效果是一样的

ls -a：列出所有目录和文件（包括隐藏文件，隐藏文件以.开头）

ls -l：以长格式显示

权限 | 链接数 | 所有者名称 | 所有者组 | 文件大小 | 修改时间 | 名称

  ~ ❯ ls -l                                                                                
总计 95840
drwxrwxr-x  3 ubuntu ubuntu     4096 12月  2 12:18 go
-rw-rw-r--  1 ubuntu ubuntu 58130616  9月 25 11:11 kubectl
-rw-rw-r--  1 ubuntu ubuntu       64  9月 25 11:11 kubectl.sha256
-rw-rw-r--  1 ubuntu ubuntu 39991324  9月 24 20:25 minikube_latest_arm64.deb
drwxrwxr-x 12 ubuntu ubuntu     4096 12月  4 10:26 mysrc

不同选项也可以组合搭配使用例如ls -al

ls 后面跟的参数可以是目录，这样会列出该目录下的内容，也可以是文件，这样会列出这个文件本身，因此常用ls -l myfile.txt来查看文件的相关信息
ls -d：把目录当成普通文件列出，而不是列出目录内容，常用ls -ld mydir查看目录信息

touch 更改时间戳 / 创建新文件
1
touch newFile
在当前目录下创建名为newFile的空文件，如果newFile已经存在，则会更新文件的时间戳
- touch -r file1 file2：把file2的时间戳更新为file1的时间戳
- touch -d "2024-01-01 12:12" file：把file的时间戳更新为指定值（日期字符串格式可以是任意格式）

file 查看文件类型

与 Windows 等其他操作系统不同，Linux 并不认识文件的后缀名，文件的类型不由后缀名决定，而由文件的内容本身决定，例如：

  ~/mysrc ❯ touch file1.png                                                                    
  ~/mysrc ❯ echo "hello" > file1.png                                                         
  ~/mysrc ❯ file file1.png                                                                   
file1.png: ASCII text

这里file1.png并不是图片文件，而是普通的文本文件

但通常，为文件加上约定俗成的后缀名，可以便于编辑器和其他操作系统识别文件类型

cat 查看文件内容
1
cat myfile
会将myfile的内容输出到屏幕上
也可以跟多个参数
1
cat file1 file2
less 文件查看器
当文件内容过多，使用cat查看文件内容不太便利，less允许你分页查看文件的内容
键入less后，你会进入文件导航模式
- 使用上下箭头逐行翻页，使用page up/down整页翻页
- 使用g和G跳转到文件开头 / 结尾
- 使用q来退出
- 输入/Linux，则会高亮文件中所有的Linux关键字，用n跳转到下一次出现，N跳转到上一次出现
history 输出使用过的历史命令列表
- 使用方向键向上箭头来切换你的历史命令记录，使用!!来切换到上次使用的命令，再次按下enter即可执行
- ctrl + r 是最强大的历史命令查询器，按下ctrl + r会出现搜索框，在框内输入”Linux”则会显示最近一次使用过的带有“Linux”关键字的命令，此时不断按下ctrl + r则可以切换到更早的匹配项
- history -c：清空所有历史命令记录
- history -d 101：删除第101条历史记录
clear 清空屏幕
cp 复制文件到指定目录下
1
cp myfile /home/ubuntu/mysrc
也可以在复制的时候指定复制后的文件名
1
cp myfile /home/ubuntu/mysrc/file2
这会创建file2，并且复制myfile的内容
- cp -r：递归复制，通常用于复制目录
- *：通配符，例如cp -r ~/mysrc/* ~/target/会把/mysrc下的所有内容复制到/target下，注意，如果是``cp -r ~/mysrc ~/target/，则会复制整个mysrc目录，包括mysrc`这一层级
- cp -f：强制覆盖同名文件
- cp -i：交互式，会在覆盖同名文件前向你确认
- cp -p：保留元数据，通常复制时会出现文件时间戳和文件所有权变化的情况，-p可以确保这些元数据不发生变化
mv 移动文件和目录 / 重命名文件和目录
1
2
3
mv file1 file2 ~/mysrc/target
mv file1 file2
mv dir1 dir2
- mv -i：交互式，会在覆盖同名文件前向你确认
- mv -b：覆盖同名文件的同时，会自动创建被覆盖旧文件的备份，并命名为原文件名 + ~
- mv -v：会输出mv命令正在执行的操作，显示正在移动或者重命名的文件
mkdir 创建目录
- mkdir：创建多级目录
rm 删除文件
- rm -f：强制删除
- rm -r：递归删除，常用于删除目录及其所有内容，rm无法直接删除目录
- rm -i：交互式删除，每个文件删除前都会提醒你确认
- rmdir：删除空目录
find 查找文件 / 目录
- find -name：根据名称查找文件 / 目录
  1
  find -name file1
- find -type：限制查找类型
  1
  2
  find -type d -name mysrc
  find -type f -name file1.txt
- 与find不同，grep也用于查找，但常用于在文本中查找匹配内容
find默认会递归查找给出目录及其所有的子目录
man 查看命令手册
1
man ls
大部分命令带有选项--help，也可查看使用说明
1
2
ls --help
ls -h
这里推荐一个浏览器端的速查链接：https://tldr.sh/，方便使用翻译插件，英语weaker有救了（bushi）
除此之外，whatis可以快速返回一个简短的命令描述
1
2
  ~/mysrc ❯ whatis man
man (1) - 系统参考手册的接口
alias 创建别名
1
2
alias back='cd ..'
unalias back# 删除别名
键入back即可返回上级目录，这样的别名只在当前会话生效，退出终端便会清除，unalias也是如此
想要使别名永久生效，需要写入配置文件~/.bashrc（根据不同 shell 决定）
1
2
# 写入...
source ~/.bashrc # 使配置生效也可以关闭会话重新登录
exit 退出会话

文本操作

标准输出 / 输入 stdout/stdin
1
echo "hello world" > file1
这会在当前目录下创建一个新文件file1，内容是hello world
默认情况下，echo会把命令行参数发送到stdout，在你的屏幕上显示，看起来像回显一样
>是一个重定向符号，默认发送到stdout的数据，可以通过>来拦截，发送到一个新的目的地
然而，>重定向的内容会覆盖文件中原有的所有内容，如果你想要追加而不是覆盖，可以使用>>
1
echo "hello linux" >> file1 # 会自动在file1的内容结尾加上换行符
既然标准输出会显示在你的屏幕，那么标准输入就是你键入的内容
当我们使用cat命令，不加任何参数时，会打开一个交互式的场景，此时你输入hello，屏幕会再次回显一个hello，这里你输入的hello就时标准输入，回显的hello就是标准输出
这里cat的作用就是接受标准输入，传递给标准输出
配合重定向符号，我们可以实现：
1
2
# 把 file1 的内容添加到 file2 的结尾
cat < file1 >> file2
cat也可以直接读取文件内容，而不是从标准输入读取，所以下面这样也有同样的效果
1
cat file1 >> file2
标准错误 stderr
1
2
  ~/mysrc ❯ ls bbb > file1
ls: 无法访问 'bbb': 没有那个文件或目录
这里的报错信息，如果是标准输出，按理来说会重定向到file1中，然而却打印到了屏幕上，这是由于另一个 I / O 流在起作用，标准错误stderr
默认情况下，stderr和stdout都会输出到屏幕上，这里的>只重定向了标准输出，而没有重定向标准错误，因此错误信息仍然会打印到屏幕上，要控制标准错误，先要简单理解一下文件描述符fd
文件描述符是一个非负整数，内核通过它来识别打开的文件或流，默认的文件描述符是：
- 0：标准输入
- 1：标准输出
- 2：标准错误
而重定向符号>实际上是1>的缩写，<实际上是<0的缩写
如果想要重定向标准错误，应该这样：
1
2
ls bbb 2> file1
ls bbb 2>> file1
如果我希望标准输出和标准错误都能定向到file1，可以将两者合并
1
2
ls bbb > file1 2>&1
ls bbb >> file1 2>&1
意思是先重定向标准输出，然后在结尾再把标准错误重定向到标准输出所在的位置，即2>&1
Shell 还为我们提供了一种更简单的缩写方法
1
2
ls bbb &> file1
ls bbb &>> file1
如果我们希望把错误信息完全丢弃，既不输出到屏幕上，也不保存到文件中，这时有一个特殊的文件/dev/null，有些人称之为“黑洞”，因为任何输出到该文件的数据都会被丢弃
1
ls bbb >> file1 2>/dev/null
管道和tee
1
ls -a | less
|是管道，它可以获取左侧命令的标准输出，放入管道内，将其作为右侧命令的标准输入
1
ls -a | tee file.txt
tee可以将输出流分为两个方向输出，此时ls的内容会同时输出到标准输出和file.txt中
使用管道和tee过滤的数据流可以继续进入下一级管道，例如我要实现功能：
列出当前目录的所有内容，保存到file1中，同时在屏幕上打印名字中带有file的文件
1
ls -a | tee file1 | grep "file"
tee和|的一个常见组合用法是提升权限，例如：
1
sudo echo "hello" > /root/demofile
这里的sudo只对echo生效，而重定向符号没办法使用sudo来提升权限，因此需要：
1
2
echo "hello" | sudo tee /root/demofile
# 这里的 echo 不需要sudo
env 环境变量
使用env命令可以查看当前会话的所有环境变量，环境变量和其他编程语言中的变量一样，有变量名和值，可以使用$查看变量的值
1
echo $HOME
普通的变量与环境变量的区别在于，是否被其他进程可见，Linux 的进程管理中，子进程只会继承父进程的环境变量，而不会继承父进程的普通变量，我们可以通过export来声明环境变量
1
2
TEST=1# 子进程不可见
export TEST=2# 子进程可见
这样声明的环境变量只在当前 Shell 会话中生效，一旦关闭终端，变量将不再存在
如果你需要让环境变量一直生效，只需要将其添加到 Shell 的启动文件中即可，例如~/.bashrc（或是.zprofile .zshrc .bash_profile等由 Shell 决定），这样每次打开终端，Linux 会自动加载这些文件中的环境变量
在这些环境变量中，有一个特殊的环境变量PATH
echo &PATH会返回一个以:冒号作为分隔符的列表
当你输入一个命令时，系统会先从内置库寻找命令，如果没有找到，就会从PATH变量中开始找
例如直接键入java --version，可能会出现command not found的错误提示，当你把 java 添加到PATH环境变量中，就可以执行java的相关命令了
cut 输出切取的字符
1
echo "Hello! Linux is so interestring." > greeting.txt
- cut -c 8 greeting.txt：输出第8个字符L（空格也算一个字符）
- cut -f 1 -d '!'：按!进行分割，输出第一部分（若不加-d，默认以tab作为分隔符）
  值得注意的是，!在 Linux 中有特殊含义，用于引用历史记录，这种引用在双引号内仍然会生效，如果想要输出字符!，需要在感叹号前添加转义或者使用单引号，"\!"或'!'
paste 输出合并的字符
1
2
3
4
5
# 用 vim 编辑 greeting.txt 为以下内容
Linux
is
so
interesting
- paste -s greeting.txt：输出Linux is so interesting，默认以tab作为分隔符
- paste -s -d ' ' greeting.txt：-d指定分隔符
head 查看文件开头
- head /var/log/syslog：默认会输出文件的前10行
- head -n 15 /var/log/syslog：使用-n指定行数
tail 查看文件末尾
- tail /var/log/syslog：默认输出末尾10行
- tail -n 15 /var/log/syslog：使用-n指定行数
- tail -f /var/log/syslog：使用-f实时监控文件
expand 与 unexpand
- expand hello.txt：把文本中的tab转化为空格输出
- unexpand -a hello.txt：把文本中的空格转化为tab输出（默认情况下，unexpand 只转换每行开头的空格。-a 选项告诉 unexpand command 将所有 8 个空格的实例转换为制表符）
如果要将转化后到结果保存到文件，需要expand hello.txt > result.txt
sort 对行排序

以行为分隔符，对元素进行排序

sort hello.txt：默认是字典排序
sort -r hello.txt：反向排序
sort -n hello.txt：数值排序，先比较行首的数字大小（非数字算作0），数字后的部分按字典排序

tr 转换文本
- echo "hello linux" | tr a-z A-Z：输出HELLO LINUX
- echo "hello 123 linux" | tr -d 0-9：-d删除内容，输出hello linux
- echo "hhhelo linuxxx" | tr -s 'h'：把多个连续的h压缩成一个h
  如果有两个参数，会把前者压缩为后者，例如echo "hhhelo linuxxx" | tr -s 'h' 'H'
  如果要输出hello linux，如下：
  1
  2
  3
  echo "hhhello linuxxx" | tr -s 'h' \
  | tr -s ' ' \
  | tr -s 'x'
  这里的\是 Linux 中的换行符，表示命令还没输完，输入\按下回车后不会执行命令，而是会继续输入未完成的命令
  实际上，Linux 中的|管道符号同时兼备换行的作用，因此上面的命令也可以写成这样：
  1
  2
  3
  4
  echo "hhhello linuxxx" |
  tr -s 'h' |
  tr -s ' ' |
  tr -s 'x'
uniq 重复行处理
新建一个reading.txt，内容如下：
1
2
3
4
5
6
7
book
book
paper
paper
article
article
magazine
- uniq reading.txt：输出删除相邻的重复行后的结果（处理后的结果不会修改原文件）
  只会删除相邻的重复行，如果要删除所有的重复行，需要sort reading.txt | uniq
- uniq -c reading.txt：统计相邻行重复出现的次数
- uniq -u reading.txt：仅输出重复的行
- uniq -u reading.txt：仅输出不重复的行

wc 数据统计

1
2
3

  ~/mysrc ❯ wc reading.txt                                                                   
 9  8 53 reading.txt
 # 行数 单词数 字节数

wc -l：仅显示行数
wc -w：仅显示单词数
wc -c：仅显示字节数

nl 对行编号
输出编号后的结果
1
nl reading.txt
grep 内容搜索
1
grep book reading.txt
搜索reading.txt中含有book的内容
如果我们要搜索reading.txt中含有关键字-v的文本，grep "-v" reading.txt是无效的，此时的-v会被识别成grep的选项，即便你加了双引号，grep提供了-e选项，明确表示后面是你要匹配的内容，而不是选项
1
grep -e "-v" reading.txt
除此之外还有一种更通用的方法--，Linux 中的--是一个万能分界符，它明确表示，--之后的内容都将作为参数，不会被命令误当成选项解析
1
2
3
grep -- -v reading.txt
# 删除一个名为 -f 的文件
rm -- -f
- grep -i：搜索时不区分大小写
- grep -o：仅提取匹配项（默认会输出含有匹配项的整行内容），常与正则表达式结合用于提取符合格式的内容
- grep -f pattern.txt log.txt：当你有多个模版时，把他们放在pattern.txt，搜索log.txt中符合模版的内容
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  # pattern.txt
  info
  warn
  error
  
  # log.txt
  [info]message...
  [warn]message...
  [error]message...
  [info]message...
正则表达式
参考https://labex.io/zh/lesson/regular-expressions-regex
（我一般都让 AI 写正则？）

文本编辑器

Vim 应该是命令行环境中最常用的文本编辑器，这里只简单介绍 Vim 的使用方法

有关 vim 的配置信息，通常在~/.vimrc文件中，这里留存一份我个人使用的配置文件：

" 启用语法高亮
syntax on

" 支持 256 色
set t_Co=256

" 自动缩进
set autoindent
set smartindent

" 显示匹配括号
set showmatch

" 一些常用增强
set number
set tabstop=4
set shiftwidth=4
set expandtab

" 搜索高亮
set hlsearch
set incsearch

" 允许鼠标
set mouse=a

vim hello.txt 使用 vim 编辑器打开 / 新建 hello.txt 文件
vim 有四种模式，普通模式，尾行模式，编辑模式，视图模式
在普通模式下，使用i切换到编辑模式，:切换到尾行模式，v切换到视图模式，esc切换回普通模式
由于我在配置文件中加了set mouse=a，当你用鼠标选中一段文本时，此时 vim 会自动为你切换到视图模式
使用小技巧：
- gg跳转到文件开头，G跳转到文件结尾
- 0跳转到当前所在行行首，$跳转到当前所在行行尾
- 键入/来进入搜索模式，输入搜索内容后回车，vim 会高亮出所有匹配项，使用n和N跳转到下一个 / 上一个匹配项（还有一个?也用于搜索，区别是/用于从当前光标开始向后搜索，?是向前搜索，并且n / N的方向也会根据/和?来发生改变）
- :1,20d后回车，可以删除[1, 20]行的内容
- 鼠标模式很好用，用鼠标选中文本后，按下d删除，按下y复制，按下p粘贴（注意 vim 的剪切板与你的系统剪切板不同步）
保存与退出：
- :w：保存更改的内容
- :q：退出，如果你有未保存的改动时，使用:q会退出失败，如果你想放弃更改并退出，使用:q!
- :wq：保存并退出，你也可以在普通模式下按下ZZ ，快速执行保存并退出的操作
撤销更改
类似 windows 里的 ctrl + z，vim 使用 u 来撤销更改，类似ctrl + shift + z，vim 使用 ctrl + r 来撤销撤销的更改

用户管理

Linux 中的进程会以启动该进程的用户的身份运行，每个用户都有自己的个人主目录/home/xxx，在这些普通用户之外，root是 Linux 中的超级用户，拥有最高的权限。当出现Permission denied时，普通用户可以通过sudo来以 root 权限执行命令

su命令
1
su
这会为你打开一个新的 shell 会话，只要你知道目标用户的密码，可以使用su来切换到 Linux 上的任意用户
如果只输入su，默认会尝试登录 root 用户
不建议长期在 root shell 下执行命令，因为你在此 shell 中的操作不会记录到你个人用户的日志中，尽量使用sudo
sudo
都有哪些用户可以使用sudo呢？实际上，允许使用sudo的用户由配置文件/etc/sudoers决定，编辑此配置文件，Linux 提供了一个专门的命令 visudo
你应该总是通过visudo而不是sudo vim /etc/sudoers来编辑这个文件，前者会进行语法检查确保安全性，以免你把自己锁在sudo权限之外，导致不能再编辑此文件
/etc/passwd
Linux 识别用户和组，是通过UID和GID，每个用户和组都有独特的UID和GID，用户的相关信息存储在/etc/passwd这个文件中，当使用cat查看该文件时，可能会出现很多条目，其中有很多是系统为了隔离权限而创建的用户，例如mysql，并不能直接登录，目前我们暂时只关注人类用户，也就是可以登录的用户
1
2
root:x:0:0:root:/root:/bin/bash
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/usr/bin/zsh
每个条目被用:分隔成了七个字段，分别代表：
- 用户名
- 密码：但为了安全考虑，用x来占位，真实的密码会被加密存储在/etc/shadow中，每个条目仍然以:分隔，第一个字段代表用户名，第二个字段代表加密密码，后面是密码更改日期…有效期…之类的，可以不用在意
- 用户id（UID）：用户的唯一标识符，root 用户的 UID 永远是 0
- 组id（GID）：主组id，每个用户至少需要在一个主组内
  实际上，每个用户在创建之初，系统会自动创建一个组作为该用户的主组，并且组名=用户名，GID=UID
  用户可以退出默认的主组，加入其他主组，除了一个必须的主组外，用户可以自由的加入任意多个附属组
- GECOS 字段，用于添加备注信息，可以不太关注
- 用户目录的绝对路径
- 用户的默认 shell
不建议手动编辑/etc/passwd，Linux 通常会提供其他专用命令来修改用户信息
/etc/group
1
2
root:x:0:
docker:x:988:ubuntu
与/etc/passwd类似，/etc/group的每一行代表一个组，字段用:分隔，分别代表：
- 组名
- 组密码：这是一个历史遗留项，现在的 Linux 版本已经很少使用组密码了，常见x占位符
- 组id（GID）
- 附加成员：显示这个组的附加成员有哪些，主成员不会显示在这里
用户管理命令
- 创建用户和组：核心命令是useradd，下面以创建用户sakura为例说明整个过程：
  1. 先确保系统中没有名为sakura的用户，可以使用id sakura查看
  2. 先创建组，名为 sakura（默认主组名和用户名相同）
    1
    sudo groupadd sakura
    此时，系统会自动为组 sakura 分配 GID，并写入/etc/group，可以看到，这里我的 GID 是 1001
  3. 创建用户 sakura
    1
    2
    3
    4
    5
    sudo useradd \
    -m \
    -g sakura \
    -s /bin/shell \
    sakura
    - -m 表示自动创建用户家目录，相当于：
      1
      2
      3
      mkdir /home/sakura
      cp -a /etc/skel/. /home/sakura/
      chown -R sakura:sakura /home/sakura
      值得注意的是，/etc/skel/目录下的内容是用户的家目录模版，因此每个用户在创建家目录时都会拷贝其中的内容，里面通常包含.profile .bashrc等文件，这意味着我们可以编辑/etc/skel/中的内容来使新建的用户自动继承某些配置，这是一种很常见的做法
    - -g 指定主组，系统会确保 UID = GID
    - -s 指定默认 shell，通常为 bash
    - sakura 用户名
    此时，系统会自动把 sakura 用户的信息写入/etc/passwd
  4. 为 sakura 设置密码
    此时/etc/shadow中显示 sakura 用户的密码栏目为!，表示我们还没有给用户设置密码，该用户暂时无法用于登录
    1
    sudo passwd sakura # 给 sakura 用户设置密码
    设置之后，再次查看/etc/shadow，sakura 加密后的密码已经正常显示
  5. 至此，sakura 用户已经创建成功，其实在 Debian 系等发行版，内置了adduser命令，看起来和useradd很像，但它涵盖了上述 1 ～ 3 的完整步骤，可以方便地直接使用sudo adduser sakura来快速创建用户。然而，在 Arch 系等其他发行版则不提供该内置命令，因此在写脚本的时候需要注意跨平台的问题，useradd仍是更普遍更底层的方式。
- 修改用户 / 组信息
  - sudo passwd sakura：修改 sakura 的密码
  - sudo usermod -g 新组 sakura：修改 sakura 的主组为新组
  - sudo usermod -aG 附加组 sakura：添加附加组，可以把附加组设置为 sudo，赋予 sakura sudo的权限
  - sudo gpasswd -d sakura 组名：把 sakura 从附加组移除
- 删除用户 / 组
  1
  sudo userdel sakura
  这样仅能删除 sakura 用户本身，如果还要删除家目录，加上-r
  1
  sudo userdel -r sakura
  在某些 Linux 的发行版中，如 Debian 系，若用户的主组内只有这一个用户，当用户被删除时，组也会被自动清理。如果你想手动删除一个组，可以用以下命令：
  1
  sudo groupdel sakura

权限

文件权限

  ~/mysrc ❯ ll                                                                              
总计 55M
drwxrwxr-x 3 ubuntu ubuntu 4.0K 10月 19 23:28 boss
drwxrwxr-x 7 ubuntu ubuntu 4.0K  1月  5 18:03 doki
-rw-r--r-- 1 ubuntu ubuntu  55M 12月  2 12:10 go1.25.1.linux-arm64.tar.gz
-rw-rw-r-- 1 ubuntu ubuntu  21K  2月 24 15:23 hello2.txt
-rw-rw-r-- 1 ubuntu ubuntu  20K  2月 24 15:20 hello.txt
drwxrwxr-x 8 ubuntu ubuntu 4.0K 11月 14 16:00 jenkins-demo
drwxrwxr-x 2 ubuntu ubuntu 4.0K 10月 20 12:22 k8s-wordpress
drwxrwxr-x 3 ubuntu ubuntu 4.0K 12月  4 10:26 learn-go
drwxrwxr-x 2 ubuntu ubuntu 4.0K 10月 10 20:45 myk8s
drwxrwxr-x 2 ubuntu ubuntu 4.0K 10月 20 01:17 mynginx
drwxrwxr-x 2 ubuntu ubuntu 4.0K 10月 10 15:43 nu
drwxrwxr-x 3 ubuntu ubuntu 4.0K 12月  4 10:25 project
drwxrwxr-x 4 ubuntu ubuntu 4.0K 10月 13 16:46 tvsos

第一列代表文件类型和权限

1	d \| rwx \| rwx \| r-x

d：目录，-：文件，l：符号链接

r：读取权限，w：写入权限，x：执行权限，-：无权限

三组 rwx 分别代表不同级别的访问权限：

所有者，默认情况下是创建这个文件 / 目录的用户
所有组，默认情况下是创建这个文件 / 目录的用户所在的主组
其他人，指既不是所有者也不在所有组内的用户

更改权限

最常用的命令是chmod

符号模式

u：所有者，g：所有组，o：其他，a：全部

# 为用户添加执行权限
chmod u+x myfile
# 同时为组和其他人添加执行和写入权限
chmod go+rx myfile
# 这样也是合法的
chmod g-x,o-xw myfile # 注意 , 后面不要多加空格
# 不指定 who，会给 ugo 同时加上权限
chmod +x myfile

八进制模式
4 - r，2 - w，1 - x，这样任意几个数字的和都是唯一的
1
2
chmod 664 myfile
chmod 775 mydir
新建的文件的默认权限是664，由于目录需要x权限才能进入，所以一般新建目录的默认权限是775

更改所有权

更改用户所有权

1 2	# 把 myfile 的所有权更改为 sakura sudo chown sakura myfile

更改所有组

1 2	# 把 myfile 的所有组改为 staff sudo chgrp staff myfile

同时更改所有用户和组
1
sudo chown sakura:staff myfile

umask
前面说过，Linux 中默认创建的文件权限是664，目录权限是775，实际上，造成这样的原因是umask的存在，Linux 系统默认把文件的最大权限值当作666（系统默认文件是不可执行的），把目录的最大权限值当作777，当新建文件 / 目录时，权限值会被设定为 最大权限值 - umask
在终端输入umask，可以看到，大部分系统的默认umask是002，因此
新建文件：666 - 002 = 664
新建目录：777 - 002 = 775
换句话说，umask的作用是移除某些权限，你可以在终端中输入umask 021来设置umask的值为 021，但这种更改不是永久的，如果想要永久更改 umask，需要修改.profile 或 .bashrc 等文件，加入以下内容
1
umask 021 # 修改 umask 为 021
一般来说使用默认的 002 就好
SUID与SGID
之前我们说过，可以用passwd更改用户密码，此时系统会更改/etc/shadow中的内容
1
2
  ~/mysrc ❯ ls -l /etc/shadow
-rw-r----- 1 root shadow 1010 2月 24 22:20 /etc/shadow
然而，查看这个文件，发现他的所有者是 root，且只有 root 才有写入权限，为什么我们能通过passwd来更改这个文件的内容呢？
1
2
  ~/mysrc ❯ ls -l /bin/passwd
-rwsr-xr-x 1 root root 72056 5月 30 2024 /bin/passwd
这里发现了一个新的权限位s，这个权限位称为SUID（Set User ID），当其他用户执行这个文件时，SUID将赋予此用户该文件所有者的权限，在这里也就是 root，所以当用户允许passwd时，是以 root 的身份执行的
你也可以用chmod来给自己的文件设置SUID
1
2
3
sudo chmod u+s myfile
# 等价写法
sudo chmod 4755 myfile
SUID可以用4表示，加在权限集的前面，你可能会见到SUID出现大写S的情况，这是无效的写法，表示虽然加了SUID，但是没有给予文件执行权限
类似SUID，SGID（Set Group ID）允许其他用户执行文件时，赋予此用户该文件所有组的成员权限
1
2
3
sudo chmod g+s myfile
# 等价写法
sudo chmod 2755 myfile
SGID的数字表示是2
进程权限
可以读一下这个大致了解 https://labex.io/zh/lesson/process-permissions
粘滞位
在 Linux 中，有这样一个目录/tmp，任何用户都可以访问该目录，并且在该目录下存放 / 修改自己的临时文件
1
2
  ~/mysrc ❯ ls -ld /tmp
drwxrwxrwt 17 root root 4096 2月 25 15:25 /tmp
注意到这里其他用户有一个新的权限位t，表示设置了粘滞位。它的作用是即使所有用户都可以在这个目录自由的读写，但是他们无法对其他用户的文件进行rm操作，这可以防止一个用户干扰另一个用户的工作
1
2
3
4
# 设置粘滞位（只能对目录设置）
sudo chmod +t mydir # 不能写成 o+s
# 等价写法
sudo chmod 1755 mydir
粘滞位的数字表示是1

进程

进程是指在系统上正在运行的程序，由 Linux 内核管理，每个进程会被分配一个唯一的 id，即PID，通常在创建新进程时 PID 会按顺序分配。

ps 输出与当前终端会话相关的进程列表快照

  ~/mysrc ❯ ps                                                                               
    PID TTY          TIME CMD
  68227 pts/0    00:00:03 zsh
  68231 pts/0    00:00:00 zsh
  68260 pts/0    00:00:00 zsh
  68261 pts/0    00:00:00 zsh
  68263 pts/0    00:00:00 gitstatusd-linu
  69183 pts/0    00:00:00 ps

PID：进程唯一 id
TTY：控制该进程的终端
TIME：进程从启动以来，占用 CPU 的总时间，不能代表进程的运行时间，因为大部分时间进程都在睡眠 / 挂起，只有被调度时才会占用 CPU
CMD：启动该进程的命令

ps 的选项有两种不同的风格，常用的组合分别是ps aux和ps -ef，前者作为日常使用，后者则更常见于脚本中

top 进程实时监控
ps是针对某一时刻的进程快照，而top可以实时监控进程资源，每隔几秒便会刷新一次，常用于排查进程占用资源异常
tty
在进程列表中，有一个字段TTY，称为控制终端，在早期的计算机中，人们通过 Teletype（电传打字机）来输入命令和计算机进行交互，tty 得名于此。在现代的 Linux 系统中，tty 指为进程提供标准输入和输出的终端。
终端有两种类型：终端设备和伪终端
- 终端设备
  在 Linux 中，真正的终端设备通常指 虚拟控制台（Virtual Console）。在物理机上直接安装 Linux 后，可以通过 Ctrl + Alt + F1 ~ F6 切换到这些控制台，它们对应 /dev/tty1、/dev/tty2 等设备。此时你会看到只带有命令提示符的黑框框，这些终端由内核直接管理，不依赖图形界面，即使图形系统崩溃，也可以正常登录和操作。
- 伪终端
  伪终端是我们日常最常用的，也称为pty，当我们在图形化的操作系统下打开终端应用程序时，此时出现的黑框框实际上是pty，输入命令ps检查TTY字段，会看到输出为pts/0，pts/1等
这里 pty 和 pts 不是打错了，详细概念可以看：https://dev.to/napicella/linux-terminals-tty-pty-and-shell-192e
这里我开启两个终端会话，查看进程：
可以看到 TTY 的编号分别是 pts/0，pts/1
大多数进程都需要绑定一个控制终端，进程的生命周期与启动该进程的控制终端相关联，终端窗口被关闭时，与之相关联的进程也会被杀死
有一类进程称为守护进程（daemon），他们被设计为在后台运行，管理着某些系统服务，通常只在机器 / 系统关闭时停止，不与控制终端关联，如果你在ps aux中看到部分进程的 TTY 显示一个问号?，这表示该进程没有关联任何控制终端，独立于用户会话运行
有关进程的简单介绍：https://labex.io/zh/lesson/process-details
进程的创建
Linux 中创建进程的现有机制是 fork - exec 模型。首先，现有进程使用 fork 来克隆自身，创建一个和自己几乎一样的子进程，这个子进程会获得自己的唯一 PID ，原始进程则为该进程的父进程，由 PPID 标识
之后，子进程通过 execve 系统来调用或加载一个新程序，有效地用新程序的内存空间替换了继承的内存空间，从而执行新的任务
在ps -ef 或 ps l命令中，PPID 的列代表父进程的 PID
这里可以看到，ps l的 PPID 就是当前 shell 进程的 PID（68227）
如果每个进程都是另一个进程的子进程，那么必然存在一个最初的祖先。这就是 init 进程。系统启动时，内核会创建 init 作为第一个用户空间进程，并为其分配 PID 1。init 进程是所有其他进程的最终父进程，并以 root 权限运行以管理系统。在系统关闭之前，它不能被终止，并且负责启动许多维持系统运行的服务
进程的终止
进程通常通过调用 _exit 系统调用来终止。此操作向内核发出信号，表明进程已完成，其资源（如内存和文件描述符）可以被回收。退出时，进程会向内核提供一个终止状态，这是一个整数值。按照惯例，状态 0 表示成功执行，而非零值表示发生错误
然而，调用 _exit 并不会立即清除进程。父进程必须使用 wait 系统调用来确认其子进程的终止。此调用允许父进程检查子进程的终止状态。这种两步机制对于正确的进程清理至关重要
另外一种终止进程的方式是信号，后续介绍
- 孤儿进程
  如果父进程在子进程终止之前就终止了，那子进程就变成了孤儿进程。由于其原始父进程没办法调用 wait，内核会介入，孤儿进程会立即被一个特殊的系统进程（通常是 init，PID 为 1）收养，该进程被认为是所有进程的祖先。然后 init 进程承担起父进程的角色，定期调用 wait 来收集其所有被收养子进程的终止状态，使它们能够干净地终止
- 僵尸进程
  当子进程终止，但父进程还尚未调用 wait 时，子进程就变成了僵尸进程。内核会释放僵尸进程的大部分资源，但他会在进程表中保留一个条目，包含进程 PID 和终止状态，等待父进程来收集。由于僵尸进程已经死亡，它不会占用 CPU 的资源，你无法使用信号来终止僵尸进程，因为他们根本没在运行。父进程调用 wait 来清理僵尸进程的过程叫做回收，如果父进程不调用wait来回收僵尸进程，虽然不消耗 CPU 资源，但大量僵尸进程会填满进程表，阻止新进程的创建。在父进程也终止的情况下，init 会收养并回收僵尸进程。
- 孤儿进程 vs 僵尸进程
  - 孤儿进程是活动的，正在运行的进程，其父进程已经死亡，他被init收养并继续运行，直到任务完成
  - 僵尸进程是死亡的，它已经完成了要执行的任务，但在进程表中仍然存在一个条目，等待父进程读取回收
  总之，孤儿进程是活着但没有父进程，僵尸进程是死了但没有被父进程回收
信号
在 Linux 中，信号是发送给进程的软件中断，用于通知它发生了重要事件，是进程间通信（IPC）的主要方式之一
- 用户可以在终端输入特殊字符（ctrl + c , ctrl + z）来向前台进程发送停止 / 中断信号
- 内核也可以向进程发送信号，通知发生了软件 / 硬件问题
- 系统管理员和其他进程也可以使用信号管理进程的生命周期
信号生成后，首先传递给目标进程，此时信号处于“待处理”状态，直到内核运行该进程，当进程被调度时，信号被传递。然而，进程具有信号掩码，可以配置掩码来阻止特定信号的传递
当信号被传递时，进程可以采取以下操作：
- 忽略信号：简单地丢弃信号，继续执行任务
- 捕获信号：执行信号处理程序（自定义函数）来响应该事件
- 执行默认操作：当信号没有被忽略或捕获时，则执行默认操作，对于许多信号来说，这意味着终止进程
- 阻塞信号：如果信号在进程的信号掩码中，则信号保持“待处理”状态，直到解除阻塞
常见的信号如下：（都以 SIG 开头）
- SIGHUP (1)：挂断。通常用于告诉守护进程重新加载配置
- SIGINT (2)：中断。ctrl + c，它是终止进程的请求
- SIGKILL (9)：杀死。这是一种立即、强制的终止，该信号无法被忽略、捕获、阻塞
- SIGSEGV (11)：段错误。通知进程进行了无效的内存引用
- SIGTERM (15)：终止。这是一种标准且礼貌的请求进程终止的方式，kill命令默认发送此信号，进程可以捕获此信号，在退出前执行清理工作
- SIGSTOP (19)：停止。立即停止进程，该信号无法被忽略、捕获、阻塞
- SIGTSTP (20)：暂停。礼貌地暂停进程，该信号可以被忽略、捕获、阻塞，暂停后的进程可以恢复
kill
kill命令尽管名称如此，但他不仅仅能向进程发送终止信号，还能发送许多各种信号
1
2
3
kill 12345
# 等价写法
kill -15 12345
这将会终止 PID 为 12345 的进程，他会发送 SIGTERM 信号，这是标准、优雅地终止进程的方式，用于请求进程干净地关闭，给了进程清理和释放资源的机会
有时进程出现无响应，不会对 SIGTERM 信号做出反应，在这种情况下可以使用 SIGKILL 信号强制杀死
1
kill -9 12345
这会立即杀死进程，不给它清理的机会
kill命令后加上数字选项，可以发出各种类型的信号，比如kill -1通知守护进程重新加载配置文件等，你也可以使用信号名称代替数字编号，例如kill -SIGHUP，效果是一样的
一个特殊的用法是kill -0
1
kill -0 12345
这个命令实际上没有发送任何信号，但是可以用来检查 PID 为 12345 的进程是否存在，以及你是否有权限对该进程发送信号
进程优先级
多个进程同时运行时，实际上，CPU 会在不同的进程之间快速切换，为每段进程分配一小段处理时间，称为“时间片”，时间片结束后，进程会被暂停，CPU 会转而执行下一个进程（以单核 CPU 为例）
内核的调度决策可以由进程的 niceness 决定，niceness 决定了一个进程的“友好性”，它用一个数字表示，范围是-20 ~ 19
- 一个进程的 nicenee 比较高，表示该进程十分“友好”，他会先把 CPU 时间让给其他进程，因此该进程的优先级就比较低。换句话说，niceness 与进程的优先级是负相关的，niceness 较小的进程拥有较高的优先级
使用 top 命令实时查看进程状况，其中 NI 列就代表进程的 niceness。大部分进程在创建时，niceness 的值默认为0，我们也可以手动更改和设定进程的 niceness 值
- 以 niceness 为 5 启动 apt update
  1
  nice -n 5 apt update
- 把 PID 为 12345 的进程的 niceness 改为 10
  1
  renice 10 -p 12345
进程状态

使用 ps aux 查看进程快照，你会看到 STAT 列，表示当前的进程状态

R：运行中或可运行。要么正在 CPU 核心上运行，要么在运行队列中，一旦有可用 CPU 核心立刻运行
S：可中断睡眠。最常见的进程状态之一，进程正在等待某个事件的完成，可以被信号唤醒
D：不可中断睡眠。无法被信号唤醒，通常用于 I / O 操作期间，此时中断进程可能导致状态损坏。如果某个进程长期处于该状态，可能表示硬件和驱动存在问题
Z：僵尸进程。
T：停止。如按下ctrl + z挂起的进程或者调试器跟踪的进程，可以用 SIGCONT 信号恢复它

/proc 文件系统
Linux 系统中有一个独特的目录 /proc，这个目录不是硬盘上的真实文件系统，它由内核在内存中创建
1
ls /proc
可以看到，/proc 中有很多带有编号的目录，这些编号代表进程的 PID。还有一些文件例如 cpuinfo 和 meminfo，他们提供系统的硬件信息
如果你知道某个进程的 PID
1
cat /proc/12345/status
此命令将显示有关该进程的详细信息，提供了比其他工具多得多的数据。实际上，像 top、ps等这样的应用程序都会从 /proc 读取数据，并以用户友好的形式展现出来，因此 /proc 目录可能会显示这些工具没有的大量额外细节
你也可以通过读取 /proc 目录来构建你的自定义脚本或监控面板

作业控制

在 Linux 中，你可能会遇到需要等待很长时间才能完成的命令，你不必傻傻等待，让命令占用终端前台而无法使用

要在后台启动一个进程，只需要在命令后面加上一个 &

1
2
3

sleep 1000 &
sleep 1001 &
sleep 1002 &

你在后台启动了三个进程，可以使用 jobs 查看后台正在运行的作业

  ~/m/p/linux-lab/lab-01   main +3 !3 ?2 ❯ jobs    

[1]    running    sleep 1000
[2]  - running    sleep 1001
[3]  + running    sleep 1002

第一列显示了后台作业的 ID，+ 表示最后一个启动的作业，- 表示倒数第二个启动的作业

后台作业，一般只用于跑一个较为耗时的脚本 / 命令时使用，为了不影响前台正常输入命令而用的，通常不适合用于跑长期服务

如果你将一个命令跑在了前台，运行一半的过程中，你想把他转移到后台作业，但又不想重新启动该命令，可以搭配使用 SIGTSTP (ctrl + z) 和 bg 命令

# 前台启动进程
sleep 1003
# 暂停进程
ctrl + z
# 前台启动进程
sleep 1004
# 暂停进程
ctrl + z

# ctrl + z 在暂停进程的同时，还会把这些进程登记到后台作业，使用 jobs 查看
jobs

[1]  - suspended  sleep 1003
[2]  + suspended  sleep 1004

# 使用 bg 来启动后台作业
bg %1 # 启动作业 id 为 1 的后台作业
bg # 不指定则会启动最后一个后台作业

如果你想要把后台作业调回前台，使用 fg 命令，用法与 bg 相同

fg %2

后台作业和前台进程一样，都可以用 kill 来传递信号，如果要终止一个后台作业进程

kill %2
# 其他各种信号也都可以传递
kill -9 %2
kill -20 %2

软件包

软件发行
你可能知道像 chrome 和 firefox 这样的软件名称，在技术层面上，他们实际上是软件包。软件包是一个文件存档，包含应用程序的可执行文件、配置文件、文档等。软件包的供应链中存在两个角色：
- 上游提供者：软件的开发者，他们编译源代码，创建安装说明和发布更新版本
- 软件包维护者：新版本准备好之后，上游提供者会将他们发送给软件包维护者。软件包维护者会审查之后将软件以特定 Linux 发行版的软件包形式分发给用户
虽然你可以直接通过源码编译安装软件，但使用软件包更为高效，如 .deb 、 .rpm 等是常见的软件包形式
软件包存储库
我们可以在官方网站获取软件包，但更为高效的解决方案是使用包管理器，从软件包存储库下载软件包
每个 Linux 发行版有个字不同的包管理器，他们通常会预先配置一组默认的软件包存储库，用于下载系统上的所有基础软件包。
以 Ubuntu 系统为例，旧版本的 Ubuntu 会把软件包的源配置在文件 /etc/apt/sources.list 中，当你使用 apt install 下载软件包时，会读取该文件配置的软件源。但通常会出现 Linux 发行版提供的默认软件包源的软件版本落后的情况，例如安装 docker 时，官方文档建议你手动配置软件源，手动配置的软件源位于 /etc/apt/sources.list.d 目录中。在新版本的 Ubuntu 中甚至默认使用 /etc/apt/sources.list.d 目录作为所有软件源的配置目录，默认的软件源的配置信息被迁移到了 /etc/apt/sources.list.d/ubuntu.source 中
1
2
3
  ~/mysrc ❯ ls /etc/apt/sources.list.d

docker.list jenkins.list ubuntu.sources
使用 apt 安装软件包时，会先读取 *.list 的软件源，如果没有，再从默认源下载
在 Linux 中，软件包很少是独立存在的，他们通常必须依赖其他组件才能正常运行，也就是依赖项。这些依赖项可以是其他包，或者更常见的是共享库，共享库是多个程序可以同时使用的预编译代码集合，可以节省开发人员为每个新应用程序写通用函数。如果软件在安装过程中缺乏所需的依赖项，这些软件包就是损坏的，Linux 包管理器旨在自动处理 Linux 包依赖项，获取并安装他们，防止损坏包的出现

压缩与归档

在 Linux 中，归档与压缩是两步操作

归档：把多个文件 / 目录打包成一个文件
压缩：减小一个文件的大小以节省磁盘空间和加快传输过程

由此可见，归档可以对多个文件 / 目录使用，而压缩是针对一个文件使用的

  ~/mysrc/demodir ❯ tree                                                                                        ubuntu@vmubuntu  09:08:20 上午
.
├── content# 目录
│   └── file3
├── file1
├── file2
└── target# 目录

3 directories, 3 files

压缩

gzip 用于压缩文件，生成一个 .gz 结尾的压缩文件代替原文件

  ~/mysrc/demodir ❯ ls -a                                                                  
.  ..  content  file1  file2  target
  ~/mysrc/demodir ❯ gzip file1                                                             
  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1.gz  file2  target

如果要解压，使用 gunzip

1
2
3

  ~/mysrc/demodir ❯ gunzip file1.gz                                                       
  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1  file2  target

归档

tar 用于将多个文件 / 目录打包成一个归档文件，通常以 .tar 结尾

  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1  file2  target
  ~/mysrc/demodir ❯ tar -cvf myarchieve.tar file1 file2 content                           
file1
file2
content/
content/file3
  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1  file2  myarchieve.tar  target

选项解释：

-c 表示创建归档
-v 表示归档过程中输出详细信息，打印被归档的目录和文件
-f 表示指定目标归档文件（这里的 myarchieve.tar）

如果要提取归档文件，使用 -x 代替 -c

  ~/mysrc/demodir ❯ tar -xvf myarchieve.tar -C target                                     
file1
file2
content/
content/file3
  ~/mysrc/demodir ❯ ls target                                                              
content  file1  file2

提取归档文件通常配合 -C 选项使用，用于指定提取到目标位置

归档与压缩结合使用

最常见的用法是归档与压缩一起使用，先归档再压缩，创建 .tar.gz 文件，Linux 也为我们提供了快捷的命令

  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1  file2  target
  ~/mysrc/demodir ❯ tar -czvf myfile.tar.gz file1 file2 ./content                         
file1
file2
./content/
./content/file3
  ~/mysrc/demodir ❯ ls -a                                                                 
.  ..  content  file1  file2  myfile.tar.gz  target

这里的 -z 选项表示在创建归档之后使用 gzip 压缩

  ~/mysrc/demodir ❯ tar -xzvf myfile.tar.gz -C target                                     
file1
file2
./content/
./content/file3
  ~/mysrc/demodir ❯ ls target                                                             
content  file1  file2

这里的 -x 选项表示提取归档之前使用 gzip 解压，同样这里可以用 -C 指定解压到目标路径

dpkg 与 rpm
如果要直接安装软件包，而不是通过包管理器安装，你可以在软件官网上找到 .deb 或 .rpm 文件，下载后通过以下命令安装：
1
2
# Debian 系统
dpkg -i nginx.deb
-i 选项表示下载，你也可以用长选项 --install 代替
如果要移除下载的软件
1
2
3
4
# 删除软件
dpkg -r nginx
# 删除软件及其相关的配置文件（更彻底）
dpkg -P nginx
实际上，不管是通过包管理器还是手动从 .deb 文件下载的软件，都可由包管理器进行管理，使用 dpkg -l 列出所有已安装的包，他们都可以通过包管理器删除，更为干净彻底，自动处理依赖
1
2
3
4
# 删除软件
sudo apt remove nginx
# 彻底删除
sudo apt purge nginx
包管理器
以 Debian 系操作系统为例，使用 apt 包管理器
安装与删除
1
2
sudo apt install nginx
sudo apt remove nginx
值得注意的是，使用 apt 包管理器下载 / 更新软件之前更新软件源索引是个好习惯
1
2
3
4
# 更新软件源索引
sudo apt update
# 更新软件
sudo apt upgrade
update 只是更新了仓库源，真正更新软件的是 upgrade，upgrade 是保守更新，在不影响正常服务 / 不改变依赖的情况下对软件升级，不会出现跨大版本更新导致服务 / 配置失效的情况，只会更新向后兼容的小版本（尽管如此在开发中尽量不要全局使用 apt upgrade）
从源码编译下载
某些软件可能只提供从源码编译的下载方式，掌握如何编译源码来下载软件是必要的，这里以下载 GNU Hello 为例演示从源码编译的步骤。GNU Hello 是一个非常轻量的软件，它的作用仅仅是输出 Hello World，为教学编译使用，大部分 Linux 的发行软件的编译过程都与此类似（不过查看 README 总是好的）
- 下载工具 build-essential（如果你没有的话）
  1
  2
  sudo apt update
  sudo apt install build-essential
  这个软件包括了一套软件开发工具，有 gcc 编译器 make 应用程序等，对编译代码至关重要
- 下载源码并解压
  1
  2
  3
  wget https://ftp.gnu.org/gnu/hello/hello-2.12.tar.gz
  tar -xzvf hello-2.12.tar.gz
  cd ./hello-2.12 # 后续操作在软件项目根目录下执行
- 执行 ./configure 脚本
  1
  ./configure
  开发者会提供 ./configure 脚本，他会运行一小段简单的程序，来检查你的机器上是否有该软件运行所必须的依赖，如果缺少依赖项，你需要在继续安装之前补全他们（不用看 yes / no，如果缺失依赖会报错 error 的），然后生成 Makefile，其中包含了关于如何将源代码编译成可执行程序的规则
- 执行 make
  1
  make
  读取 Makefile，确认编译内容和顺序，然后执行编译，生成各种可执行文件和目标程序
- 安装软件
  软件编译成功后，还需要安装到系统上，有两种安装方式，传统的安装方式是继续输入 sudo make install，系统会把编译后的文件复制到合适的目录下，但他有一个明显的缺点：这样安装的软件不会被注册到包管理器中，难以管理。因此，更好的方法是使用 checkinstall
  checkinstall是一个第三方工具，你得先在你的系统上安装它
  1
  sudo apt install checkinstall
  执行安装
  1
  sudo checkinstall
  它的原理是利用编译后到文件创建一个 .deb 包，然后安装这个应用
  执行命令后，会输出一系列类似安装引导的文字，交互后即可成功安装
- 检查是否安装成功

5.给服务器配置代理

2025-11-14T03:47:00.000Z

给服务器配置代理

今天在服务器上部署项目时依旧遇到了国内服务器无法访问境外镜像资源的情况，由于已经遇到很多次了，所以本篇文章就来详细记录一下如何给服务器配置代理，避免大家踩坑。当然我的方案只是一种折中的方案，后续有精力再去折腾其他方案。

基础环境

一台PC设备，操作系统任意，需要在本地PC上运行clash代理（我的端口是7897，根据个人情况会有所不同，请自己调整端口）。
一台服务器，有公网ip。
配置了服务器与本地PC的ssh连接与免密登录（最好是在~/.ssh/config文件里写个Name，方便使用，后续就不用写username@的形式了，也无需输入密码）。

原理说明

在服务器上配置http/https代理，将流量转发至服务器的7897端口。
通过ssh隧道连接，建立与本地PC的端口映射，将服务器7897的流量转发至本地PC的7897端口（由于本地PC无公网ip，服务器想要与其通信这里采用ssh隧道的方式）。

服务器操作

配置环境变量（注意端口换成你自己的）。

# 配置http与https流量 走clash系统代理 后面端口为clash运行端口
export http_proxy=http://127.0.0.1:7897
export https_proxy=http://127.0.0.1:7897
export no_proxy=127.0.0.1,localhost

直接在终端输入，退出终端作用域就无了，想要长期保存可以写在.zprofile/.bash_profile/.zshrc/.bashrc中，根据自己的shell选择（其实profile和rc文件写哪个都可以，之前看到过一篇帖子详细讲二者区别的，这里不细说了，平时习惯用哪个就写哪个吧，想要分清楚的可以去google一下）。

本地PC操作

运行clash（最好把局域网连接也打开）。
建立ssh隧道（注意是-R不是-L，不要转发反了）。

1	ssh -R 127.0.0.1:7897:127.0.0.1:7897 -N

注意端口和servername换成你自己的。

这里ssh隧道是挂在终端前台运行的，这里给出一个bash脚本，大家可以复制下来保存到serverClash.sh文件中，方便后台运行，以及启动/关闭ssh隧道（注意端口和servername换成你自己的）。

#!/bin/bash

TUNNEL="ssh -R 127.0.0.1:7897:127.0.0.1:7897  -N"
PID_FILE="$HOME/.ssh_tunnel.pid"

start() {
    if [ -f "$PID_FILE" ] && kill -0 $(cat "$PID_FILE") 2>/dev/null; then
        echo "⚠️ 隧道已在运行中，PID=$(cat "$PID_FILE")"
        exit 0
    fi
    $TUNNEL &
    echo $! > "$PID_FILE"
    echo "✅ 隧道已启动，PID=$(cat "$PID_FILE")"
}

stop() {
    if [ -f "$PID_FILE" ]; then
        kill $(cat "$PID_FILE") && rm "$PID_FILE"
        echo "🛑 隧道已停止"
    else
        echo "⚠️ 隧道未运行"
    fi
}

status() {
    if [ -f "$PID_FILE" ] && kill -0 $(cat "$PID_FILE") 2>/dev/null; then
        echo "✅ 隧道正在运行，PID=$(cat "$PID_FILE")"
    else
        echo "⚠️ 隧道未运行"
    fi
}

help() {
    echo "================= SSH 隧道管理脚本 ================="
    echo "用法: $0 {start|stop|status|restart|help}"
    echo ""
    echo "start    - 启动 SSH 反向隧道"
    echo "stop     - 停止 SSH 反向隧道"
    echo "status   - 查看隧道当前状态"
    echo "restart  - 重启 SSH 反向隧道"
    echo "help     - 显示此使用说明"
    echo "===================================================="
}

case "$1" in
    start) start ;;
    stop) stop ;;
    status) status ;;
    restart) stop; start ;;
    help) help ;;
    *) echo "⚠️ 参数错误或未提供参数"; help ;;
esac

给脚本添加执行权限

1 2	chmod +x serverClash.sh # 可以使用 ./serverClash.sh help 查看使用方法，很easy

验证代理

在服务器上curl一下google

1	curl -I https://www.google.com

（ping不通是正常的，ping的ICMP是网络层协议，clash代理是工作在传输层TCP / UDP以上的，所以ping根本不会走代理端口，是直接由内核转发出去的）

给docker配代理

docker拉取镜像默认是不会走http / https代理的，docker命令输⼊到shell后，是由docker客户端将请求转发给docker服务器 docker daemon 去执⾏，它并不会读取环境变量中http_proxy的配置。所以我们要给docker daemon也配个代理。

Docker daemon 的代理配置文件放在：

1	/etc/systemd/system/docker.service.d/http-proxy.conf

如果目录不存在，先创建：

1	sudo mkdir -p /etc/systemd/system/docker.service.d

写入配置：

sudo tee /etc/systemd/system/docker.service.d/http-proxy.conf > /dev/null << EOF
[Service]
Environment="HTTP_PROXY=http://127.0.0.1:7897"
Environment="HTTPS_PROXY=http://127.0.0.1:7897"
Environment="NO_PROXY=localhost,127.0.0.1"
EOF

注意换成你自己的端口

让 Docker 重新加载配置

1 2	sudo systemctl daemon-reload sudo systemctl restart docker

测试是否成功走代理
运行：

1	docker pull hello-world

如果能拉下来，说明 docker daemon 已经成功走代理。

4.计网-交换机VLAN工作原理

2025-10-07T08:12:00.000Z

交换机的VLAN是如何工作的？

一篇文章，用最通俗的人话，带你了解交换机VLAN的工作原理TvT！

什么是交换机？

交换机，工作在五层参考模型中的数据链路层，用于局域网内的设备通信，负责转发数据帧的网络设备。

交换机是一种即插即用的网络设备，无需管理员手动分配，它会自动维护一张MAC地址表，关联连接设备的MAC地址与自己的端口。交换机从端口接收数据帧，查看数据帧的目标MAC地址，根据MAC地址表，选择合适的端口发送数据帧。

如果MAC地址表中不存在目标设备的MAC地址，交换机则会通过广播的形式发送数据帧到所有连接设备，交换机是通过观察流量的源MAC地址来学习的，因此如果目标设备收到了目的地是自己MAC地址的数据帧，会返回一个响应帧，交换机根据这次发送的源MAC地址来学习，把目标MAC地址和端口号加入到MAC地址表中，与此同时记录的还有更新时间，如果长时间无通信，该条数据将会由超时机制被从MAC地址表中移除。

什么是VLAN？

Virtual Local Area Network（VLAN），即虚拟局域网。这里从VLAN的用途，逐步详细介绍VLAN的工作原理，最后会涉及一个小练习，如果你能成功完成它，代表你已经成为VLAN高手了！

VLAN——将一个物理交换机分割成多个虚拟交换机

我们知道，交换机用于同一个局域网内的设备间的通信；类似路由器用于局域网网络之间的通信一样。

这里有三个局域网，通过两台路由器连接，每个局域网中的设备通过交换机连接，如果每个交换机上有24个端口，但只有两个端口被使用了，剩下的22个端口不就被浪费了吗？

明明一个交换机的端口数量，已经绰绰有余了，但这里我却用了三个交换机。如果我想搭建这样一个网络模型，能不能只使用一个交换机呢？

当然是可以的，这就需要用到VLAN技术了，它允许你把一个物理交换机划分为多个虚拟交换机。

这个网络结构与之前的完全相同，路由器的配置和运行方式也一模一样。

每个虚拟局域网，即VLAN，仅仅是一个给端口号数字标记，例如：红色虚拟交换机上的两个端口被标记为VLAN #10，黄色虚拟交换机上的两个端口被标记为VLAN #20，蓝色虚拟交换机上的两个端口被标记为VLAN #30。

那么其他没有被特别标记的端口，都属于默认VLAN，一般是VLAN #1。

每个VLAN是一个虚拟局域网，如果流量没有经过路由器的转发，即使是在同一个交换机上的端口，也无法跨局域网通信。例如，A发送的数据包，在未经路由器转发时，只能由VLAN #10这个局域网内的设备收到，不可能神奇的出现在VLAN #20，VLAN #30其他局域网中。

那么，问题来了，交换机是如何知道来自一个设备的流量，都需要转发到哪些端口呢？

为了实现这一目标，每个交换机都维护一个MAC地址表，该表是连接到每个交换端口的MAC地址的映射。支持VLAN的交换机还会在每个 MAC 地址表的条目中包含 VLAN #。

一个支持 VLAN 的交换机的 MAC 地址表中的单个条目的简单表示为： VLAN# | MAC Address | Port 。

如果主机A发送一个目标MAC地址为主机 B 的数据帧，那么这个数据帧仍然只会被发送到 VLAN #10 的交换机端口上。即使MAC地址表中存在与 VLAN #30 相关的主机 B 条目，但不在一个局域网内，就无法直接发送。

VLAN——将虚拟交换机扩展到多个物理交换机上

VLAN的强大功能不止上面如此，此外，他可以将虚拟交换机扩展到多个物理交换机上。

这里将两个交换机连接起来，例如设备A和C，虽然他们连接到了两台不同的交换机，但他们都在VLAN #10中，因此，主机A发送的流量，无需经过路由器，就可以被主机C接收。

这意味着，单个VLAN可以跨越物理地域限制，例如：我在7号楼，你在8号楼，我们的设备连接的是不同的交换机，但我们仍然可以在同一个局域网VLAN #10中，进行局域网内的通信。单个VLAN可以跨越多个房间、楼层或办公楼。

Access VS Trunk

上面我们介绍的情况，交换机的端口都属于acceess端口，access端口是只属于一个 VLAN 的交换机端口。

当将端口配置为access端口时，管理员也会指定该端口所属的VLAN编号。每当交换机在access端口上收到任何流量时，它就会将该流量转发到配置的VLAN中。

上面的例子中，两台交换机连接时，我们注意到VLAN #10和VLAN #30分别用网线进行了一次连接。

想象一下，如果我们的拓扑使用了十个VLAN，在一个有24个端口的交换机上，几乎有一半的端口会被用于交换机之间的链路。

这也太浪费了吧，能不能让两个交换机的所有VLAN流量，都通过一对端口来进行转发呢？

实际上，这种端口是存在的，称为trunk端口，它允许单个交换机端口承载来自多个VLAN的流量。

采用trunk端口，我们的拓扑模型可以简化成这样。大大减少了端口的浪费，在实际应用中，通常，连接到终端设备（如工作站、打印机、服务器）的交换机端口配置为access端口。相反，连接到其他网络设备的交换机端口配置为trunk端口（如其他交换机、路由器）。

交换机上的一个trunk端口可以接收多个VLAN的流量。例如，在上面的图中，两个交换机之间的链路正在传输 VLAN 10 和 VLAN 30 的流量。

但在两种情况下，流量都是以一系列帧的形式离开一个交换机，并以一系列帧的形式到达另一个交换机。这就引出了一个问题：接收交换机将如何确定哪些帧属于 VLAN #10 ，哪些帧属于 VLAN #30 ？

这就引出了trunk端口的核心作用，“打标签”。

为了解决这个问题，每当交换机通过trunk端口发送帧时，它会在每个帧中添加一个标签，以告知另一端该帧属于哪个 VLAN。这使得接收交换机能够读取 VLAN 标签，从而确定传入流量应该关联到哪个 VLAN。

相比之下，access端口只能承载或接收单个 VLAN 的流量。因此，离开access端口的流量无需添加 VLAN 标签。换句话说，access端口根本不认识VLAN标签，由access端口发送的流量都是不带有VLAN标签的，看起来就好像是它做了“标签清零”的功效一样。

之前我们提到access端口通常用于终端主机设备，如工作站、打印机或服务器，这使得主机可以无需了解其连接的 VLAN 信息即可运行。从某种意义上说，主机有意地对 VLAN 的存在或使用完全不知情。主机无需关心交换机VLAN的使用情况，主机只是在网络上发送数据，而无需了解 VLAN 或它们可能连接的交换机。

因此，按通常的惯例来讲，到达主机的流量应该不能带有VLAN标签，有些主机能够接收带有 VLAN 标签的帧，而有些主机则不能——这取决于主机是否理解 802.1q VLAN 标签。（大部分主机都是不能的，部分服务器，虚拟机，专用网卡可以）（VLAN 标签的确切格式由 802.1Q 标准规定。这是一个开放式的 IEEE 标准，是当今普遍使用的 VLAN 标签方法。你可能也会见到 ISL 等，这属于较旧的 VLAN 标记方法，现在几乎已经不再使用了。）

比较特别的一个例子是，如果单个物理主机托管多个虚拟机（VMs）。某些情况下，这些 VM 中的每一个都需要存在于不同的 VLAN 中。因此，物理主机必须连接到一个 trunk 端口，并且必须发送和接收 VLAN 标签，以便将虚拟机流量限制在特定的 VLAN。

Native VLAN

这是一个很容易混淆的概念，前面我们说过，trunk端口在发送帧的时候，会向帧中添加一个标签，但这里有个例外，当trunk端口收到了来自Native VLAN的数据帧的时候，不会为这个数据帧打标签，我们结合这个例子来看：

每个trunk都会有一个Native VLAN，这样做的原因是如果trunk端口接收到了来自另外一个trunk端口的数据帧，但该数据帧又不带有VLAN标签，trunk端口就会难以判断这个数据帧要发送到哪个局域网内，此时，这个trunk端口将不会再为该数据帧打上标签，而是默认这个数据帧属于Native VLAN，直接把它转发到Native VLAN局域网中。

因此，确保中继端口的两端配置相同原生 VLAN 至关重要。如上图：

若A向C发送了一个数据帧，由于主机与交换机之间的端口是access，该数据帧不带有VLAN标签，当数据帧到达x交换机的trunk端口后，发现是从VLAN 22传来的数据帧，该数据帧恰好是trunk端口的Native VLAN，于是trunk端口没有为这个数据帧打VLAN标签，就直接转发给了交换机y，交换机y收到了该数据帧，发现没有VLAN标签，前面说过，trunk接收到了来自trunk且没有VLAN标签的数据帧，则接受trunk认为这个数据帧是来自自己的Native VLAN的，即VLAN 33，于是它只会在VLAN 33内转发，此时，设备C就无法按照预期收到数据帧，甚至更为严重的是，设备D可能会意外的收到这份数据帧！

所以简单记忆：

access去除标签
trunk添加标签
例外：trunk收到来自Native VLAN的数据帧时不添加标签，trunk收到来自trunk且无标签的数据帧时默认它属于Native VLAN，在Native VLAN内转发

小练习

问题：如果A对所有设备发送广播，有哪些设备能收到？

答案：C，F，H，I，B

主机 J 和主机 K 也会收到广播，但当它们接收到帧时，该帧将包含 VLAN 标签。有些主机能够接收带有 VLAN 标签的帧，而有些主机则不能——这取决于主机是否理解 802.1q VLAN 标签。

解析：设备A发送的数据帧从A3发送，不带有标签，在swT内会被转发到A3和trunk端口，即A3，T7。因此设备C可以接收到，T7发送该数据帧到swV时，会为它带上VLAN 3的标签，T5收到该数据帧，在swV内转发给A3端口和trunk端口，即A3。数据帧的标签在经过access时会被去掉，因此设备F可以正常接收到数据帧。同时，数据帧被swV从A3端口发送给swX，swX的A4端口接收到该数据帧，只能把它发送给A4和trunk端口，即A4，T4。此时设备H能正常接收到这个不带有标签的数据帧，数据帧被swX通过T4转发到swY，T4为数据帧添加了VLAN 4标签，但到达swY时，该标签又被A6去除，A6把数据帧转发给A6和trunk，即T4，T6。T4会为该数据帧加上VLAN 6标签，前面说过，绝大多数设备无法接收带有标签的数据帧，因此J无法正常接收。但T6的Native VLAN恰好是VLAN 6，因此T6不会再为数据帧加上VLAN 6标签，到达设备I的是不带有标签的数据帧，因此设备I可以正常接收。swY把数据帧由T6转发给swZ，swZ经A9接收后数据帧不带有标签，转发给A9和trunk，即A9，T8，由于T8会为数据帧添加上VLAN 9的标签，设备K无法正常接收，而设备B连接的端口是access端口，到达设备B的数据帧不带有标签。综上，能正常收到数据的设备有C，F，H，I，B。

参考文献

Virtual Local Area Networks (VLANs)

感兴趣的友友可以去阅读一下原文，写的更详细。

3.搭建个人VPN

2025-09-28T07:12:00.000Z

如何搭建一个个人VPN呢？

想要科学（？）的使用网络，往往有两种方式，代理（proxy）or 私有局域网（VPN）

什么？你的梯子又双挂了，为什么不搭建一个自己的VPN呢？

本篇文章仅供计网知识学习交流使用

租借一个海外的服务器

首先，你需要有一台海外/香港等地区的服务器，确保服务器可以正常访问海外网站即可。

云服务厂商推荐：

国内：阿里云/腾讯云（推荐腾讯云锐驰型，公网流量不会额外收费）
国外：vultr

购买国外服务器需要国际支付方式，推荐：海外银行卡/PayPal。

（国内银行卡好像也可以试试，但我试的不太行，换了两张卡都被海外厂商封掉了跨境交易…）

服务器配置买最低的即可，服务器只用来做流量转发，配置太高只会浪费。

搭建VPN

本教程采用WireGuard工具来搭建，大家也可以选择其他的。

服务器操作系统为ubuntu，客户端操作系统为macOS。（windows可以使用wireguard官方的图形化工具）

安装WireGuard

登录到服务器，安装wireguard。

1 2	sudo apt update sudo apt install -y wireguard

生成服务器密钥对

更改文件权限，确保新建的文件只有自己的用户可以访问。

umask 077

1 2	mkdir wireguardkey cd ~/wireguardkey

生成服务端密钥对，将公钥和私钥保存到这两个文件中，这两个key文件会生成于你所在的目录下。

server_private.key：私钥，写入配置文件。
server_public.key：公钥，给客户端用。

1	wg genkey \| tee server_private.key \| wg pubkey > server_public.key

开启内核转发。

1	sudo vim /etc/sysctl.conf

输入/进行查找 or 添加以下内容：

1 2	net.ipv4.ip_forward=1 net.ipv6.conf.all.forwarding=1

之后保存退出，用以下命令使修改生效：

1	sudo sysctl -p

生成客户端密钥对

创建目录wireguardkey，切换到该目录下。
安装WireGuard命令行工具。

1	brew install wireguard-tools

和服务端类似，生成客户端密钥对。

client_private.key：私钥，写入客户端配置。
client_public.key：公钥，要写到服务器配置里。

1 2	umask 077 wg genkey \| tee client_private.key \| wg pubkey > client_public.key

将密钥写入配置文件

编辑服务器配置文件：/etc/wireguard/wg0.conf

[Interface]
Address = 10.0.0.1/24, fd86:ea04:1115::1/64
ListenPort = 51820
PrivateKey = 

# IPv4 NAT
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT
PostUp = iptables -A FORWARD -o wg0 -j ACCEPT
PostUp = iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o eth0 -j MASQUERADE

# IPv6 转发
PostUp = ip6tables -A FORWARD -i wg0 -j ACCEPT
PostUp = ip6tables -A FORWARD -o wg0 -j ACCEPT
PostUp = ip6tables -t nat -A POSTROUTING -s fd86:ea04:1115::/64 -o eth0 -j MASQUERADE

# 下线清理
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT
PostDown = iptables -D FORWARD -o wg0 -j ACCEPT
PostDown = iptables -t nat -D POSTROUTING -s 10.0.0.0/24 -o eth0 -j MASQUERADE

PostDown = ip6tables -D FORWARD -i wg0 -j ACCEPT
PostDown = ip6tables -D FORWARD -o wg0 -j ACCEPT
PostDown = ip6tables -t nat -D POSTROUTING -s fd86:ea04:1115::/64 -o eth0 -j MASQUERADE


[Peer]
# 这是客户端的信息
PublicKey = 
AllowedIPs = 10.0.0.2/32, fd86:ea04:1115::2/128

把换成你的server_private.key内容
把换成你的client_public.key内容
把eth0换成你的服务器外网网卡名（可用ip route查看，显示dev eth0就表示eth0是外网网卡）

编辑客户端配置文件：/opt/homebrew/etc/wireguard/wg0.conf

[Interface]
Address = 10.0.0.2/24, fd86:ea04:1115::2/64
PrivateKey = 
DNS = 8.8.8.8, 2001:4860:4860::8888

[Peer]
PublicKey = 
Endpoint = :51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25

把换成client_private.key 内容
换成服务器生成的 server_public.key 内容
换成服务器的公网ip
⚠️注意：如果你的服务器不支持ipv6，需要把[Peer]中的AllowedIPs = 0.0.0.0/0, ::/0更改为AllowedIPs = 0.0.0.0/0

启动服务

在启动服务前，请检查你的服务器防火墙或者是云服务商的安全组，确保51820端口的UDP流量是开放的。

在服务器执行：

1 2	sudo systemctl start wg-quick@wg0 sudo systemctl enable wg-quick@wg0

启动服务，指定wg0配置文件，并设置为开机自启，可用sudo systemctl status wg-quick@wg0查看服务状态。

在客户端执行：

开启VPN服务：

1	sudo wg-quick up wg0

关闭VPN服务：

1	sudo wg-quick down wg0

验证服务

按照上面的流程，你的VPN服务应该已经可以正常运行了。

可以使用以下方法验证一下：

ping一下google
检查自己的ip地址是不是服务器的ip：curl ifconfig.me

2.初始化multipass虚拟机

2025-09-24T07:07:00.000Z

如何初始化一个multipass虚拟机？

包含zsh主题配置，ssh连接，root登录，基本配置等。

以macOS为例，windows的操作也类似，部分目录结构有差别。

新建一个multipass虚拟机

1	multipass launch --name vmubuntu --cpus 2 --memory 4G --disk 40G

其中：

name：你的虚拟机名称
cpus：分配的cpu个数
memory：内存
disk：磁盘大小

创建成功后，可以使用multipass ls来查看所有的虚拟机实例，镜像，和运行状态。

如果想要查看某个虚拟机的具体配置，请使用multipass info 。

虚拟机创建后默认是开机自启的，可以使用multipass start 和multipass stop 来控制虚拟机的启动与关闭。

使用multipass shell 来进入到你的虚拟机实例。默认用户为ubuntu。

配置ssh连接

安装openSSH

multipass默认是最新版本的ubuntu镜像，它也仅支持这一种操作系统，因此非常轻量级。

首先，你需要先进入虚拟机实例，安装openSSH服务。

1 2	sudo apt update sudo apt install openssh-server -y

启动ssh服务并设置为开机自启。

1 2	sudo systemctl start ssh sudo systemctl enable ssh

可以使用下列命令查看启动状态。

1	sudo systemctl status ssh

结果显示active(running)表示服务正在运行，enable表示开机自启配置成功。

配置虚拟机服务端ssh连接

multipass默认会禁用作为服务端的ssh连接，我们需要修改一些配置。

当你想要通过宿主机使用ssh连接到虚拟机时，此时虚拟机作为服务端，你的物理机作为客户端。

配置虚拟机作为服务端ssh连接，需要编辑以下文件。

1	sudo vim /etc/ssh/sshd_config

vim编辑器中，切换到命令模式，使用/来进行搜索，键入搜索内容，用N,n来切换匹配项，我们需要改的有四个：

PermitRootLogin yes              # 允许 root 登录
PasswordAuthentication yes       # 允许密码登录
PubkeyAuthentication yes         # 允许密钥登录
KbdInteractiveAuthentication yes # 允许交互认证

之后保存，退出，重启ssh服务来使配置生效。

1	sudo systemctl restart ssh

我们还需要用以下命令来为用户设置密码。

1 2	sudo passwd root sudo passwd ubuntu

之后使用exit退出虚拟机，尝试ssh连接。

1 2	ssh root@ ssh ubuntu@

现在可以登录成功了，但每次需要输入密码，还是有点麻烦，接下来来配置一下ssh密钥，实现免密登录。

ssh免密登录

切换到你的宿主机终端，执行以下命令生成ssh密钥对，-f后面跟的是你要保存的密钥文件位置。

1	ssh-keygen -t rsa -b 4096 -C "your_email@example.com" -f ~/.ssh/id_vmubuntu

之后一路回车即可，会在~/.ssh目录下生成密钥对。

接下来编辑宿主机~/.ssh目录下的config文件，加入以下配置。

Host vmubuntu
    HostName 
    User 
    IdentityFile ~/.ssh/id_vmubuntu

如果你是macOS，请确保你在该文件中已经添加了下列全局配置。

1
2
3

Host *
    UseKeyChain yes
    AddKeysToAgent yes

之后进入虚拟机，编辑以下文件：

1	sudo vim ~/.ssh/authorized_keys

这里是你放公钥的地方，但你可能会发现里面已经有一个ssh公钥了，原因是实际上当你使用multipass shell 连接到虚拟机时，实际上他的底层是ssh连接，当你创建一个虚拟机时，会自动配置这对ssh密钥，你可以选择保留它（建议保留），在后面添加你自己的ssh密钥即可。

之后使用ssh 就可以直接连接了。

配置zsh

multipass的默认终端是bash，接下来我们把它修改为zsh，并配置好看的主题和代码补全插件。

下载字体

当你连接到虚拟机时，此时你的终端并没有改变，因此默认还会使用你终端的字体，你可以使用系统自带的终端或者是vscode的终端等等，强烈建议下载nerd字体，便于p10k主题图标和字体的正确渲染。

如果你是windows用户或者ubuntu桌面版用户，建议去官网下载，解压到你的字体目录中。
如果你是macOS用户，通过brew下载或者在官网下载都是可以的，默认会放进你的字体目录中。

官网：nerd fonts

之后在终端设置中选择字体MesloLGS Nerd Font Mono即可。

安装zsh

首先使用以下命令查看自己的可用shell中是否有zsh，有的话就可以跳过这一步了。

1	cat /etc/shells

没有的话需要用以下命令安装：

1	sudo apt install zsh -y

安装之后用以下命令把zsh设置为默认终端：

1	chsh -s $(which zsh)

退出你的虚拟机，重新登录后即可生效，你会进入zsh的欢迎界面，这里会让你选择.zshrc的配置方式，先选择0即可，后续配置主题时还会修改。

也可以使用以下命令检查：

1 2	echo $SHELL # 输出默认shell ehco $0 # 输出当前所在shell

安装on-my-zsh

on-my-zsh是一个强大的终端工具，可以配置各种插件和主题，下面我们来安装p10k主题，代码补全和高亮提示。

在这之前，你需要先配置代理，否则可能会下载的很慢（你也可以去网上自己找镜像源）。

编辑~/.profile文件，添加以下内容，clash需要打开局域网模式。

顺便把语言中文也配置一下。

sudo apt update
sudo apt install language-pack-zh-hans -y
sudo locale-gen zh_CN.UTF-8
sudo update-locale LANG=zh_CN.UTF-8 LANGUAGE=zh_CN:zh LC_ALL=zh_CN.UTF-8

# 配置代理
export http_proxy=http://<宿主机局域网ip>:
export https_proxy=http://<宿主机局域网ip>:

# 修改系统语言为中文
export LANG=zh_CN.UTF-8
export LANGUAGE=zh_CN:zh
export LC_ALL=zh_CN.UTF-8

使用source .profile使修改内容生效。

使用下述命令下载on-my-zsh：

1	sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

接下来下载主题和插件：

在这之前先更新一下你的git版本

1
2
3

sudo apt update
sudo apt install git -y
sudo apt upgrade git -y

# powerlevel10k主题
git clone https://github.com/romkatv/powerlevel10k.git $ZSH_CUSTOM/themes/powerlevel10k
# zsh-autosuggestions自动提示插件
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
# zsh-syntax-highlighting语法高亮插件
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

编辑~/.zshrc文件，启用你的插件和主题，修改一下内容：

# 修改主题
ZSH_THEME="powerlevel10k/powerlevel10k"

# 启用插件
plugins=(
  git
  zsh-autosuggestions
  zsh-syntax-highlighting
)

使用source ~/.zshrc使修改生效。

接下来你会进入p10k主题的引导设置界面，按照自己喜欢的设置即可，如果没有进入，可以通过以下命令进入：

1	p10k configure

于是，你就得到一个好看的shell了！

1.网站介绍

2025-08-25T02:17:00.000Z

welcome to kirito の site！

你好！👋

我非常高兴欢迎你来到我的个人空间，在这里我将分享我整理的笔记、经验和见解。无论你是同样领域的爱好者、寻求新想法的人，还是仅仅是来探索的朋友，这个博客将为你提供有价值的资源和思考。

为什么要写这个博客？

在这个信息爆炸的时代，信息过载已经成为一个现实的挑战。我的目标很简单：创建一个空间，将复杂的概念拆解成易懂的知识，分享个人经验，释放知识的流动。

在这里，你将找到涵盖多种主题的文章：

技术笔记 🖥️
从开发技巧、教程，到软件推荐。

个人心得 💭
关于生产力、创意和开发小窍门的感悟。

学习与挑战 📚
从失败和成功中总结的经验教训。

你能得到什么？

我将主要写下我所学到的内容——工具、方法、策略和经验，目的是帮助他人提高、学习，或者激发灵感。这不仅是我整理个人思考的方式，也是我希望能帮助到其他人的一种分享方式。

关于我

我是热心网友宁桑/kirito，一个充满热情的geek。我花了无数小时学习技术、阅读、实验，有时也会失败。这个博客是我记录这个过程，并希望将其分享给你的方式。

敬请期待

我会定期发布文章，欢迎你关注、分享你的想法，并希望我们能一起学习和成长。

感谢你的来访！🙏

联系方式与社交

如果你想联系我，合作，或只是打个招呼，欢迎你在下方评论留言，或者访问“关于”界面以获取我的联系方式

让我们开始吧！🚀

在接下来的文章中，我会分享一些实用的技巧，特别是面向初学者的内容，欢迎和我一起探索开发的乐趣，望这个网站能成为你学习和成长的一部分，期待与你一起交流和进步！