运维 on 吾爱主机

TLS 1.3 握手与证书链校验：原理、流程与工程排查

Sat, 25 Jul 2026 00:00:00 +0800

线上偶发 “证书不受信任”“握手失败”“只能 HTTP 能开、HTTPS 间歇 525”，根因往往不在业务代码，而在 TLS 握手协商 与 X.509 证书路径校验。浏览器地址栏的小锁背后，是一次版本/密码套件协商、密钥交换、身份证明和密钥确认；服务端 PEM 链顺序错一环，客户端就会在完全不同的报错路径上失败。

本文基于 RFC 8446（TLS 1.3）、RFC 5280（PKIX 证书与路径校验），并对照 MDN 的 TLS/HTTPS 说明、OpenSSL s_client 与 Nginx ngx_http_ssl_module 官方文档，把机制、可复现排查命令与工程配置落到同一条链路上。

问题背景：TLS 到底在保护什么

MDN 对 Transport Layer Security（TLS）的定位很直接：让客户端在不可信网络上与服务器 安全通信。在 Web 上，用 TLS 保护 HTTP 的结果就是 HTTPS。TLS 从三方面加固连接：

目标	含义
机密性（Encryption）	传输中数据被加密，窃听者难以直接读内容
完整性（Integrity）	中间人无法在不被发现的情况下篡改数据
身份认证（Authentication）	一端能向另一端证明“我是谁”

在公开 Web 上，服务端向客户端认证 是常态；客户端向服务端出示证书 相对少见（多见于 mTLS / 专用 API）。HTTPS 也是对抗 中间人（MITM） 的关键防线：攻击者插在浏览器与站点之间时，若无法通过证书路径与握手完整性校验，就难以“静默”读写业务流量。

因此工程排错要分清两层：

握手层：版本、密码套件、密钥交换、Finished 校验是否完成。
信任层：证书链能否锚定到本地信任锚、名字是否匹配、是否在有效期内、是否被吊销策略拒绝。

核心原理：TLS 1.3 握手的三个阶段

RFC 8446 说明：安全通道的密码参数由 握手协议 产生。握手用于协商协议版本、选择密码算法、可选地互相认证，并建立共享密钥材料；完成后双方用该密钥保护应用层流量。握手失败或其它协议错误会终止连接（可选先发 alert）。

TLS 1.3 支持三种基本密钥交换模式：

(EC)DHE（有限域或椭圆曲线上的 Diffie-Hellman）
仅 PSK
PSK 与 (EC)DHE 组合

完整握手消息流（1-RTT）

规范 Figure 1 给出了基本完整握手（* 表示可选/场景相关；{} 表示用握手流量密钥保护；[] 表示用应用流量密钥保护）：

Client Server

Key ^ ClientHello
Exch | + key_share*
 | + signature_algorithms*
 | + psk_key_exchange_modes*
 v + pre_shared_key* -------->
 ServerHello ^ Key
 + key_share* | Exch
 + pre_shared_key* v
 {EncryptedExtensions} ^ Server
 {CertificateRequest*} v Params
 {Certificate*} ^
 {CertificateVerify*} | Auth
 {Finished} v
 <-------- [Application Data*]
 ^ {Certificate*}
Auth | {CertificateVerify*}
 v {Finished} -------->
 [Application Data] <-------> [Application Data]

可按三个阶段理解：

Key Exchange（密钥交换）
客户端发送 ClientHello（含随机数、可接受版本、对称密码/HKDF 哈希对列表，以及 key_share / pre_shared_key 等扩展）。服务端回 ServerHello 选定连接参数；若用 (EC)DHE，服务端 key_share 必须落在客户端给出的某一组上。ClientHello 与 ServerHello 共同决定共享密钥。此阶段之后的消息均加密。
Server Parameters（服务端参数）
- EncryptedExtensions：对那些不决定密码参数、也不绑定单张证书的 ClientHello 扩展作应答。
- CertificateRequest：若需要基于证书的客户端认证则出现；否则省略。
Authentication（认证）
证书类认证使用同一套消息：Certificate、CertificateVerify、Finished（PSK 认证则作为密钥交换的副作用发生）。
- Certificate：端点证书及链上支撑证书。约定使用证书认证时服务端必须发送；客户端仅当收到 CertificateRequest 时发送。
- CertificateVerify：证明持有与证书对应的私钥，并对握手到该点的完整性提供签名保护；服务器基于证书认证时必须发送，且紧挨在 Certificate 之后、Finished 之前。
- Finished：认证块的最后一条消息，用派生自 Base Key 的 MAC 对握手 transcript 做确认；收方必须校验，错误则 decrypt_error 终止。

双方都发送并成功校验对端 Finished 后，才可在连接上收发应用数据（0-RTT 与服务端首飞后抢发等例外见规范；后者在完成握手前无法确认对端身份与活性）。

相对 TLS 1.2 的关键变化（工程相关）

RFC 8446 §1.2 列出若干重大差异，与排障直接相关的包括：

变化	工程含义
对称算法只保留 AEAD	旧 CBC/非 AEAD 套件不再进入 1.3 协商
去掉静态 RSA / 静态 DH 套件	基于公钥的密钥交换提供前向保密（forward secrecy）
ServerHello 之后握手消息加密	证书等不再明文暴露在握手中后期
密钥派生改用 HKDF	密钥分离与分析模型更清晰
版本协商改为扩展中的版本列表	兼容历史上错误实现版本协商的服务端
会话恢复 / 旧 PSK 套件统一为新 PSK 交换	恢复与 0-RTT 都围绕 PSK 建模
可选 0-RTT early data	省一轮 RTT，但牺牲部分安全属性

0-RTT：快，但默认不适合“写操作”

当客户端与服务端已共享 PSK（外部配置或先前握手得到）时，客户端可在首飞发送 early data。规范强调：0-RTT 在连接建立时节省往返，代价是某些安全属性。Nginx 文档进一步写明：early data 内的请求 可能遭受重放（replay）；应用层可用 $ssl_early_data 识别，例如：

proxy_set_header Early-Data $ssl_early_data;

工程默认建议：

保持 ssl_early_data off;（Nginx 默认即为 off），除非上层明确幂等且能处理重放。
切勿把“首次提交订单/支付/改密”暴露给 0-RTT 路径。

证书链校验：从信任锚走到叶子

握手里的 Certificate 消息只是把 证书序列 交给对端；真正“信不信”取决于客户端的 认证路径校验。

RFC 5280 §6 指出：Internet PKI 的路径处理验证 主体可分辨名和/或主体备用名（SAN） 与主体公钥之间的绑定；该绑定还受路径上证书约束与依赖方输入限制。基本路径校验中：

有效路径从信任锚（trust anchor）签发的证书开始。
信任锚选择是策略问题（层级 PKI 顶端 CA、组织自建根、系统信任库中的根等），但路径校验过程本身与“选了哪颗根”无关。
校验相对于 当前日期时间（实现也可支持对过去某时刻的验证，但不能对有效期之外的时间做校验）。
客户端 必须拒绝 含有不支持 critical 扩展的证书。

叶子身份：SAN 才是名字的主战场

subjectAltName（SAN）把身份绑定到证书主体：可含邮箱、DNS 名、IP、URI 等。规范要求：只要要把这类身份绑进证书，就必须使用 SAN（或 issuer 对应扩展）；DNS 名也可额外用 subject 的 domainComponent 表示，但现代浏览器与库几乎都以 SAN DNS 做主机名匹配。

线上“证书有效但浏览器仍报警”的常见原因：

证书只写在 CN、未正确填 SAN。
SAN 有 example.com 却没有 www.example.com（或反过来）。
多站点共用 IP，TLS 客户端未发 SNI，服务端回了默认虚拟主机证书。

CA 与路径长度：basicConstraints

basicConstraints 标明主体是否为 CA，以及可包含该证书的路径最大深度。若 v3 证书无此扩展，或存在但 cA 未断言，则该公钥不得用于验证证书签名——这也是“把服务器叶子证书误当成中间 CA 拼进链”会立刻失败的原因之一。

服务端交付的链 vs 客户端验证出的链

OpenSSL s_client -showcerts 显示的是 服务端发送的证书列表（发送顺序），文档明确：它不是已验证链。测试工具默认在证书校验错误后仍可能继续握手；生产客户端不应如此。需要“校验失败就中止”时使用 -verify_return_error。

实践：用 OpenSSL 复现握手与链问题

1）看协议版本、套件与服务端发送的证书

# 强制 TLS 1.3，展示服务端 certificate_list，SNI 指定主机名
openssl s_client -connect example.com:443 \
 -servername example.com \
 -tls1_3 \
 -showcerts </dev/null

关注输出中的：

Protocol / Cipher（是否真是 TLSv1.3 与 AEAD 套件）
Certificate chain 段：叶子是否在前、中间证书是否齐全
Verify return code（在默认“测试继续”模式下仍会打印校验结果）

OpenSSL 说明：若未提供 -servername，会尽量用 -connect 里的 DNS 名填充 SNI；从 1.1.1 起默认行为如此。排查“默认证书错了”时，刻意省略 SNI 与 显式指定 SNI 对比往往立刻见分晓：

# 对比：不发 SNI（排查默认 vhost 证书）
openssl s_client -connect 203.0.113.10:443 -noservername -showcerts </dev/null

2）让校验错误真正失败（贴近生产客户端）

openssl s_client -connect example.com:443 \
 -servername example.com \
 -verify_return_error \
 -CAfile /etc/ssl/certs/ca-certificates.crt </dev/null

-verify_return_error 会在服务端证书校验失败时返回错误并通常中止握手，而不是“打印 warning 仍连上”。

3）从 PEM 文件本地拆解链

# 分拆 fullchain.pem 中的每张证书主题/颁发者/SAN/有效期
openssl crl2pkcs7 -nocrl -certfile /etc/nginx/ssl/fullchain.pem \
 | openssl pkcs7 -print_certs -noout -text \
 | egrep 'Subject:|Issuer:|DNS:|Not Before|Not After|CA:'

核对顺序：叶子 → 中间 →（一般不要把公共根塞进服务端发送链，根应由客户端信任库提供）。

4）Nginx 侧：链顺序与协议底线

官方 ssl_certificate：同一 PEM 内先主证书（叶子），再中间证书；密钥用 ssl_certificate_key。
ssl_protocols 默认已是 TLSv1.2 TLSv1.3——新站点通常不必再打开 TLS 1.0/1.1。

server {
 listen 443 ssl http2;
 server_name api.example.com;

 # 叶子在前，中间在后（官方顺序）
 ssl_certificate /etc/nginx/ssl/api.fullchain.pem;
 ssl_certificate_key /etc/nginx/ssl/api.key;

 # 与当前默认一致；显式写出便于审计
 ssl_protocols TLSv1.2 TLSv1.3;
 # TLS 1.3 套件由库侧管理；此指令主要影响 ≤1.2
 ssl_ciphers HIGH:!aNULL:!MD5;
 ssl_prefer_server_ciphers off;

 # 多 worker 共享会话参数，降低重复握手成本
 ssl_session_cache shared:SSL:10m;
 ssl_session_timeout 1d;

 # OCSP stapling：需让 Nginx 知道签发者证书
 ssl_stapling on;
 ssl_stapling_verify on;
 ssl_trusted_certificate /etc/nginx/ssl/api.chain-only.pem;
 resolver 1.1.1.1 8.8.8.8 valid=300s;

 # 默认关闭 0-RTT；开启前先确认业务幂等
 ssl_early_data off;

 # 仅在 mTLS 场景打开
 # ssl_verify_client on;
 # ssl_client_certificate /etc/nginx/ssl/client-ca.pem;
 # ssl_verify_depth 2;
}

说明（均来自 Nginx 官方指令文档）：

ssl_session_cache 默认 none；生产建议 shared:... 并配合合适超时。
ssl_stapling 默认 off；开启时签发者证书须可知（可在 fullchain 或 ssl_trusted_certificate 中提供）。
ssl_verify_client 默认 off；ssl_verify_depth 默认 1。
ssl_early_data 默认 off；开启后请求可能被重放。

常见坑与排查清单

现象	更可能的原因	建议动作
浏览器报 NET::ERR_CERT_COMMON_NAME_INVALID	SAN 不匹配访问主机名	`openssl x509 -in leaf.pem -noout -ext subjectAltName`
手机信任、某台服务器不信任	服务端少发中间证书 / 系统信任库过旧	`-showcerts` 数链长；补全 intermediate
同 IP 多站，偶发证书串站	SNI 未传到正确 vhost	对比 `-servername` 有无
仅部分客户端握手失败	仍协商到 TLS 1.0/1.1 或过旧套件	收紧 `ssl_protocols`；抓包看 ClientHello
`s_client` 显示 Verify error 但仍连上	工具默认不因校验失败中止	加 `-verify_return_error`
开启 early data 后偶发重复写	0-RTT 可重放	关闭 early data，或业务读 `$ssl_early_data` 拒绝非幂等
stapling 无效 / 日志 OCSP error	缺签发者证书或 resolver	配 `ssl_trusted_certificate` + `resolver`
mTLS 客户端被拒	深度/信任锚/optional 语义不符	查 `ssl_verify_client` / `ssl_verify_depth` / 客户端链

补充运维习惯：

证书轮换演练：新 fullchain 应用后，立刻用外网 VPS 跑一遍 s_client -verify_return_error，不要只在本机 curl -k。
HTTP→HTTPS：MDN 建议对明文入口 301 到 HTTPS，并配合 HSTS（Strict-Transport-Security）降低 SSL stripping 窗口；同时杜绝 mixed content（HTTPS 页加载 HTTP 子资源）。
密钥权限与进程身份：私钥仅 Nginx worker 可读；配置重载失败时注意旧进程仍握旧 fd。

总结

TLS 1.3 握手可粗分为 密钥交换 → 服务端参数 → 认证；ServerHello 之后的握手消息受握手流量密钥保护，CertificateVerify 证明私钥持有，Finished 做握手完整性确认。
1.3 强制 AEAD、去掉静态 RSA 密钥交换、引入统一 PSK/0-RTT 模型——配置与排障要以 前向保密 + 加密握手 + 谨慎 early data 为默认心智。
证书信任是 从信任锚出发的路径校验（RFC 5280），不是“PEM 里有几段文字”；SAN、basicConstraints、中间证书顺序与 SNI 是线上最高频的失败点。
用 openssl s_client 区分“服务端发送了什么”和“客户端验证是否通过”，用 Nginx 官方顺序拼 fullchain，并按业务风险决定是否打开会话缓存、stapling 与 0-RTT。

把“能连上”升级为“能证明连对了人、用对了算法、链完整且可复现验证”，HTTPS 才真正从开关变成可运维的安全能力。

参考资料

RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3（.txt：https://www.rfc-editor.org/rfc/rfc8446.txt）
RFC 5280: Internet X.509 Public Key Infrastructure Certificate and CRL Profile（.txt：https://www.rfc-editor.org/rfc/rfc5280.txt）
MDN: Transport Layer Security (TLS)
MDN: HTTPS
OpenSSL: openssl-s_client
Nginx: Module ngx_http_ssl_module

Kubernetes 探针机制：Liveness / Readiness / Startup 原理与工程实践

Sun, 19 Jul 2026 00:00:00 +0800

上线后 Pod 进程还在、端口也开着，但线程死锁、缓存预热未完成、依赖库未就绪——这类“半死不活”状态，单靠进程退出码抓不住。Kubernetes 用 探针（Probe） 让 kubelet 周期性诊断容器，并据此决定：是否重启、是否继续接流量、是否允许启动阶段慢慢就绪。

本文基于 Kubernetes 官方概念文档 Liveness, Readiness, and Startup Probes、任务文档 Configure Liveness, Readiness and Startup Probes 与 Pod Lifecycle，把三类探针的职责边界、四种检查机制、默认参数、典型 YAML 与线上排错清单讲清楚，方便直接落地到业务 Deployment。

一、问题背景：进程存活 ≠ 服务可用

常见误区：

只看 Running：容器主进程没挂，业务已卡死在死锁或无限重试里。
把启动慢当成故障：JVM 冷启动、大配置加载、数据预热需要数分钟，却用过激 liveness 把容器反复杀掉，进入 CrashLoopBackOff。
就绪与存活混用：依赖短暂不可用时杀进程，反而放大级联故障。

官方定位很清晰：探针是 kubelet 对容器做的周期性诊断；根据结果，Kubernetes 可以重启不健康容器，或停止向未就绪容器发送流量。

二、三类探针：职责完全不同

探针	回答的问题	失败后果（概要）	生命周期
Startup	应用是否已经完成启动？	kubelet 杀死容器，按 Pod `restartPolicy` 处理	仅启动阶段；成功后不再执行
Liveness	容器是否仍活着、值得保留？	连续失败超过阈值后重启该容器	启动探针成功后（或无 startup 时）周期执行
Readiness	容器是否可以接流量？	从匹配 Service 的 EndpointSlice 中摘掉 Pod IP；不重启容器	整个生命周期周期执行

1. Startup：给慢启动留窗口

配置了 startupProbe 后，在它成功之前，不会执行 liveness / readiness，避免启动期误杀。

适合：首次初始化很慢、但稳态后希望 liveness 快速发现死锁的应用。官方建议：用与 liveness 相同的检查，但把 failureThreshold * periodSeconds 拉长到覆盖最坏启动时间。示例（30 × 10s = 300s）：

startupProbe:
 httpGet:
 path: /healthz
 port: 8080
 failureThreshold: 30
 periodSeconds: 10
livenessProbe:
 httpGet:
 path: /healthz
 port: 8080
 failureThreshold: 1
 periodSeconds: 10

启动探针一旦成功一次，liveness 接管；若 300s 内始终失败，容器被杀死并受 restartPolicy 约束。

2. Liveness：死锁与不可恢复故障的“硬重启”

典型用途：进程还在，但无法推进业务（死锁、事件循环卡死）。重启可能比挂着更可用。

官方提醒：liveness 必须表示不可恢复失败。配置过激会在高压时连环重启、请求失败、剩余 Pod 压力更大——级联故障。

若进程自己会在异常时崩溃退出，不一定需要 liveness；kubelet 会按 restartPolicy 处理退出。需要“探测失败就杀并重启”时，再配 liveness，且 restartPolicy 一般为 Always 或 OnFailure。

3. Readiness：接不接流量，而不是杀不杀进程

适用：加载大文件、预热缓存、建立连接、临时过载或依赖抖动——暂时不想接流量，但也不该被杀掉。

失败时，控制器从所有匹配 Service 的 EndpointSlice 中移除该 Pod IP，流量不再打到它。删除 Pod 做摘流时，EndpointSlice 条件也会更新，不一定非要 readiness 才能排空；readiness 更适合运行期的“维护摘流 / 依赖未就绪摘流”。

官方还提到一种模式：依赖后端时，liveness 只表示本进程健康，readiness 额外检查后端是否可用，避免把只能回错误的 Pod 继续挂在 Service 上。

三、四种检查机制

每个探针必须且只能配置一种机制：

机制	成功条件	适用场景
`exec`	容器内命令退出码 0	文件标志、本地 CLI 自检
`httpGet`	HTTP 状态码 ≥ 200 且 < 400	业务 `/healthz`、`/ready`
`tcpSocket`	端口可建立 TCP 连接（对端立刻关闭也算健康）	只关心端口是否监听
`grpc`	gRPC Health Checking 返回 `SERVING`	原生 gRPC 服务

要点：

HTTP：路径/端口/命名端口均可；v1.13 之后本地 HTTP 代理环境变量不影响 HTTP liveness。
TCP：端口通了就算成功，不验证应用协议是否正常。
gRPC：需实现官方 health 协议；探针打到 Pod IP/主机名；不支持认证参数；gRPC 不支持命名端口。
exec 开销：每次探测会创建/派生进程；高密度集群 + 短 periodSeconds 会抬高节点 CPU，优先考虑 HTTP/TCP/gRPC。

四、关键参数与默认值

字段	含义	默认（官方）	注意
`initialDelaySeconds`	容器启动后延迟多久开始探测	0	有 startup 时，liveness/readiness 的延迟从 startup 成功后再算
`periodSeconds`	探测间隔	10	最小 1；未 Ready 时 readiness 可能更密探测以尽快就绪
`timeoutSeconds`	单次超时	1	最小 1
`successThreshold`	失败后需连续成功几次才算恢复	1	liveness/startup 必须为 1
`failureThreshold`	连续失败几次判定整体失败	3	最小 1
`terminationGracePeriodSeconds`	探针触发关闭时的宽限期	继承 Pod 级（未设则 30s）	≥1.25 可在 liveness/startup 上覆盖；不能设在 readiness

失败后的行为差异：

startup / liveness：达到 failureThreshold → 视为不健康 → 重启该容器；kubelet 会尊重（探针级或 Pod 级）terminationGracePeriodSeconds。
readiness：失败 → 容器继续跑、探针继续做，但 Pod 的 Ready 条件为 false，从 Service 摘流。

未配置某类探针时，kubelet 对该类结果视为 Success；对 readiness，初始延迟结束前结果按 Failure 处理（避免过早接流）。

五、可落地的组合配置

apiVersion: v1
kind: Pod
metadata:
 name: probe-example
spec:
 terminationGracePeriodSeconds: 30
 containers:
 - name: app
 image: registry.k8s.io/e2e-test-images/agnhost:2.40
 ports:
 - name: http
 containerPort: 8080
 startupProbe:
 httpGet:
 path: /healthz
 port: http
 failureThreshold: 30
 periodSeconds: 10
 livenessProbe:
 httpGet:
 path: /healthz
 port: http
 periodSeconds: 10
 timeoutSeconds: 3
 failureThreshold: 3
 readinessProbe:
 httpGet:
 path: /ready
 port: http
 periodSeconds: 5
 failureThreshold: 3

工程约定建议：

/healthz（liveness）：只查本进程/关键本地资源，不要把下游超时算作“该死”。
/ready（readiness）：可查依赖、连接池、预热是否完成；失败只摘流。
慢启动：用 startupProbe 拉长启动窗口，而不是把 liveness 的 initialDelaySeconds 拉到数分钟还丢掉快速失败能力。
同路径不同阈值：官方常见模式是 readiness 与 liveness 可共用低成本 HTTP 端点，但 liveness 使用更高 failureThreshold，先摘流再硬杀。

官方 exec 示例可快速验证“失败 → 重启”链路：

kubectl apply -f https://k8s.io/examples/pods/probe/exec-liveness.yaml
kubectl describe pod liveness-exec
# 约 30s 后会出现 Liveness probe failed / Container ... will be restarted
kubectl get pod liveness-exec # RESTARTS 递增

HTTP / TCP / gRPC 示例清单同在官方 task 文档：

https://k8s.io/examples/pods/probe/http-liveness.yaml
https://k8s.io/examples/pods/probe/tcp-liveness-readiness.yaml
https://k8s.io/examples/pods/probe/grpc-liveness.yaml

六、常见坑与排查

现象	可能原因	处理思路
启动即 `CrashLoopBackOff`	liveness 在应用未就绪时过早失败	加 `startupProbe` 或合理 `initialDelaySeconds`
READY 长期 0/1	readiness 过严或依赖一直失败	`kubectl describe` 看 Unhealthy；区分依赖故障 vs 端点写错
高压时批量重启	liveness 把“忙/慢”当“死”	收紧 liveness 语义；用 readiness 摘流 + HPA/限流
节点 CPU 被探针打高	大量 `exec` + 短周期	改 HTTP/TCP/gRPC，增大 `periodSeconds`
探针失败但业务浏览器可访问	探针打容器网络命名空间路径/端口与外部不一致	确认 `port`/`host`、命名端口、监听 `0.0.0.0`
gRPC 探针总失败	未实现 health 协议或只监听 localhost	按官方 gRPC health 检查协议暴露，监听 Pod IP 可达地址
重启过猛、优雅退出不够	宽限期过短	Pod 级或 liveness 探针级 `terminationGracePeriodSeconds`（≥1.25）

排错命令：

kubectl describe pod <pod> # Events: Unhealthy / Killing
kubectl get pod <pod> -o wide
kubectl logs <pod> --previous # 被重启前的日志
kubectl get endpointslices -l kubernetes.io/service-name=<svc>

describe 中典型事件类似：Liveness probe failed: ...，随后 Container ... failed liveness probe, will be restarted。

七、选型速查

场景	推荐
进程自己会崩	可不配 liveness，依赖 `restartPolicy`
可能死锁但不退出	liveness（轻量、本地）
启动慢（分钟级）	startup + 稳态 liveness
预热/依赖未齐不想接流量	readiness
维护窗口主动摘流	readiness 独立端点返回失败
仅端口监听即可	`tcpSocket`（认知其浅）
标准 HTTP API	`httpGet` 200–399
gRPC 微服务	实现 health 协议 + `grpc` 探针

八、总结

Startup 管“能不能开始正经跑”，失败会杀容器；成功前挡住 liveness/readiness。
Liveness 管“还值不值得活着”，失败会重启——语义必须严格，防止级联重启。
Readiness 管“能不能接流量”，失败只摘 EndpointSlice，不重启。
机制选 httpGet / tcpSocket / grpc / exec 时，优先低开销网络探针；exec 要注意节点开销。
调参抓住：periodSeconds、failureThreshold、timeoutSeconds 与 startup 窗口 failureThreshold × periodSeconds。

把三类探针当成三个独立控制面来设计端点与阈值，比“抄一段 YAML 三个探针同路径同阈值”更接近生产稳态。

参考资料

Kubernetes 官方概念文档：Liveness, Readiness, and Startup Probes
Kubernetes 官方任务文档：Configure Liveness, Readiness and Startup Probes
Kubernetes 官方概念文档：Pod Lifecycle（Container probes）
Kubernetes API 参考：Probe / Container（Pod v1）
gRPC Health Checking 协议：grpc/grpc health-checking.md

OceanBase 多平台搭建教程：Linux / Windows / macOS / Docker 从零到可连接

Fri, 17 Jul 2026 00:00:00 +0800

OceanBase 是蚂蚁集团开源的分布式关系型数据库，兼容 MySQL 协议，适合本地体验、开发联调与集群试验。很多人第一次上手时最困惑的不是“它强在哪”，而是：

我在 Linux / Windows / macOS 上，到底该用哪一种方式装？

本文按官方社区推荐路径，整理一套可复用的多平台搭建方法：优先讲最快跑起来，再讲更接近生产部署的方式，并给出连接验证与常见排错。

说明：本文以 OceanBase 社区版（CE） 的官方开源安装路径为主，面向学习与开发环境。官方 Docker 镜像明确标注仅供测试，不建议直接用于生产。

一、先选对安装路径

平台	最推荐方式	备选方式	说明
Linux	`all-in-one` + `obd demo`	Docker / OBD 自定义集群	官方 all-in-one 仅支持 Linux
macOS	Docker Desktop + `oceanbase-ce`	远程 Linux 开发机	本机不建议硬编译 observer 当第一选择
Windows	Docker Desktop	WSL2 + Linux 方案	原生 Windows 不适合当主路径
任意平台（快速体验）	Docker `oceanbase/oceanbase-ce`	quay.io / ghcr.io 镜像源	单实例、端口 `2881`
Kubernetes	`ob-operator`	—	容器化生产/类生产集群请走 operator

资源底线（很重要）

不同路径对资源要求不同，至少记住两档：

Docker 官方镜像（测试）
- 主机建议至少 2 物理核 + 8GB 内存
obd demo 本地单节点
- 至少 2 CPU、6GB 可用内存、54GB 可用磁盘
- 端口 2881 / 2882 未被占用

机器太小会导致 bootstrap 卡住、容器反复重启，看起来像“命令写错了”，其实是资源不足。

二、通用概念：端口、租户、客户端

搭好后，通常这样连接：

项目	常见值
协议	MySQL 兼容
SQL 端口	`2881`
系统租户	`sys`
示例业务租户	`test`（Docker 镜像常见）
客户端	`obclient` 或标准 `mysql` 客户端

常用连接示例：

# 系统租户 root
mysql -h127.0.0.1 -P2881 -uroot

# 普通租户 root（Docker 文档示例）
mysql -h127.0.0.1 -P2881 -uroot@test

如果你本机没有 mysql 客户端，可用容器内置客户端：

docker exec -it oceanbase-ce obclient -h127.0.0.1 -P2881 -uroot

三、最快路径：Docker（Linux / Windows / macOS 通用）

这是跨平台体验 OceanBase 最省事的方式。
官方提供镜像：

Docker Hub：oceanbase/oceanbase-ce
备选：quay.io/oceanbase/oceanbase-ce
备选：ghcr.io/oceanbase/oceanbase-ce

官方说明：该镜像用于快速搭建测试环境，只支持单实例；若在 Kubernetes 中运行，请改用 ob-operator。

1. 前置条件

已安装并可运行 Docker（Linux Docker Engine / Docker Desktop）
主机资源满足：约 2 核 + 8GB 内存
本机 2881 端口空闲

2. 启动实例

# mini 模式：适合快速体验（官方 README 推荐写法）
docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce

Docker Hub 文档还给出了其他模式：

# 使用容器更多资源
docker run -p 2881:2881 --name oceanbase-ce -e MODE=normal -d oceanbase/oceanbase-ce

# slim / fastboot 模式
docker run -p 2881:2881 --name oceanbase-ce -e MODE=slim -d oceanbase/oceanbase-ce

若 Docker Hub 拉取慢，可切换镜像源：

docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d quay.io/oceanbase/oceanbase-ce
# 或
docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d ghcr.io/oceanbase/oceanbase-ce

3. 等待 bootstrap 完成

首次启动可能需要几分钟。查看日志末尾：

docker logs oceanbase-ce | tail -1

期望看到：

boot success!

4. 连接验证

# 方式 A：容器内客户端
docker exec -it oceanbase-ce obclient -h127.0.0.1 -P2881 -uroot

# 方式 B：宿主机 mysql 客户端
mysql -h127.0.0.1 -P2881 -uroot
mysql -h127.0.0.1 -P2881 -uroot@test

进入后可执行：

SHOW DATABASES;
SELECT version();

5. 常用运维命令

docker ps -a | grep oceanbase-ce
docker logs -f oceanbase-ce
docker restart oceanbase-ce
docker stop oceanbase-ce
docker rm -f oceanbase-ce

6. 初始化 SQL（可选）

官方镜像支持挂载初始化脚本目录：

docker run -p 2881:2881 --name oceanbase-ce \
 -v /path/to/init-sql:/root/boot/init.d \
 -d oceanbase/oceanbase-ce

注意：官方文档提醒，初始化脚本中不要直接改 root 密码；若要改密码，应使用镜像提供的环境变量（如 OB_TENANT_PASSWORD，以当前镜像说明为准）。

四、Linux 原生：all-in-one + OBD（官方推荐体验路径）

如果你有一台 Linux 服务器或虚拟机，想更接近“真集群工具链”，优先用官方 all-in-one。

1. 一键安装 all-in-one

官方 README 明确：仅 Linux。

# 需要能访问外网
bash -c "$(curl -s https://obbusiness-private.oss-cn-shanghai.aliyuncs.com/download-center/opensource/oceanbase-all-in-one/installer.sh)"
source ~/.oceanbase-all-in-one/bin/env.sh

2. 一键拉起演示实例

obd demo

obd demo 会在本机部署并启动一个 OceanBase 实例。部署完成后：

obclient -h127.0.0.1 -uroot -P2881

3. 单独安装 OBD（CentOS/RHEL 系）

如果你不走 all-in-one，也可以单独装 OceanBase Deployer：

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo
sudo yum install -y ob-deploy
source /etc/profile.d/obd.sh

然后同样可用：

obd demo

4. `obd demo` 前自检清单

端口 2881、2882 空闲
可用内存 ≥ 6GB
CPU ≥ 2
可用磁盘 ≥ 54GB
系统时间正常、主机名可解析

资源不够时，OBD 往往会在预检阶段失败；先把机器规格补齐再重试，比反复改 YAML 更有效。

五、Windows 搭建

Windows 原生不适合作为 OceanBase observer 主部署平台。实操建议两条路：

方案 A：Docker Desktop（最简单）

安装 Docker Desktop for Windows
确保 WSL2 后端已启用（Docker Desktop 默认推荐）
在 PowerShell / Windows Terminal 执行：

docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce
docker logs oceanbase-ce

看到 boot success! 后连接：

docker exec -it oceanbase-ce obclient -h127.0.0.1 -P2881 -uroot

Windows 上若本机没有 mysql 客户端，优先用容器内 obclient。

方案 B：WSL2 + Linux 路径

适合希望练习 obd / all-in-one 的同学：

安装 WSL2 与 Ubuntu（或其他受支持发行版）
给 WSL 分配足够内存（建议在 .wslconfig 中提高 memory）
在 WSL 内按上文 Linux all-in-one / Docker 步骤执行

注意：WSL 的磁盘 I/O 与内存限制会影响 bootstrap 时间，尽量把数据放在 Linux 文件系统内，不要跨挂载到很慢的 Windows 目录。

六、macOS 搭建

macOS 上同样优先 Docker：

1. 安装 Docker Desktop for Mac

Intel / Apple Silicon 都可使用 Docker Desktop
在 Docker Desktop → Settings → Resources 中给足 CPU/内存（建议 ≥ 2 CPU、8GB）

2. 启动 OceanBase

docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce

拉取慢时可换：

docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d ghcr.io/oceanbase/oceanbase-ce

3. 连接

docker exec -it oceanbase-ce obclient -h127.0.0.1 -P2881 -uroot

4. macOS 特别提醒

官方 all-in-one 标注 Linux Only，不要在 macOS 上硬套那条 installer 当主路径
Apple Silicon 上若镜像/依赖偶发兼容问题，优先换官方备用镜像源，或使用远程 Linux 机器做部署练习
开发联调可把应用跑在 macOS，数据库跑在 Docker 容器；应用连接 127.0.0.1:2881

七、进阶：Kubernetes 与多节点

当你已经不满足“本机单实例体验”，可以往这两类走：

1. Kubernetes：`ob-operator`

官方 README 推荐使用 ob-operator 在 K8s 中部署管理 OceanBase。
适合：

想练容器化运维
需要更接近云原生的生命周期管理
本地 kind/k3s/自建集群实验

快速入口见：https://oceanbase.github.io/ob-operator

2. OBD 自定义集群

obd demo 只是快速单机演示。真正做多副本/多节点时，应使用 OBD 的集群配置与命令组（镜像仓库、集群启停、升级等）。
这已经超出“第一次搭起来”的范围，但方向应是：

先用 Docker / obd demo 跑通连接
再学 OBD 配置文件与集群拓扑
最后再上 K8s operator

八、连接后的最小验收清单

不管你用哪种平台，搭完后建议做同一套验收：

-- 1. 能登录
SELECT 1;

-- 2. 看版本信息
SELECT version();

-- 3. 建库建表
CREATE DATABASE demo;
USE demo;
CREATE TABLE t1(id INT PRIMARY KEY, name VARCHAR(64));
INSERT INTO t1 VALUES (1, 'oceanbase');
SELECT * FROM t1;

宿主机侧再确认：

# 端口监听
# Linux
ss -lntp | grep 2881
# macOS
lsof -iTCP:2881 -sTCP:LISTEN

九、常见问题排查

1. 容器一直起不来 / 没有 `boot success!`

优先检查：

内存是否低于 8GB（Docker 场景）
磁盘是否紧张
docker logs oceanbase-ce 是否有 OOM / 权限 / 存储错误
是否重复占用容器名 oceanbase-ce

处理：

docker rm -f oceanbase-ce
docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce

2. `2881` 端口冲突

# 换宿主机端口映射，例如 12881 -> 2881
docker run -p 12881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce
mysql -h127.0.0.1 -P12881 -uroot

3. Docker Hub 拉取失败

依次尝试：

quay.io/oceanbase/oceanbase-ce
ghcr.io/oceanbase/oceanbase-ce
配置可用的镜像加速 / 代理

4. 能进容器但不能从宿主机连接

确认 -p 2881:2881 已映射
Windows/macOS 确认 Docker Desktop 正在运行
云服务器还要放行安全组/防火墙入站规则

5. `obd demo` 预检失败

对照官方条件逐项查：

内存、CPU、磁盘是否达标
2881/2882 是否被占用
是否在非 Linux 环境误跑 all-in-one

十、平台选型建议（实战版）

你的目标	建议
30 分钟内先连上跑 SQL	Docker `MODE=mini`
在 Linux 服务器练官方部署工具	all-in-one + `obd demo`
Windows 笔记本本地体验	Docker Desktop
macOS 开发机联调	Docker Desktop
学习 K8s 运维	ob-operator
准备生产环境	不要直接用体验镜像；按正式部署/高可用架构与官方生产文档规划

一句话总结：

跨平台先 Docker；Linux 深造用 OBD；生产上集群/K8s，不要拿体验镜像硬上。

十一、精简命令速查

Docker（全平台）

docker run -p 2881:2881 --name oceanbase-ce -e MODE=mini -d oceanbase/oceanbase-ce
docker logs oceanbase-ce | tail -1
docker exec -it oceanbase-ce obclient -h127.0.0.1 -P2881 -uroot

Linux all-in-one

bash -c "$(curl -s https://obbusiness-private.oss-cn-shanghai.aliyuncs.com/download-center/opensource/oceanbase-all-in-one/installer.sh)"
source ~/.oceanbase-all-in-one/bin/env.sh
obd demo
obclient -h127.0.0.1 -uroot -P2881

OBD RPM（CentOS/RHEL）

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo
sudo yum install -y ob-deploy
source /etc/profile.d/obd.sh
obd demo

总结

OceanBase 的“多平台搭建”并不要求你在每个 OS 上都原生编译一套数据库：

Docker 是 Linux / Windows / macOS 的最大公约数，适合快速体验与开发联调。
Linux all-in-one + OBD 更接近官方部署工具体验，适合服务器环境。
Windows / macOS 应把精力放在 Docker Desktop（或 WSL2）而不是强行原生部署。
需要容器编排时，转向 ob-operator，而不是把 oceanbase-ce 体验镜像直接当生产方案。

先保证“能启动、能连接、能建表”，再进入租户管理、资源规格、多副本和高可用，路径会清晰很多。

参考资料

OceanBase 官方仓库 README（中英文 Quick Start / Docker / all-in-one）：https://github.com/oceanbase/oceanbase
OceanBase Docker 镜像说明（Docker Hub oceanbase/oceanbase-ce）：https://hub.docker.com/r/oceanbase/oceanbase-ce
OceanBase Docker 镜像仓库文档：https://github.com/oceanbase/docker-images
OceanBase Deployer（OBD）中文 README：https://github.com/oceanbase/obdeploy
ob-operator 文档：https://oceanbase.github.io/ob-operator
OceanBase 中文文档中心：https://www.oceanbase.com/docs/oceanbase-database-cn
快速体验入口：https://open.oceanbase.com/quickStart

Linux cgroup v2 内存控制与 OOM Killer：原理、观测与容器化实践

Thu, 16 Jul 2026 00:00:00 +0800

线上最棘手的一类故障，往往不是“服务报了明确业务错误”，而是进程突然消失：容器退出码 137、Pod 状态里出现 OOMKilled，或者主机 dmesg 里留下一行 Out of memory: Killed process。表象是“内存不够”，根因通常落在 内存如何被记账、如何被限制、以及内核如何选择牺牲者。

本文以 Linux cgroup v2 memory 控制器 与 OOM Killer 为主线，结合 Docker / Kubernetes 的常见映射，把“限多少、什么时候开始回收、什么时候杀进程、怎么排”讲清楚。

一、先建立两层模型：全局 OOM vs cgroup OOM

Linux 里至少要区分两种“内存不够”：

场景	典型触发	影响范围
全局内存压力	整机可用内存 + 可回收页不够，分配失败	OOM killer 在系统范围内按启发式选进程
cgroup 内存上限	某 cgroup 的 `memory.max` 触顶且回收失败	OOM 只发生在该 cgroup 内（不会跨出该 cgroup 去杀别人）

这解释了一个常见错觉：给容器设了 -m 512m，为什么还会拖垮宿主机？
因为：

没设硬限制时，容器与宿主机共享整机内存；
即使设了 limit，仍可能有内核开销、page cache 统计差异、swap 配置、以及 宿主级其他进程 的压力；
Docker 默认会尽量保护 daemon 自身，但不会自动把所有容器都“隔离成绝对安全沙箱”。

因此工程上要同时看：

进程/容器是否撞到了 自己的 limit；
节点是否发生了 系统级 OOM / kubelet 驱逐。

二、cgroup v2 的内存阶梯：min / low / high / max

cgroup v2 memory 控制器把控制面拆成“保护、限速、硬顶”几层。官方接口里最核心的是这些文件（单位均为字节）：

接口	角色	关键语义
`memory.current`	观测	当前 cgroup 及其后代已用内存
`memory.min`	硬保护	在 effective min 内，内存不会被回收；若系统没有其他可回收内存，可能直接触发 OOM
`memory.low`	尽力保护	在 effective low 内，尽量不被回收；只有无保护可回收内存时才可能被碰
`memory.high`	节流线	超高后进程被 throttling，并承受很重的 direct reclaim；不会因此调用 OOM killer
`memory.max`	硬上限	用量到顶且无法压回时，在该 cgroup 内调用 OOM killer
`memory.oom.group`	策略	设为 `1` 时，把 cgroup 当不可分割工作负载：要么一起杀，要么都不杀（`oom_score_adj=-1000` 的任务例外）
`memory.events`	事件计数	`high` / `max` / `oom` / `oom_kill` 等，是最好的“快撞墙”信号
`memory.peak`	峰值	自创建或重置以来的最大用量

可以把它理解成一条阶梯：

usage
 │
 │ memory.min ── 硬保护（尽量不回收；保护过猛可能反噬）
 │ memory.low ── 软保护（有余量时优先回收别人）
 │ memory.high ── 开始重压回收 + 节流（通常还不杀）
 │ memory.max ── 硬顶；回收失败 → cgroup OOM
 ▼

1. 为什么要有 `high`，而不是只设 `max`？

memory.max 是“悬崖”：到顶就可能杀进程。
memory.high 是“缓坡”：先让工作负载变慢、开始回收，给外部控制器（或人）反应时间。内核文档明确：high 越界 never invokes the OOM killer，极端情况下甚至可能被短暂突破。

生产里更健康的模式往往是：

high 设在“可接受抖动”的水位；
max 设在“绝对不可越过”的水位；
用 memory.events 的 high/max 做告警，而不是等进程死了再看。

2. `min`/`low` 保护不是免费的

memory.min 是硬保护：保护区内页面在“任何条件下”都不应被回收；如果系统已经没有未保护可回收内存，就可能 直接 OOM。
memory.low 是 best-effort：优先保护，但仍可能在全局极端压力下被回收。

因此：

保护值叠加超过父 cgroup/整机能力时，会发生 overcommit of protection；
effective 边界还会受祖先 cgroup 限制；
把所有关键服务都设成很高的 min，等于在内存不够时更容易触发“保谁都保不住”的 OOM。

三、OOM Killer：它到底怎么选人

1. 评分：`oom_score` 与 `oom_score_adj`

当内核决定必须杀进程腾内存时，会给候选任务打 badness 分。man-pages 对 /proc/<pid>/oom_score / oom_score_adj 的说明可概括为：

分数大致落在 0（几乎不杀）到 1000（优先杀）；
主要依据是任务相对其 allowed memory 的用量比例（RSS/swap 等估计）；
用满允许内存 ≈ 1000，用一半 ≈ 500；
root 进程额外获得约 3% 的“更宽容”额度；
oom_score_adj 范围 -1000 ~ +1000，在启发式结果上再加减；
oom_score_adj = -1000 表示 OOM 保护（基本不会被选中）。

“allowed memory”取决于 OOM 上下文：

系统全局 OOM → 整机可分配资源；
cgroup/limit 触顶 → 该 limit 本身；
cpuset / mempolicy 节点耗尽 → 对应节点集合。

2. 系统级可调旋钮（`/proc/sys/vm/*`）

参数	默认（文档）	作用
`oom_dump_tasks`	`1`	OOM 杀进程时是否打印系统任务摘要（pid/rss/oom_score_adj 等），便于事后定位
`oom_kill_allocating_task`	`0`	`0`：扫描任务列表按启发式选“更该杀”的；`1`：直接杀触发分配失败的那个任务（省扫描）
`panic_on_oom`	`0`	`0` 杀进程求生；`1` 全局 OOM 可 panic（节点局部耗尽未必）；`2` 连 memory cgroup OOM 也整机 panic
`overcommit_memory`	`0`	`0` 启发式拒绝明显 overcommit；`1` 几乎总是允许，直到真正用完；`2` never overcommit 策略

大多数业务机保持默认即可；集群 failover / 取证 场景才会认真考虑 panic_on_oom + kdump。
不要把 oom_kill_allocating_task=1 当成“优化”随手打开：它可能杀掉“刚好申请最后一页”的 innocuous 任务，而放过真正的内存黑洞。

3. cgroup 内 OOM 的边界

cgroup v2 文档强调两点：

触达 memory.max 且无法回收时，OOM killer 在该 cgroup 内被调用；
一旦在某个 cgroup 触发 OOM，不会去杀该 cgroup 外的任务（与祖先 memory.oom.group 取值无关）。

memory.oom.group=1 适合“多进程必须同生共死”的工作负载（例如某个多 worker 服务希望要么整组重启，要么都不半残）。
但要注意：被 -1000 保护的任务仍是例外。

四、工程映射：Docker 与 Kubernetes

1. Docker：把 limit 落到 cgroup

Docker 官方资源限制文档给出了与内存相关的关键选项：

# 硬上限（最小允许约 6m）
docker run -d --name demo -m 512m your-image

# 内存 + swap 总预算（细节依赖 --memory-swap 语义）
docker run -d -m 512m --memory-swap 1g your-image

# 软预留（争用时更“敏感”，不保证不越界）
docker run -d -m 1g --memory-reservation 512m your-image

# 一般不要关 OOM killer；若关闭，必须同时设置 -m
docker run -d -m 512m --oom-kill-disable your-image

要点：

-m/--memory：容器可用内存上限；
--memory-reservation：软限制，需小于 --memory，争用时生效，不保证永不越界；
--oom-kill-disable：禁用容器内 OOM killer；文档要求 仅在同时设置了 -m 时使用，否则可能把压力转嫁给宿主机，拖垮整机；
Docker daemon 会调整自身 OOM 优先级，降低“杀 daemon 导致全盘崩溃”的概率；容器进程默认没有这种优待。

2. Kubernetes：request / limit / QoS / 驱逐

Kubernetes 文档把资源语义拆成两层：

调度与预留：requests 供 kube-scheduler 选型，kubelet 也会为容器预留至少 request 量；
运行时强制：limits 由 kubelet/容器运行时落到 cgroup；memory limit 由内核通过 OOM kill 强制。

与 CPU 不同：CPU 超限通常是节流；内存超限更可能直接被内核杀掉。文档也提醒：OOM 是 反应式 的——容器可能短暂超过 limit，但在内核感知到压力后才被终止。

QoS 类（Guaranteed / Burstable / BestEffort）主要影响 节点资源压力下的驱逐优先级：

节点资源不足时，通常先考虑驱逐 BestEffort，再 Burstable，最后 Guaranteed；
因资源压力驱逐时，候选对象通常是 超过 request 的 Pod；
Guaranteed（各容器 request=limit 且都 >0 的经典条件）最不容易被驱逐，但 不等于永远不被 OOM：一旦超过自己的 memory limit，仍可能 OOMKilled。

一个可复现的排查入口：

kubectl describe pod <pod> | sed -n '/Last State/,/Events/p'
# 常见：Reason: OOMKilled, Exit Code: 137

五、可复现观测：别等 dmesg 再救火

1. 先确认 cgroup v2 与容器路径

# 多数现代发行版默认 cgroup v2 统一层级
mount | grep cgroup
stat -fc %T /sys/fs/cgroup

# 看某个进程属于哪个 cgroup
pidof java | head -n1 | xargs -I{} cat /proc/{}/cgroup

2. 读 memory 接口（容器内或宿主机 cgroup 路径）

CG=/sys/fs/cgroup # 或容器对应的子路径，如 /sys/fs/cgroup/system.slice/docker-<id>.scope

cat $CG/memory.current
cat $CG/memory.max
cat $CG/memory.high
cat $CG/memory.peak
cat $CG/memory.events
# 关注：high / max / oom / oom_kill 是否持续上涨

解释事件：

`memory.events` 字段	含义（工程视角）
`high`	触碰 high 边界，被节流/强制回收的次数
`max`	用量几乎要越过 max；若 direct reclaim 失败，将进入 OOM 状态
`oom`	已到 limit，分配即将失败
`oom_kill`	实际发生了 OOM kill

3. 看谁更容易被杀

# 分数越高越危险
ps -eo pid,user,comm,rss,oom_score,oom_score_adj --sort=-oom_score | head

# 某个关键守护进程是否被错误保护/错误牺牲
cat /proc/$(pidof dockerd)/oom_score_adj

4. 对照内核日志

dmesg -T | egrep -i 'out of memory|killed process|oom'
journalctl -k -b --no-pager | egrep -i 'out of memory|killed process'

若 oom_dump_tasks=1（默认），日志里通常能看到候选任务的 rss、oom_score_adj 等信息，用来回答“为什么杀的是 A 不是 B”。

六、常见坑与排查清单

坑 1：只设 request，不设 limit

调度时“看起来能放下”，运行时可以吃爆节点；最终变成 节点级压力 + 驱逐/全局 OOM，故障面比单容器 OOM 更大。

坑 2：limit 设太紧，没有 `high` 缓冲与观测

应用启动峰值、JVM 堆外、page cache、临时解压都可能把 current 顶到 max。
结果是频繁 OOMKilled 重启，而不是平滑降速。优先补：

真实峰值观测（memory.peak、容器监控）；
合理 limit；
能用 high 水位告警就不要只用死亡事件告警。

坑 3：把 `oom_score_adj=-1000` 到处贴

保护数据库/核心 agent 合理；若把内存泄漏服务也保护起来，OOM killer 只能去杀更无辜的进程，整机稳定性更差。

坑 4：`--oom-kill-disable` 却没有硬上限

Docker 文档明确警告：关 OOM killer 时必须配合 -m。否则容器可把宿主内存吃穿。

坑 5：混淆“kubelet 驱逐”与“cgroup OOM”

现象	更像
Pod 事件里有 eviction、磁盘/内存 pressure	kubelet 驱逐
Container `Last State: OOMKilled` / exit 137	cgroup/内核 OOM
宿主 `dmesg` 出现 Killed process，且受害进程不一定是容器	全局 OOM 或选中了别的任务

坑 6：用错“内存用量”口径

RSS、cgroup memory.current、容器运行时 working set、JVM heap used 不是同一个数。
排 OOM 时以 cgroup 记账 + kernel 日志 为准，再用进程级工具交叉验证。

七、一套可执行的生产建议

每个有状态/高风险服务都要有 memory limit，并基于压测峰值留 20%–40% 余量（按语言运行时特性调整）。
优先监控 memory.events 与 working set 趋势，把 high/max 当预警，把 oom_kill 当事故。
K8s 上让关键链路尽量 Guaranteed 或至少 request≈实际稳态；limit 不要拍脑袋抄 CPU 倍数。
保护面要窄：-1000 只给真正的系统关键路径；业务进程靠 limit 与弹性，而不是全局免死金牌。
复盘时固定三件套：memory.current/max/events + oom_score(_adj) + dmesg/journal。
不要默认改 panic_on_oom / oom_kill_allocating_task，除非你清楚故障域与取证目标。

八、总结

cgroup v2 用 min/low/high/max 把内存控制从“一刀切 hard cap”扩展成“保护 + 节流 + 硬顶”。
high 负责让系统先变慢并回收；max 才是 OOM 悬崖。
OOM killer 按 badness/oom_score_adj 选人；cgroup OOM 默认 杀在组内，memory.oom.group 可改变是否整组同生共死。
Docker 的 -m、K8s 的 limits.memory 最终都落到内核 cgroup；CPU 超限多半被节流，内存超限更可能被杀。
可观测性的关键不是“死了没有”，而是 memory.events 是否在反复逼近上限。

把内存限制当成“开关”只会得到随机的 137；把它当成“阶梯 + 评分 + 事件流”，才能在容器化环境里稳定控风险。

参考资料

Linux Kernel Docs — Control Group v2（memory.current / min / low / high / max / oom.group / events）: https://docs.kernel.org/admin-guide/cgroup-v2.html
Linux Kernel Docs — Documentation for /proc/sys/vm/（oom_dump_tasks、oom_kill_allocating_task、panic_on_oom、overcommit_memory、swappiness）: https://docs.kernel.org/admin-guide/sysctl/vm.html
man-pages — proc_pid_oom_score(5): https://man7.org/linux/man-pages/man5/proc_pid_oom_score.5.html
man-pages — proc_pid_oom_score_adj(5): https://man7.org/linux/man-pages/man5/proc_pid_oom_score_adj.5.html
Docker Docs — Resource constraints（memory options、OOME、--oom-kill-disable）: https://docs.docker.com/engine/containers/resource_constraints/
Kubernetes Docs — Resource Management for Pods and Containers: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
Kubernetes Docs — Pod Quality of Service Classes: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/

etcd 3.7.0 正式发布：Kubernetes 控制面的升级、备份与兼容性检查清单

Thu, 09 Jul 2026 09:06:19 +0800

etcd 是 Kubernetes 控制面的关键依赖：API Server 的对象状态、Leader 选举、租约与 watch 通知，最终都要落到这个分布式键值存储上。2026 年 7 月 8 日，etcd 项目发布了 v3.7.0。它不是一个只改版本号的小更新：官方发布说明明确要求升级前阅读 v3.7 升级指南，CHANGELOG 中同时包含安全修复、依赖升级、v2 相关能力移除、clientv3 行为变化以及运维工具改动。

这篇文章基于 etcd 官方 Release、CHANGELOG、v3.7 升级文档，以及 Kubernetes 官方 etcd 运维文档整理成一份实践清单。它不是复制某一篇公告，而是面向真实生产环境回答三个问题：是否应该升级、升级前要检查什么、如果你运行的是 Kubernetes 集群该如何降低风险。

这次发布最值得关注的变化

1. 安全修复与依赖升级

v3.7.0 的正式版 CHANGELOG 提到两个服务端修复：当配置 --listen-client-http-urls 时，gRPC listener 上的 CRL enforcement bypass 问题得到修复；同时修复了带 bearer 前缀 token 的 websocket 认证问题。依赖层面，官方二进制使用 Go 1.26.5 编译，并将 golang.org/x/crypto 升级到 v0.52.0，以处理多项 CVE。

对运维团队来说，这意味着 v3.7.0 不应只被看成“新功能版本”。如果你的 etcd 暴露在严格证书校验、客户端证书吊销列表、或经过网关/WebSocket 访问的场景中，安全修复本身就值得排期评估。

2. v2 时代彻底退出

v3.7 升级文档说明，v2 store 已在 v3.7 中完全移除：--enable-v2、--experimental-enable-v2v3、v2 discovery service、client/v2 包以及 v2 snapshot 文件加载都不再存在。CHANGELOG 也把移除 v2 discovery、client/v2、v2 request/apply 等列为 v3.7.0-rc.0 的 breaking changes。

如果你的集群已经稳定运行在 3.6，并且历史上没有保留 v2 数据，这通常不是阻塞项；但如果某些遗留脚本仍依赖 v2 API，或者你还保留了旧版本快照恢复流程，就必须在升级前完成迁移与演练。

3. clientv3 创建连接不再阻塞

CHANGELOG 写明：clientv3 创建 etcd client 变为 non-blocking，etcd 不再遵循已废弃的 grpc.WithBlock dial option。过去一些程序会假设 clientv3.New(...) 返回成功就代表连接已建立；升级依赖后，这类程序需要改为显式执行健康检查、超时控制或首次请求重试。

一个更稳妥的模式是：创建 client 后立即用带超时的上下文调用 Status 或 EndpointHealth，把“创建对象成功”和“后端可达”拆开处理。

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
_, err := cli.Status(ctx, "https://127.0.0.1:2379")
if err != nil {
 return fmt.Errorf("etcd endpoint not ready: %w", err)
}

4. 命令行工具与可观测性变化

v3.7 系列整理了 etcdctl 命令，使帮助输出更简洁；etcdutl 为所有命令增加 timeout flag，用于等待数据库文件锁时避免无限等待。监控方面，CHANGELOG 提到新增 etcd_server_request_duration_seconds，以及多项 watch send loop 相关指标。对于依赖 Prometheus 告警的集群，升级后应同步检查 dashboard 和 recording rules，避免因为指标新增、命名差异或告警阈值不适配导致误报或漏报。

生产升级前的硬性检查

官方 v3.7 升级文档给出了两个基础前提：运行中的集群必须已经是 v3.6.11 或更高版本；etcd 只支持一次升级一个 minor 版本。如果你还在 3.5 或更早版本，应先升级到 3.6，再从 3.6 升级到 3.7。

升级前建议执行以下检查：

# 1. 检查所有成员版本与健康状态
ETCDCTL_API=3 etcdctl \
 --endpoints=https://127.0.0.1:2379 \
 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
 --cert=/etc/kubernetes/pki/etcd/server.crt \
 --key=/etc/kubernetes/pki/etcd/server.key \
 endpoint status --cluster -w table

ETCDCTL_API=3 etcdctl \
 --endpoints=https://127.0.0.1:2379 \
 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
 --cert=/etc/kubernetes/pki/etcd/server.crt \
 --key=/etc/kubernetes/pki/etcd/server.key \
 endpoint health --cluster

# 2. 创建快照，保留到升级窗口结束后
ETCDCTL_API=3 etcdctl \
 --endpoints=https://127.0.0.1:2379 \
 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
 --cert=/etc/kubernetes/pki/etcd/server.crt \
 --key=/etc/kubernetes/pki/etcd/server.key \
 snapshot save /backup/etcd-$(date +%F-%H%M).db

# 3. 校验快照状态
etcdutl snapshot status /backup/etcd-YYYY-MM-DD-HHMM.db -w table

Kubernetes 官方文档也强调了 etcdctl 与 etcdutl 的分工：etcdctl 主要用于通过网络管理集群、键值和健康状态；etcdutl 更偏向直接操作数据文件，例如快照恢复、碎片整理、迁移与一致性验证。不要把两者混用成一个“万能命令”。

日常维护也要一起复盘

升级窗口是复盘 etcd 维护策略的好时机。官方维护文档指出，etcd 需要周期性维护以保持可靠性；如果 keyspace 历史没有及时压缩，后端数据库没有碎片整理，空间配额触发后集群会进入只接受读取和删除的受限维护模式。

建议把下面三件事纳入升级后的运维基线：

# 自动压缩：保留最近 1 小时历史（示例，需按业务 watch/回放需求调整）
etcd --auto-compaction-mode=periodic --auto-compaction-retention=1h

# 手动压缩到某个 revision 后，再对成员做 defrag
ETCDCTL_API=3 etcdctl compact <revision>
ETCDCTL_API=3 etcdctl defrag --cluster

# 关注 DB Size、leader 切换、请求延迟、watch 延迟等指标
# 结合新增的 etcd_server_request_duration_seconds 更新 Prometheus 告警

升级风险清单

遗留 v2 依赖：检查脚本、SDK、旧控制器和快照恢复流程，不要等升级后才发现 client/v2 或 v2 snapshot 不可用。
客户端连接假设：如果业务代码使用 clientv3，确认是否依赖 grpc.WithBlock 带来的阻塞语义。
快照不可恢复：只保存快照不够，至少要在隔离环境验证一次恢复流程。
混合版本时间过长：滚动升级可以混合版本运行，但不应长期停留在混合状态。
Kubernetes 兼容性：控制面组件、发行版、kubeadm 与 etcd 版本必须一起评估。

总结

etcd 3.7.0 的关键词是“安全修复、v2 清理、客户端语义调整、运维工具增强”。对于新集群，它让技术债更少；对于老集群，它会暴露历史遗留依赖。真正稳妥的升级不是简单替换二进制，而是先确认版本链路、备份可恢复、客户端行为可接受、监控和维护策略同步更新。只要把这些检查前置，v3.6 到 v3.7 的滚动升级可以成为一次相对可控的控制面基础设施升级。

参考资料

etcd 官方 Release：https://github.com/etcd-io/etcd/releases/tag/v3.7.0
etcd 官方 CHANGELOG 3.7：https://github.com/etcd-io/etcd/blob/main/CHANGELOG/CHANGELOG-3.7.md
etcd 官方 v3.7 升级指南：https://etcd.io/docs/v3.7/upgrades/upgrade_3_7/
etcd 官方维护文档：https://etcd.io/docs/v3.7/op-guide/maintenance/
Kubernetes 官方 etcd 管理文档：https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/

Caddy：现代化Web服务器入门与实战

Fri, 26 Jun 2026 15:30:00 +0000

Caddy 简介

Caddy 是一个用 Go 语言编写的现代化 Web 服务器，以其自动 HTTPS 功能闻名。相比 Nginx，Caddy 的配置更简洁，功能更现代，特别适合云原生环境。

Caddy 的核心优势：

自动 HTTPS：自动获取和续期 Let’s Encrypt 证书
配置简洁：Caddyfile 语法直观易读
零依赖：单个二进制文件，无外部依赖
API 驱动：支持通过 REST API 动态配置
跨平台：支持 Linux、macOS、Windows

安装 Caddy

Linux（推荐）

# Debian/Ubuntu
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

macOS

brew install caddy

Docker

docker run -d -p 80:80 -p 443:443 \
 -v /data/caddy:/data \
 -v /config/caddy:/config \
 caddy:latest

Caddyfile 配置语法

Caddy 使用 Caddyfile 作为配置文件，语法简洁直观。

基本结构

# 全局配置
{
 email admin@example.com
 acme_ca https://acme-staging-v02.api.letsencrypt.org/directory
}

# 站点配置
example.com {
 # 配置指令
}

实战配置示例

1. 静态网站

example.com {
 root * /var/www/html
 file_server
}

2. 反向代理

api.example.com {
 reverse_proxy localhost:8080
}

# 带负载均衡
app.example.com {
 reverse_proxy backend1:8080 backend2:8080 backend3:8080
}

3. 自动 HTTPS

# Caddy 自动获取并续期 SSL 证书
secure.example.com {
 reverse_proxy localhost:3000
}

4. PHP 支持（WordPress 等）

blog.example.com {
 root * /var/www/wordpress
 php_fastcgi localhost:9000
 file_server
}

5. WebSocket 代理

ws.example.com {
 reverse_proxy localhost:8080 {
 header_up Upgrade {>Upgrade}
 header_up Connection {>Connection}
 }
}

6. 限流配置

⚠️ 注意：rate_limit 不是 Caddy 标准内置指令，需要第三方插件 caddy-ratelimit（官方标注为 experimental）。使用前需用 xcaddy 编译进自定义二进制：xcaddy build --with github.com/mholt/caddy-ratelimit，否则会报 unrecognized directive: rate_limit。

api.example.com {
 rate_limit {
 zone api_zone {
 key {remote_host}
 events 10
 window 1s
 }
 }
 
 reverse_proxy localhost:8080
}

7. 访问控制

admin.example.com {
 # 基本认证（Caddy 2.7+ 指令名为 basic_auth，旧名 basicauth 已废弃）
 basic_auth * {
 admin $2a$14$Zkx19XLiW6VYouLRR8Kj.OXQBKlejFyYi6CZjfCMjh8YBPL5YE5LG
 }
 
 reverse_proxy localhost:8080
}

Caddy vs Nginx 对比

特性	Caddy	Nginx
自动 HTTPS	✅ 内置	❌ 需要 certbot
配置语法	Caddyfile（简洁）	nginx.conf（传统）
配置热更新	✅ API 驱动	⚠️ reload
学习曲线	低	中等
性能	优秀	极致
生态系统	成长中	成熟
适用场景	中小型项目、云原生	大型项目、高性能场景

Caddy API 配置

Caddy 支持通过 REST API 动态管理配置：

# 获取当前配置
curl localhost:2019/config/

# 通过 API 添加站点
curl -X POST localhost:2019/config/apps/http/servers/srv0/routes \
 -H "Content-Type: application/json" \
 -d '{
 "@id": "example",
 "match": [{"host": ["example.com"]}],
 "handle": [{"handler": "reverse_proxy", "upstreams": [{"dial": "localhost:8080"}]}]
 }'

# 删除站点配置
curl -X DELETE localhost:2019/id/example

生产环境最佳实践

1. 性能优化

{
 # 启用 HTTP/3
 servers {
 protocols h1 h2 h3
 }
}

example.com {
 # 启用压缩
 encode gzip zstd
 
 # 缓存静态资源
 @static {
 path *.jpg *.jpeg *.png *.gif *.css *.js
 }
 header @static Cache-Control "public, max-age=31536000"
 
 file_server
}

2. 安全配置

example.com {
 # 安全头
 header {
 X-Frame-Options "SAMEORIGIN"
 X-Content-Type-Options "nosniff"
 X-XSS-Protection "1; mode=block"
 Referrer-Policy "strict-origin-when-cross-origin"
 -Server
 }
 
 # 隐藏 Caddy 标识
 header -Server
 
 reverse_proxy localhost:8080
}

3. 日志配置

{
 log {
 output file /var/log/caddy/access.log {
 roll_size 100mb
 roll_keep 10
 roll_keep_for 720h
 }
 format json
 }
}

example.com {
 log {
 output file /var/log/caddy/example.log
 }
 
 reverse_proxy localhost:8080
}

Caddy systemd 管理

# 启动
sudo systemctl start caddy

# 停止
sudo systemctl stop caddy

# 重启
sudo systemctl restart caddy

# 查看状态
sudo systemctl status caddy

# 开机自启
sudo systemctl enable caddy

# 查看日志
journalctl -u caddy --no-pager -n 50

常见问题

1. 证书申请失败

# 检查 DNS 解析
dig example.com

# 使用 staging 环境测试
{
 acme_ca https://acme-staging-v02.api.letsencrypt.org/directory
}

2. 配置文件位置

# 查找配置文件
caddy environ | grep XDG

# 默认位置
# Linux: /etc/caddy/Caddyfile
# macOS: ~/Library/Application Support/Caddy/Caddyfile

3. 性能不如预期

{
 # 调整服务器参数
 servers {
 max_header_size 16384
 read_timeout 30s
 write_timeout 30s
 idle_timeout 120s
 }
}

总结

Caddy 是一个现代化的 Web 服务器，特别适合：

需要自动 HTTPS 的项目：零配置获取 SSL 证书
中小型项目：配置简洁，上手快
云原生环境：API 驱动，易于自动化
快速原型开发：无需复杂配置

对于大型项目和极致性能要求，Nginx 仍然是更好的选择。但对于大多数场景，Caddy 提供了更现代、更简洁的解决方案。

Nginx从入门到精通：完整教程

Fri, 26 Jun 2026 15:00:00 +0000

Nginx 简介

Nginx（发音为 “engine-x”）是一个高性能的 HTTP 和反向代理 Web 服务器，由俄罗斯的伊戈尔·赛索耶夫开发，第一个版本发布于 2004 年。截至目前，Nginx 已成为全球最流行的 Web 服务器之一，市场份额超过 34%。

Nginx 的核心特点：

高并发：支持约 50000 个并发连接
低内存占用：相比 Apache 等传统服务器，内存消耗极低
配置简洁：学习曲线平缓，配置直观
高稳定性：运行数月无需重启
模块化设计：功能可按需扩展

安装 Nginx

Ubuntu/Debian

sudo apt update
sudo apt install nginx

CentOS/RHEL

sudo yum install epel-release
sudo yum install nginx

macOS（Homebrew）

brew install nginx

从源码编译

# 下载最新稳定版
wget http://nginx.org/download/nginx-1.26.2.tar.gz
tar -zxvf nginx-1.26.2.tar.gz
cd nginx-1.26.2

# 配置编译选项
./configure --prefix=/usr/local/nginx \
 --with-http_ssl_module \
 --with-http_v2_module \
 --with-http_realip_module \
 --with-http_gzip_static_module

# 编译安装
make && sudo make install

常用命令

# 启动
nginx

# 停止
nginx -s stop

# 安全退出
nginx -s quit

# 重新加载配置（不中断服务）
nginx -s reload

# 检查配置文件语法
nginx -t

# 查看版本
nginx -v

# 查看编译参数
nginx -V

# 查看进程
ps aux | grep nginx

配置文件结构

Nginx 配置文件通常位于 /etc/nginx/nginx.conf，结构如下：

# 全局配置
worker_processes auto; # 工作进程数，建议设为CPU核心数
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;

events {
 worker_connections 4096; # 每个进程的最大连接数
 multi_accept on; # 允许同时接受多个连接
 use epoll; # 使用 epoll 事件模型（Linux）
}

http {
 include mime.types;
 default_type application/octet-stream;
 
 # 日志格式
 log_format main '$remote_addr - $remote_user [$time_local] "$request" '
 '$status $body_bytes_sent "$http_referer" '
 '"$http_user_agent"';
 
 access_log /var/log/nginx/access.log main;
 
 # 性能优化
 sendfile on;
 tcp_nopush on;
 tcp_nodelay on;
 keepalive_timeout 65;
 
 # Gzip 压缩
 gzip on;
 gzip_types text/plain text/css application/json application/javascript;
 
 # 虚拟主机配置
 include /etc/nginx/conf.d/*.conf;
}

实战配置示例

1. 静态网站托管

server {
 listen 80;
 server_name example.com www.example.com;
 
 root /var/www/example.com;
 index index.html index.htm;
 
 location / {
 try_files $uri $uri/ =404;
 }
 
 # 静态资源缓存
 location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
 expires 30d;
 add_header Cache-Control "public, immutable";
 }
}

2. 反向代理

server {
 listen 80;
 server_name api.example.com;
 
 location / {
 proxy_pass http://127.0.0.1:8080;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Proto $scheme;
 
 # 超时设置
 proxy_connect_timeout 60s;
 proxy_send_timeout 60s;
 proxy_read_timeout 60s;
 }
}

3. 负载均衡

# 定义上游服务器组
upstream backend {
 # 轮询（默认）
 server backend1.example.com;
 server backend2.example.com;
 
 # 加权轮询
 # server backend1.example.com weight=3;
 # server backend2.example.com weight=1;
 
 # IP Hash（会话保持）
 # ip_hash;
 
 # 最少连接
 # least_conn;
}

server {
 listen 80;
 server_name example.com;
 
 location / {
 proxy_pass http://backend;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 }
}

4. HTTPS/SSL 配置

server {
 listen 443 ssl;
 http2 on;
 server_name secure.example.com;
 
 # SSL 证书
 ssl_certificate /etc/nginx/ssl/example.crt;
 ssl_certificate_key /etc/nginx/ssl/example.key;
 
 # SSL 优化
 ssl_protocols TLSv1.2 TLSv1.3;
 ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
 ssl_prefer_server_ciphers on;
 ssl_session_cache shared:SSL:10m;
 ssl_session_timeout 10m;
 
 location / {
 proxy_pass http://localhost:3000;
 }
}

# HTTP 自动跳转 HTTPS
server {
 listen 80;
 server_name secure.example.com;
 return 301 https://$host$request_uri;
}

5. 限流配置

http {
 # 定义限流区域
 limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;
 limit_conn_zone $binary_remote_addr zone=conn_limit:10m;
 
 server {
 listen 80;
 server_name api.example.com;
 
 location /api/ {
 # 每秒最多10个请求，允许突发20个
 limit_req zone=api_limit burst=20 nodelay;
 
 # 每个IP最多5个并发连接
 limit_conn conn_limit 5;
 
 proxy_pass http://backend;
 }
 }
}

6. WebSocket 代理

server {
 listen 80;
 server_name ws.example.com;
 
 location /ws/ {
 proxy_pass http://localhost:8080;
 proxy_http_version 1.1;
 proxy_set_header Upgrade $http_upgrade;
 proxy_set_header Connection "upgrade";
 proxy_set_header Host $host;
 proxy_read_timeout 3600s;
 }
}

性能调优

系统级优化

# /etc/sysctl.conf
net.core.somaxconn = 65535
net.ipv4.tcp_max_tw_buckets = 65535
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 1200
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# 使配置生效
sudo sysctl -p

Nginx 级优化

worker_processes auto;
worker_rlimit_nofile 65535;

events {
 worker_connections 65535;
 multi_accept on;
 use epoll;
}

http {
 # 开启 sendfile
 sendfile on;
 tcp_nopush on;
 tcp_nodelay on;
 
 # 连接超时优化
 keepalive_timeout 65;
 keepalive_requests 1000;
 
 # 缓冲区优化
 client_body_buffer_size 16k;
 client_header_buffer_size 1k;
 client_max_body_size 8m;
 large_client_header_buffers 4 8k;
 
 # 开启文件缓存
 open_file_cache max=10000 inactive=20s;
 open_file_cache_valid 30s;
 open_file_cache_min_uses 2;
 open_file_cache_errors on;
}

安全配置

server {
 # 隐藏版本号
 server_tokens off;
 
 # 安全响应头
 add_header X-Frame-Options "SAMEORIGIN" always;
 add_header X-Content-Type-Options "nosniff" always;
 add_header X-XSS-Protection "1; mode=block" always;
 add_header Referrer-Policy "strict-origin-when-cross-origin" always;
 add_header Content-Security-Policy "default-src 'self'" always;
 
 # 禁止访问隐藏文件
 location ~ /\. {
 deny all;
 access_log off;
 log_not_found off;
 }
 
 # 禁止访问特定文件
 location ~* \.(bak|sql|conf)$ {
 deny all;
 }
}

常见问题排查

1. 502 Bad Gateway

# 检查上游服务是否运行
curl http://localhost:8080

# 检查 Nginx 错误日志
tail -f /var/log/nginx/error.log

# 常见原因：
# - 上游服务未启动
# - 连接超时
# - 缓冲区溢出

2. 413 Request Entity Too Large

# 增大请求体大小限制
client_max_body_size 100m;

3. 配置不生效

# 检查配置语法
nginx -t

# 重新加载配置
nginx -s reload

# 确认配置文件路径
nginx -V 2>&1 | grep conf

总结

Nginx 是现代 Web 架构中不可或缺的组件，掌握它的配置和调优对于运维和开发人员都至关重要。核心要点：

理解配置结构：main → events → http → server → location
掌握核心功能：静态服务、反向代理、负载均衡、HTTPS
注重安全配置：隐藏版本号、安全头、访问控制
持续性能调优：系统参数、Nginx 参数、缓存策略

建议在实际项目中多练习，从简单的静态网站开始，逐步尝试反向代理、负载均衡等高级功能。

macOS Homebrew 完全指南：安装、配置与常用命令

Thu, 25 Jun 2026 16:00:00 +0000

前言

Homebrew 是 macOS 上最流行的包管理器，被称为"macOS 缺失的包管理器"。它让在 Mac 上安装、更新和管理软件变得像在 Linux 上用 apt/yum 一样简单。无论你是开发者还是普通用户，Homebrew 都是 macOS 必装工具。

1. 安装 Homebrew

1.1 官方安装

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

1.2 国内镜像安装（加速）

# 使用中科大镜像
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.ustc.edu.cn/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.ustc.edu.cn/homebrew-core.git"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles"
/bin/bash -c "$(curl -fsSL https://mirrors.ustc.edu.cn/misc/brew-install.sh)"

# 或者使用清华镜像
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/homebrew-core.git"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.tuna.tsinghua.edu.cn/homebrew-bottles"

1.3 配置环境变量

# Intel Mac
echo 'eval "$(/usr/local/bin/brew shellenv)"' >> ~/.zshrc

# Apple Silicon (M1/M2/M3)
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc

source ~/.zshrc

1.4 验证安装

brew --version # 查看版本
brew --prefix # 安装路径
brew --repo # 仓库路径
brew doctor # 检查环境是否正常

2. 软件包管理

2.1 搜索与查看

# 搜索软件包
brew search nginx
brew search java
brew search --casks chrome # 只搜索 Cask（GUI 应用）
brew search --formulae python # 只搜索 Formula（命令行工具）

# 查看软件包信息
brew info nginx
brew info node
brew info --cask google-chrome

# 列出已安装的包
brew list # 所有已安装
brew list --formulae # 只列命令行工具
brew list --cask # 只列 GUI 应用
brew list nginx # 查看某个包安装了哪些文件
brew list --versions node # 显示版本号

2.2 安装与卸载

# 安装命令行工具（Formula）
brew install git
brew install node
brew install python@3.12 # 指定版本
brew install nginx
brew install mysql
brew install redis
brew install wget
brew install tree
brew install htop
brew install jq
brew install ripgrep
brew install fd

# 安装 GUI 应用（Cask）
brew install --cask google-chrome
brew install --cask visual-studio-code
brew install --cask iterm2
brew install --cask docker
brew install --cask firefox
brew install --cask postman
brew install --cask obsidian
brew install --cask rectangle
brew install --cask stats
brew install --cask orbstack

# 卸载
brew uninstall nginx
brew uninstall --cask google-chrome
brew uninstall --force nginx # 强制卸载

# 重新安装
brew reinstall nginx

2.3 更新与升级

# 更新 Homebrew 自身（获取最新包信息）
brew update

# 查看可升级的包
brew outdated

# 升级所有过时的包
brew upgrade

# 升级指定包
brew upgrade node
brew upgrade --cask google-chrome

# 锁定某个包版本（不自动升级）
brew pin node

# 解除锁定
brew unpin node

3. 服务管理（Services）

Homebrew 内置了服务管理功能，替代手动的 launchctl 操作。

# 查看所有服务
brew services list

# 启动服务
brew services start nginx
brew services start mysql
brew services start redis

# 停止服务
brew services stop nginx

# 重启服务
brew services restart nginx

# 查看服务状态
brew services info nginx

# 运行服务（不设为开机启动）
brew services run nginx

# 清理已停止的服务
brew services cleanup

4. 清理与维护

# 清理旧版本和缓存
brew cleanup # 清理所有旧版本
brew cleanup -n # 预览要清理的内容（不实际执行）
brew cleanup --prune=all # 清理所有缓存

# 查看可清理的内容
brew autoremove # 删除不再需要的依赖

# 查看缓存位置
brew --cache
brew cache --formulae # Formula 缓存
brew cache --cask # Cask 缓存

# 清除缓存
brew cache prune
brew cleanup --prune=all

# 诊断问题
brew doctor # 检查环境问题
brew config # 查看配置信息

5. 高级用法

5.1 版本管理

# 安装指定版本
brew install python@3.11
brew install python@3.12

# 切换版本（使用 brew link）
brew unlink python@3.11
brew link python@3.12

# 查看已安装的版本
brew list --versions python

# 使用 @ 符号的版本
brew install node@18
brew install node@20
brew link --overwrite node@20

5.2 Brewfile（批量管理）

# 生成 Brewfile（导出当前已安装的包）
brew bundle dump

# 从 Brewfile 安装（批量安装）
brew bundle

# 指定文件
brew bundle --file=Brewfile

# 检查 Brewfile 中是否有未安装的
brew bundle check

# 示例 Brewfile
cat << 'EOF' > Brewfile
# 命令行工具
brew "git"
brew "node"
brew "python@3.12"
brew "wget"
brew "tree"
brew "htop"
brew "jq"

# GUI 应用
cask "google-chrome"
cask "visual-studio-code"
cask "iterm2"
cask "docker"
cask "obsidian"

# Mac App Store 应用
mas "Xcode", id: 497799835
mas "WeChat", id: 836500024
EOF

5.3 自定义 Tap（软件源）

# 添加第三方 Tap
brew tap homebrew/cask-fonts
brew tap homebrew/services
brew tap heroku/brew

# 查看已添加的 Tap
brew tap

# 删除 Tap
brew untap heroku/brew

5.4 常用软件推荐

# 开发工具
brew install git # 版本控制
brew install node # Node.js
brew install python@3.12 # Python
brew install go # Go
brew install openjdk@17 # Java 17
brew install maven # Maven
brew install gradle # Gradle
brew install docker # Docker CLI
brew install kubectl # Kubernetes CLI
brew install helm # Helm

# 命令行增强
brew install zsh-autosuggestions # zsh 自动补全
brew install zsh-syntax-highlighting # zsh 语法高亮
brew install starship # 终端美化提示符
brew install fzf # 模糊搜索
brew install ripgrep # 快速 grep (rg)
brew install fd # 快速 find
brew install bat # 增强版 cat
brew install exa # 增强版 ls
brew install delta # 增强版 git diff
brew install lazygit # Git TUI
brew install neovim # 增强版 vim
brew install tmux # 终端复用

# 网络工具
brew install wget # 下载工具
brew install curl # HTTP 工具
brew install httpie # 友好的 HTTP 客户端
brew install nmap # 网络扫描
brew install socat # 网络工具

# 实用工具
brew install tree # 目录树
brew install htop # 进程监控
brew install jq # JSON 处理
brew install yq # YAML 处理
brew install watch # 定时执行命令
brew install tldr # 简化版 man
brew install the_silver_searcher # 快速搜索 (ag)

# GUI 应用
brew install --cask visual-studio-code # VS Code
brew install --cask iterm2 # 终端
brew install --cask google-chrome # Chrome
brew install --cask firefox # Firefox
brew install --cask docker # Docker Desktop
brew install --cask postman # API 测试
brew install --cask obsidian # 笔记
brew install --cask rectangle # 窗口管理
brew install --cask stats # 系统监控
brew install --cask orbstack # 轻量 Docker/VM
brew install --cask raycast # 启动器
brew install --cask drawio # 画图
brew install --cask ngrok # 内网穿透

6. 镜像加速配置

# 中科大镜像（推荐）
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.ustc.edu.cn/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.ustc.edu.cn/homebrew-core.git"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles"
export HOMEBREW_API_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles/api"

# 写入 ~/.zshrc 持久化
cat << 'EOF' >> ~/.zshrc
# Homebrew 镜像加速
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.ustc.edu.cn/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.ustc.edu.cn/homebrew-core.git"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles"
export HOMEBREW_API_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles/api"
EOF

# 清华镜像
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/homebrew-core.git"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.tuna.tsinghua.edu.cn/homebrew-bottles"

7. 常见问题

7.1 权限问题

# 修复 /usr/local 目录权限（Intel Mac）
sudo chown -R $(whoami) /usr/local/*

# 修复 /opt/homebrew 目录权限（Apple Silicon）
sudo chown -R $(whoami) /opt/homebrew/*

7.2 brew doctor 常见警告

# "Your Command Line Tools are too outdated"
xcode-select --install

# "Your Homebrew's prefix is not /usr/local"
# Apple Silicon 正常，前缀是 /opt/homebrew

# "Unbrewed files were found in /usr/local"
# 删除提示的文件即可

7.3 卸载 Homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/uninstall.sh)"

总结

Homebrew 核心命令速查：

操作	命令
安装	`brew install <pkg>` / `brew install --cask <app>`
卸载	`brew uninstall <pkg>`
搜索	`brew search <keyword>`
信息	`brew info <pkg>`
更新	`brew update && brew upgrade`
清理	`brew cleanup && brew autoremove`
服务	`brew services start/stop/restart <svc>`
列表	`brew list`
诊断	`brew doctor`
批量	`brew bundle` (Brewfile)

Homebrew 让 macOS 的软件管理变得简单高效。配合镜像加速，体验更加流畅。

Docker 常用命令与实战：从入门到精通

Thu, 25 Jun 2026 15:30:00 +0000

前言

Docker 已经成为现代开发运维的基础设施。无论是本地开发环境搭建、微服务部署，还是 CI/CD 流水线，Docker 都扮演着核心角色。本文整理了 Docker 最常用的命令和实战技巧。

当前版本：Docker Engine v29.6.0（2026 年 6 月）。containerd 镜像存储已成为默认，Docker Scout 用于供应链安全扫描。

1. 镜像管理

1.1 拉取与查看

# 拉取镜像
docker pull nginx
docker pull nginx:1.25 # 指定版本
docker pull mysql:8.0
docker pull registry.cn-hangzhou.aliyuncs.com/library/nginx # 阿里云镜像

# 查看本地镜像
docker images
docker images -a # 包含中间层镜像
docker images --digests # 显示摘要
docker images -q # 只显示 ID

# 搜索镜像
docker search nginx
docker search --filter=stars=100 nginx # 按星数过滤

1.2 构建与删除

# 构建镜像
docker build -t myapp:1.0 .
docker build -t myapp:1.0 -f Dockerfile.prod .
docker build -t myapp:1.0 --no-cache . # 不使用缓存
docker build -t myapp:1.0 --build-arg ENV=prod . # 传入构建参数

# 删除镜像
docker rmi nginx
docker rmi $(docker images -q) # 删除所有镜像
docker image prune # 删除悬空镜像
docker image prune -a # 删除未使用的镜像

# 镜像打标签
docker tag myapp:1.0 myregistry.com/myapp:1.0
docker tag myapp:1.0 myregistry.com/myapp:latest

# 推送镜像
docker push myregistry.com/myapp:1.0

# 导出/导入镜像
docker save -o nginx.tar nginx:latest
docker load -i nginx.tar

2. 容器管理

2.1 创建与运行

# 基本运行
docker run nginx
docker run -d nginx # 后台运行
docker run --name my-nginx -d nginx # 指定名称
docker run -d -p 80:80 nginx # 端口映射
docker run -d -p 8080:80 nginx # 外部8080 → 容器80
docker run -d -p 127.0.0.1:3306:3306 mysql # 仅本地访问

# 带环境变量
docker run -d -e MYSQL_ROOT_PASSWORD=123456 mysql
docker run -d --env-file .env myapp # 从文件读取环境变量

# 挂载卷
docker run -d -v /host/path:/container/path nginx
docker run -d -v /data/mysql:/var/lib/mysql mysql
docker run -d -v mydata:/data nginx # 命名卷
docker run -d -v /host/path:/container/path:ro nginx # 只读挂载

# 限制资源
docker run -d --memory=512m --cpus=1.5 myapp
docker run -d --memory=1g --cpus=2 myapp

# 重启策略
docker run -d --restart=always nginx # 总是重启
docker run -d --restart=unless-stopped nginx # 除非手动停止
docker run -d --restart=on-failure:3 myapp # 失败最多重启3次

# 网络
docker run -d --network=host nginx # 使用宿主机网络
docker run -d --network=mynet myapp # 使用自定义网络

# 交互式运行
docker run -it ubuntu /bin/bash # 进入容器
docker run -it --rm ubuntu /bin/bash # 退出后自动删除

2.2 查看与操作

# 查看容器
docker ps # 运行中的容器
docker ps -a # 所有容器（含已停止）
docker ps -q # 只显示 ID
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"

# 查看容器详情
docker inspect my-nginx
docker inspect --format '{{.NetworkSettings.IPAddress}}' my-nginx

# 查看日志
docker logs my-nginx
docker logs -f my-nginx # 实时追踪
docker logs --tail 100 my-nginx # 最后100行
docker logs --since 1h my-nginx # 最近1小时
docker logs -f --tail 50 my-nginx # 实时追踪最后50行

# 进入运行中的容器
docker exec -it my-nginx /bin/bash
docker exec -it my-nginx /bin/sh # Alpine 镜像用 sh
docker exec my-nginx cat /etc/nginx/nginx.conf # 不进入执行命令

# 复制文件
docker cp file.txt my-nginx:/path/ # 容器 → 宿主机
docker cp my-nginx:/path/file.txt ./ # 宿主机 → 容器

# 停止/启动/重启
docker stop my-nginx
docker stop $(docker ps -q) # 停止所有容器
docker start my-nginx
docker restart my-nginx

# 删除容器
docker rm my-nginx
docker rm -f my-nginx # 强制删除运行中的容器
docker rm $(docker ps -aq) # 删除所有容器
docker container prune # 删除已停止的容器

# 查看容器资源使用
docker stats
docker stats --no-stream # 只显示一次
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# 查看容器进程
docker top my-nginx

# 查看端口映射
docker port my-nginx

3. Dockerfile 编写

3.1 常用指令

# 基础镜像
FROM openjdk:17-jdk-slim
FROM node:18-alpine
FROM python:3.11-slim

# 维护者信息
LABEL maintainer="your@email.com"

# 工作目录
WORKDIR /app

# 复制文件
COPY package.json ./
COPY src/ ./src/
COPY --from=builder /app/dist ./dist # 多阶段构建

# 添加文件（支持 URL 和自动解压）
ADD app.tar.gz /app/
ADD https://example.com/file /app/

# 执行命令
RUN apt-get update && apt-get install -y \
 curl \
 vim \
 && rm -rf /var/lib/apt/lists/*

RUN npm install

# 环境变量
ENV NODE_ENV=production
ENV JAVA_OPTS="-Xmx512m"

# 暴露端口
EXPOSE 8080
EXPOSE 3306 6379

# 启动命令
CMD ["node", "server.js"]
CMD ["java", "-jar", "app.jar"]

# 入口点（不会被 docker run 的参数覆盖）
ENTRYPOINT ["java", "-jar"]
CMD ["app.jar"] # 默认参数，可被覆盖

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
 CMD curl -f http://localhost:8080/health || exit 1

# 卷
VOLUME ["/data"]

# 用户
RUN useradd -r -s /bin/false appuser
USER appuser

3.2 多阶段构建

# 阶段一：构建
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src/ ./src/
RUN mvn package -DskipTests

# 阶段二：运行
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

3.3 最佳实践

# ✅ 合并 RUN 指令减少层数
RUN apt-get update && apt-get install -y \
 curl \
 && rm -rf /var/lib/apt/lists/*

# ✅ 使用 .dockerignore
# .git, node_modules, *.log, .env

# ✅ 把变化频率低的指令放前面（利用缓存）
COPY package.json . # 先复制依赖文件
RUN npm install # 安装依赖
COPY . . # 最后复制源码

# ✅ 使用非 root 用户
RUN addgroup -S app && adduser -S app -G app
USER app

# ✅ 使用 Alpine 镜像减小体积
FROM node:18-alpine

4. 网络管理

# 创建网络
docker network create mynet
docker network create --driver bridge mynet
docker network create --subnet 172.20.0.0/16 mynet

# 查看网络
docker network ls
docker network inspect mynet

# 连接/断开网络
docker network connect mynet my-nginx
docker network disconnect mynet my-nginx

# 删除网络
docker network rm mynet
docker network prune # 删除未使用的网络

# 容器间通信（同一网络内可通过容器名访问）
docker run -d --name mysql --network=mynet mysql
docker run -d --name app --network=mynet myapp
# app 容器中可以直接用 mysql:3306 访问数据库

5. 数据卷管理

# 创建卷
docker volume create mydata

# 查看卷
docker volume ls
docker volume inspect mydata

# 删除卷
docker volume rm mydata
docker volume prune # 删除未使用的卷

# 使用命名卷
docker run -d -v mydata:/var/lib/mysql mysql

# 绑定挂载（目录映射）
docker run -d -v /host/path:/container/path nginx

# tmpfs 挂载（内存中）
docker run -d --tmpfs /app/cache myapp

6. Docker Compose

6.1 基本语法

# docker-compose.yml
version: '3.8'

services:
 web:
 build: .
 ports:
 - "8080:80"
 environment:
 - NODE_ENV=production
 volumes:
 - ./src:/app/src
 depends_on:
 - db
 - redis
 restart: unless-stopped
 networks:
 - app-net

 db:
 image: mysql:8.0
 environment:
 MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
 MYSQL_DATABASE: myapp
 volumes:
 - mysql-data:/var/lib/mysql
 - ./init.sql:/docker-entrypoint-initdb.d/init.sql
 ports:
 - "3306:3306"
 networks:
 - app-net

 redis:
 image: redis:7-alpine
 ports:
 - "6379:6379"
 networks:
 - app-net

volumes:
 mysql-data:

networks:
 app-net:
 driver: bridge

Docker Compose V1（docker-compose）已完全弃用，请使用 V2（docker compose，无连字符）。

6.2 常用命令

# 启动
docker compose up -d # 后台启动所有服务
docker compose up -d --build # 重新构建并启动
docker compose up -d web # 只启动指定服务

# 停止
docker compose down # 停止并删除容器
docker compose down -v # 同时删除卷
docker compose down --rmi all # 同时删除镜像

# 查看
docker compose ps # 查看服务状态
docker compose logs # 查看日志
docker compose logs -f web # 实时追踪指定服务日志

# 其他操作
docker compose exec web /bin/bash # 进入容器
docker compose restart web # 重启服务
docker compose pull # 拉取最新镜像
docker compose config # 验证配置文件
docker compose top # 查看进程

7. 实战场景

7.1 快速搭建 MySQL

docker run -d \
 --name mysql8 \
 -p 3306:3306 \
 -e MYSQL_ROOT_PASSWORD=123456 \
 -e MYSQL_DATABASE=mydb \
 -e MYSQL_USER=app \
 -e MYSQL_PASSWORD=apppwd \
 -v /data/mysql:/var/lib/mysql \
 --restart=unless-stopped \
 mysql:8.0 \
 --character-set-server=utf8mb4 \
 --collation-server=utf8mb4_unicode_ci

7.2 快速搭建 Redis

docker run -d \
 --name redis \
 -p 6379:6379 \
 -v /data/redis:/data \
 --restart=unless-stopped \
 redis:7-alpine \
 redis-server --appendonly yes --requirepass "mypassword"

7.3 快速搭建 Nginx

docker run -d \
 --name nginx \
 -p 80:80 \
 -p 443:443 \
 -v /data/nginx/conf.d:/etc/nginx/conf.d \
 -v /data/nginx/html:/usr/share/nginx/html \
 -v /data/nginx/ssl:/etc/nginx/ssl \
 --restart=unless-stopped \
 nginx:alpine

7.4 Java 应用部署

docker run -d \
 --name myapp \
 -p 8080:8080 \
 -e JAVA_OPTS="-Xmx512m -Xms256m" \
 -v /data/app/logs:/app/logs \
 -v /data/app/config:/app/config \
 --restart=unless-stopped \
 myapp:1.0

8. 常用技巧

# 清理所有未使用的资源（镜像、容器、网络、卷）
docker system prune -a --volumes
docker system df # 查看资源占用

# 批量操作
docker stop $(docker ps -q) # 停止所有容器
docker rm $(docker ps -aq) # 删除所有容器
docker rmi $(docker images -q) # 删除所有镜像

# 查看容器 IP
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' my-nginx

# 导出/导入容器
docker export my-nginx > nginx.tar
docker import nginx.tar my-nginx:backup

# 查看镜像构建历史
docker history myapp:1.0

# 实时查看容器资源
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"

# 修改运行中容器的重启策略
docker update --restart=unless-stopped my-nginx

# 查看容器内文件系统变化
docker diff my-nginx

总结

Docker 核心知识点：

镜像管理 — pull/build/tag/push/save/load
容器管理 — run/exec/logs/stop/rm/stats
网络管理 — network create/connect/inspect
数据卷 — volume create/bind mount/tmpfs
Dockerfile — 多阶段构建、最佳实践
Docker Compose — 多服务编排、依赖管理

掌握这些命令，就能应对 90% 以上的日常 Docker 操作。

Linux 常用终端命令完全指南

Thu, 25 Jun 2026 13:00:00 +0000

Linux 终端命令是每一位开发者和运维工程师的必备技能。本文整理了日常工作中最常用的 12 大类命令，配合丰富的实战示例，帮助你快速上手和查阅。

一、文件管理

1.1 ls — 列出目录内容

# 显示所有文件（包括隐藏文件）
ls -a

# 长格式显示（权限、所有者、大小、时间）
ls -l

# 人类可读的文件大小（KB/MB/GB）
ls -lh

# 按修改时间排序（最新在前）
ls -lt

# 递归显示子目录内容
ls -R

# 组合使用：显示所有文件，按时间排序，人类可读大小
ls -alht

# 显示目录本身信息而非内容
ls -ld /var/log

1.2 cp — 复制文件/目录

# 复制文件
cp file1.txt file2.txt

# 递归复制目录
cp -r /home/user/project /backup/

# 覆盖前提示确认
cp -i important.conf /etc/

# 保留文件属性（权限、时间戳）
cp -p original.txt backup.txt

# 复制多个文件到目录
cp file1.txt file2.txt file3.txt /tmp/backup/

# 复制时保留软链接
cp -a /source/dir /dest/dir

1.3 mv — 移动/重命名

# 重命名文件
mv old_name.txt new_name.txt

# 移动文件到目录
mv report.pdf /home/user/Documents/

# 覆盖前提示
mv -i source.txt /backup/

# 不覆盖已有文件
mv -n source.txt /backup/

# 批量移动
mv *.log /var/log/archive/

1.4 rm — 删除文件/目录

# 删除文件
rm file.txt

# 递归删除目录及其内容
rm -r old_project/

# 强制删除，不提示
rm -f temp.txt

# 递归强制删除（常用于清理）
rm -rf /tmp/build_output/

# 删除前逐一确认
rm -i *.log

# 删除当前目录下所有文件（危险！）
# rm -rf / ← 绝对不要执行！

1.5 mkdir — 创建目录

# 创建单个目录
mkdir my_project

# 递归创建多级目录
mkdir -p /home/user/projects/webapp/src/components

# 创建并设置权限
mkdir -m 755 public_dir

# 批量创建
mkdir -p project/{src,bin,doc,test}

1.6 find — 查找文件

# 按名称查找
find /home -name "*.log"

# 不区分大小写查找
find . -iname "readme.md"

# 按类型查找（f=文件，d=目录，l=软链接）
find /var -type f -name "*.conf"

# 按修改时间查找（7天内修改过的文件）
find /home -mtime -7

# 超过30天未修改的文件
find /tmp -mtime +30

# 按大小查找（大于100MB的文件）
find / -size +100M

# 查找并删除
find /tmp -name "*.tmp" -mtime +7 -delete

# 查找并执行命令
find . -name "*.log" -exec gzip {} \;

# 查找空文件和空目录
find . -empty

# 按权限查找
find / -perm 777 -type f

1.7 locate / updatedb — 快速定位文件

# 使用数据库快速查找（比 find 快得多）
locate nginx.conf

# 更新文件数据库（需要 root 权限）
sudo updatedb

# 忽略大小写
locate -i "readme"

# 限制输出数量
locate -n 10 "*.conf"

1.8 touch — 创建空文件/更新时间戳

# 创建空文件
touch newfile.txt

# 批量创建
touch file{1..10}.txt

# 只更新访问时间
touch -a existing_file

# 只更新修改时间
touch -m existing_file

# 指定时间戳
touch -t 202606251200 myfile.txt

1.9 cat — 查看文件内容

# 查看文件内容
cat /etc/hostname

# 显示行号
cat -n /etc/passwd

# 合并多个文件
cat file1.txt file2.txt > merged.txt

# 追加内容
cat file2.txt >> file1.txt

# 显示非打印字符
cat -A /etc/hosts

1.10 head / tail — 查看文件头尾

# 查看前 10 行（默认）
head /var/log/syslog

# 查看前 20 行
head -n 20 /var/log/syslog

# 查看最后 10 行
tail /var/log/syslog

# 查看最后 50 行
tail -n 50 /var/log/syslog

# 实时跟踪文件变化（日志监控利器）
tail -f /var/log/syslog

# 实时跟踪并显示最后 100 行
tail -n 100 -f /var/log/nginx/access.log

1.11 less — 分页查看

# 分页查看大文件
less /var/log/syslog

# 常用快捷键：
# 空格 / PageDown — 下一页
# b / PageUp — 上一页
# /keyword — 向下搜索
# ?keyword — 向上搜索
# n — 下一个匹配
# N — 上一个匹配
# g — 跳到文件开头
# G — 跳到文件末尾
# q — 退出

# 显示行号
less -N large_file.txt

1.12 wc — 统计行数/字数

# 统计行数
wc -l /etc/passwd

# 统计单词数
wc -w document.txt

# 统计字符数
wc -c document.txt

# 全部统计
wc -lwc document.txt

# 统计目录下文件数量
find . -type f | wc -l

1.13 ln — 创建链接

# 创建软链接（符号链接）
ln -s /usr/local/bin/node /usr/bin/node

# 创建硬链接
ln original.txt hard_link.txt

# 查看链接指向
ls -l symlink_name

# 创建目录的软链接
ln -s /var/www/html my_web

软链接 vs 硬链接： 软链接类似 Windows 快捷方式，可跨文件系统，删除原文件后失效；硬链接是文件的另一个名字，与原文件共享 inode，删除原文件仍可访问，但不能跨文件系统。

二、文本处理三剑客

2.1 grep — 文本搜索

# 基本搜索
grep "error" /var/log/syslog

# 忽略大小写
grep -i "error" /var/log/syslog

# 递归搜索目录下所有文件
grep -r "TODO" ./src/

# 显示行号
grep -n "function" app.js

# 反向匹配（排除匹配行）
grep -v "^#" /etc/nginx/nginx.conf

# 统计匹配行数
grep -c "404" /var/log/nginx/access.log

# 显示匹配行及后 3 行
grep -A 3 "Exception" app.log

# 显示匹配行及前 3 行
grep -B 3 "Exception" app.log

# 前后各 3 行
grep -C 3 "Exception" app.log

# 使用正则表达式（扩展正则）
grep -E "error|warning|critical" /var/log/syslog

# 精确匹配单词
grep -w "root" /etc/passwd

# 仅显示匹配部分
grep -o "error:[0-9]*" app.log

# 从文件读取模式
grep -f patterns.txt data.txt

2.2 sed — 流编辑器

# 替换文本（仅输出，不修改原文件）
sed 's/old/new/' file.txt

# 全局替换
sed 's/old/new/g' file.txt

# 直接修改原文件
sed -i 's/old/new/g' file.txt

# 修改前备份原文件
sed -i.bak 's/old/new/g' file.txt

# 显示第 5 到第 10 行
sed -n '5,10p' file.txt

# 删除第 3 行
sed '3d' file.txt

# 删除空行
sed '/^$/d' file.txt

# 删除包含 "comment" 的行
sed '/comment/d' file.txt

# 在第 5 行后追加内容
sed '5a\这是一行新增内容' file.txt

# 在第 1 行前插入
sed '1i\文件头部插入' file.txt

# 替换第 2 到第 5 行
sed '2,5s/old/new/g' file.txt

# 使用不同的分隔符（处理路径时很有用）
sed 's|/usr/local|/opt|g' config.txt

# 多个替换
sed -e 's/foo/bar/g' -e 's/baz/qux/g' file.txt

# 在匹配行后追加
sed '/pattern/a\追加内容' file.txt

2.3 awk — 文本分析利器

# 打印第一列
awk '{print $1}' file.txt

# 打印第一列和第三列
awk '{print $1, $3}' file.txt

# 指定分隔符
awk -F: '{print $1, $3}' /etc/passwd

# 打印行号和内容
awk '{print NR, $0}' file.txt

# 条件过滤
awk '$3 > 100 {print $1, $3}' data.txt

# 模式匹配
awk '/error/ {print $0}' app.log

# BEGIN 和 END 块
awk 'BEGIN {print "=== Report ==="} {print $0} END {print "=== End ==="}' data.txt

# 求和
awk '{sum += $3} END {print "Total:", sum}' data.txt

# 格式化输出
awk '{printf "%-20s %10d\n", $1, $3}' data.txt

# 统计行数
awk 'END {print NR}' file.txt

# 打印最后一列
awk '{print $NF}' file.txt

# 去重并统计
awk '!seen[$0]++' file.txt

# 多分隔符
awk -F'[,;:]' '{print $1, $2}' file.txt

# 处理 CSV 并计算
awk -F',' '{total+=$3} END {print "Average:", total/NR}' sales.csv

2.4 sort — 排序

# 默认按字母排序
sort file.txt

# 按数值排序
sort -n numbers.txt

# 逆序排列
sort -r file.txt

# 按第 2 列数值排序
sort -k2 -n data.txt

# 去重排序
sort -u file.txt

# 按多个键排序
sort -k1,1 -k2,2n data.txt

# 按文件大小排序（ls 结合 sort）
ls -lS | sort -k5 -n -r

# 按月份排序
sort -M months.txt

2.5 uniq — 去重统计

# 去除连续重复行
sort file.txt | uniq

# 统计每行出现次数
sort file.txt | uniq -c

# 仅显示重复行
sort file.txt | uniq -d

# 仅显示不重复的行
sort file.txt | uniq -u

# 忽略前 N 个字段
sort file.txt | uniq -f 2

2.6 cut — 截取文本列

# 按分隔符截取第 1 列
cut -d: -f1 /etc/passwd

# 截取第 1 和第 3 列
cut -d: -f1,3 /etc/passwd

# 按字符位置截取
cut -c1-10 file.txt

# 截取 CSV 文件的第 2 列
cut -d',' -f2 data.csv

2.7 tr — 字符转换

# 小写转大写
echo "hello world" | tr 'a-z' 'A-Z'

# 大写转小写
echo "HELLO" | tr 'A-Z' 'a-z'

# 删除字符
echo "hello 123 world" | tr -d '0-9'

# 压缩连续空格
echo "hello world" | tr -s ' '

# 替换换行为空格
cat file.txt | tr '\n' ' '

# 删除换行符
cat file.txt | tr -d '\n'

# 用逗号替换制表符
cat data.tsv | tr '\t' ','

2.8 tee — 输出到文件同时打印

# 输出到屏幕同时写入文件
echo "log message" | tee output.txt

# 追加模式
echo "more log" | tee -a output.txt

# 管道中使用
make 2>&1 | tee build.log

# 同时写入多个文件
echo "data" | tee file1.txt file2.txt

2.9 xargs — 构建命令行

# 基本用法
echo "file1 file2 file3" | xargs rm

# 从文件读取
cat file_list.txt | xargs rm -f

# 每次处理一个参数
cat urls.txt | xargs -n 1 wget

# 并行执行
cat hosts.txt | xargs -P 4 -I {} ssh {} 'uptime'

# 处理含空格的文件名
find . -name "*.log" -print0 | xargs -0 rm

# 结合 grep 使用
find . -name "*.py" | xargs grep "import"

2.10 diff — 文件比较

# 比较两个文件
diff file1.txt file2.txt

# 统一格式（更易读）
diff -u file1.txt file2.txt

# 递归比较目录
diff -r /backup/old /backup/new

# 并排显示
diff -y file1.txt file2.txt

# 忽略空白差异
diff -w file1.txt file2.txt

# 生成补丁文件
diff -u original.txt modified.txt > changes.patch

三、用户与权限

3.1 chmod — 修改文件权限

# 数字模式
chmod 755 script.sh # rwxr-xr-x（所有者完全，组和其他读+执行）
chmod 644 config.txt # rw-r--r--（所有者读写，其他只读）
chmod 600 secret.key # rw-------（仅所有者读写）
chmod 777 public_dir # rwxrwxrwx（所有人完全，慎用！）

# 符号模式
chmod u+x script.sh # 给所有者添加执行权限
chmod go-w file.txt # 移除组和其他的写权限
chmod a+r document.pdf # 给所有人添加读权限
chmod u=rwx,g=rx,o=r file # 精确设置

# 递归修改目录权限
chmod -R 755 /var/www/html/

# 设置 SUID（执行时以文件所有者身份运行）
chmod u+s /usr/bin/program

# 设置 SGID（目录下新建文件继承目录的组）
chmod g+s /shared/dir

# 设置 Sticky Bit（只有文件所有者能删除）
chmod +t /tmp

3.2 chown — 修改文件所有者

# 修改所有者
chown user1 file.txt

# 修改所有者和组
chown user1:group1 file.txt

# 只修改组
chown :group1 file.txt

# 递归修改
chown -R www-data:www-data /var/www/html/

# 修改软链接本身（而非指向的文件）
chown -h user1 symlink

3.3 chgrp — 修改文件所属组

chgrp developers project_dir
chgrp -R developers /opt/project/

3.4 useradd — 创建用户

# 创建用户并生成主目录
useradd -m newuser

# 指定默认 Shell
useradd -m -s /bin/bash newuser

# 指定主组和附加组
useradd -m -g developers -G docker,sudo newuser

# 指定 UID
useradd -m -u 1500 newuser

# 创建系统用户（无登录权限，用于服务）
useradd -r -s /usr/sbin/nologin serviceuser

3.5 usermod — 修改用户

# 添加附加组
usermod -aG docker username

# 更改默认 Shell
usermod -s /bin/zsh username

# 更改用户名
usermod -l newname oldname

# 锁定账户
usermod -L username

# 解锁账户
usermod -U username

# 修改主目录
usermod -d /home/newpath -m username

# 设置账户过期日期
usermod -e 2026-12-31 username

3.6 其他用户管理命令

# 修改密码
passwd username

# 切换用户
su - username

# 以 root 身份执行命令
sudo apt update

# 以其他用户身份执行
sudo -u www-data cat /var/www/index.html

# 查看当前用户
whoami

# 查看用户 ID 和组信息
id username

# 查看当前用户所属组
groups username

# 查看所有登录用户
who

# 查看用户最近登录
last username

四、进程管理

4.1 ps — 查看进程

# 查看所有进程（BSD 风格）
ps aux

# 查看所有进程（System V 风格）
ps -ef

# 查看指定用户的进程
ps -u username

# 查看指定进程
ps -p 1234,5678

# 按 CPU 使用率排序
ps aux --sort=-%cpu | head -20

# 按内存使用率排序
ps aux --sort=-%mem | head -20

# 查看进程树
ps auxf

# 自定义输出格式
ps -eo pid,ppid,user,%cpu,%mem,cmd --sort=-%cpu

4.2 top — 实时进程监控

top

# 常用快捷键：
# M — 按内存使用排序
# P — 按 CPU 使用排序
# k — 杀死进程（输入 PID）
# r — 调整进程优先级
# 1 — 显示每个 CPU 核心的使用情况
# c — 显示完整命令行
# q — 退出
# f — 选择显示字段
# H — 显示线程

4.3 kill / killall — 终止进程

# 发送 SIGTERM（默认，优雅终止）
kill 1234

# 强制杀死进程
kill -9 1234

# 按名称杀死进程
killall nginx

# 发送指定信号
kill -HUP 1234 # 重新加载配置
kill -USR1 1234 # 用户自定义信号1

# 列出所有信号
kill -l

# 杀死某个用户的所有进程
pkill -u username

# 按模式匹配杀死
pkill -f "python app.py"

4.4 nice / renice — 调整优先级

# 以低优先级运行（nice 值 -20 到 19，值越大优先级越低）
nice -n 10 ./heavy_task.sh

# 以高优先级运行（需要 root）
sudo nice -n -10 ./important_task.sh

# 修改运行中进程的优先级
renice -n 5 -p 1234

# 修改用户所有进程的优先级
renice -n 10 -u username

4.5 后台任务管理

# 后台运行命令
./long_task.sh &

# nohup 使进程在终端关闭后继续运行
nohup ./server.sh &

# nohup 输出重定向
nohup ./server.sh > output.log 2>&1 &

# 查看后台任务
jobs

# 将后台任务切换到前台
fg %1

# 将当前任务放到后台（先 Ctrl+Z 暂停）
bg %1

# 断开后台任务与终端的关联
disown %1

# 查看某个端口被哪个进程占用
lsof -i :8080
ss -tlnp | grep 8080

五、系统信息

5.1 系统基础信息

# 显示所有系统信息
uname -a

# 显示内核版本
uname -r

# 显示主机名
hostname

# 设置主机名
sudo hostnamectl set-hostname myserver

# 系统运行时间和负载
uptime

5.2 内存信息

# 人类可读格式显示内存
free -h

# 以 MB 为单位显示
free -m

# 持续监控（每 2 秒刷新）
free -h -s 2

5.3 磁盘信息

# 显示磁盘使用情况（人类可读）
df -h

# 显示文件系统类型
df -hT

# 显示 inode 使用情况
df -ih

# 查看目录大小
du -sh /var/log

# 查看当前目录各子目录大小
du -sh ./*

# 限制显示深度
du -h --max-depth=1 /home

# 按大小排序
du -sh ./* | sort -rh | head -10

# 查看块设备信息
lsblk

# 显示文件系统信息
lsblk -f

# 查看所有磁盘分区
sudo fdisk -l

# 挂载文件系统
sudo mount /dev/sdb1 /mnt/usb

# 卸载
sudo umount /mnt/usb

# 挂载 NFS
sudo mount -t nfs server:/share /mnt/nfs

5.4 其他系统信息

# CPU 信息
lscpu

# 内核日志（硬件相关）
dmesg | tail -50

# 过滤特定设备
dmesg | grep -i usb

# 查看系统发行版
cat /etc/os-release

# 查看主机名
cat /etc/hostname

六、网络命令

6.1 ip — 网络配置（推荐）

# 查看 IP 地址
ip addr show
ip a

# 查看指定网卡
ip addr show eth0

# 添加 IP 地址
sudo ip addr add 192.168.1.100/24 dev eth0

# 删除 IP 地址
sudo ip addr del 192.168.1.100/24 dev eth0

# 查看链路状态
ip link show

# 启用/禁用网卡
sudo ip link set eth0 up
sudo ip link set eth0 down

# 查看路由表
ip route show

# 添加默认网关
sudo ip route add default via 192.168.1.1

# 添加静态路由
sudo ip route add 10.0.0.0/8 via 192.168.1.1

6.2 ifconfig — 传统网络配置

# 查看所有网卡
ifconfig

# 查看指定网卡
ifconfig eth0

# 临时设置 IP
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0 up

6.3 ss / netstat — 网络连接状态

# 查看 TCP 监听端口
ss -tuln

# 查看所有 TCP/UDP 连接及进程
ss -tunp

# 查看指定端口
ss -tuln | grep :80

# netstat（较旧但仍常用）
netstat -tuln

# 查看所有连接及进程
netstat -tulnp

# 查看路由表
netstat -r

6.4 ping / traceroute / dig

# ping 指定次数
ping -c 4 google.com

# 指定间隔
ping -c 10 -i 0.5 192.168.1.1

# 路由追踪
traceroute google.com

# DNS 查询
dig example.com

# 精简输出
dig +short example.com

# 查询 MX 记录
dig MX example.com

# 查询指定 DNS 服务器
dig @8.8.8.8 example.com

# 反向 DNS 查询
dig -x 8.8.8.8

6.5 curl / wget — HTTP 工具

# GET 请求
curl https://api.example.com/data

# 下载文件
curl -O https://example.com/file.zip

# 指定保存文件名
curl -o output.html https://example.com

# POST 请求
curl -X POST -H "Content-Type: application/json" \
 -d '{"name":"test","value":123}' \
 https://api.example.com/resource

# 添加自定义请求头
curl -H "Authorization: Bearer token123" https://api.example.com

# 显示响应头
curl -I https://example.com

# 跟随重定向
curl -L https://short.url/abc

# 断点续传下载
wget -c https://example.com/large_file.iso

# 递归下载网站
wget -r -np -k https://example.com/docs/

# 限速下载
wget --limit-rate=1m https://example.com/file.zip

6.6 scp / rsync / ssh — 远程操作

# SSH 连接远程服务器
ssh user@192.168.1.100

# 指定端口
ssh -p 2222 user@server.com

# 使用密钥文件
ssh -i ~/.ssh/mykey user@server.com

# 远程执行命令
ssh user@server.com 'df -h && free -h'

# SCP 复制文件到远程
scp file.txt user@server:/home/user/

# 从远程复制文件
scp user@server:/var/log/app.log ./

# 递归复制目录
scp -r ./project user@server:/home/user/

# rsync 同步（增量传输，高效）
rsync -avz ./local_dir/ user@server:/remote_dir/

# 排除文件
rsync -avz --exclude='*.log' ./src/ user@server:/dest/

# 只同步删除的文件
rsync -avz --delete ./src/ user@server:/dest/

# 模拟运行（不实际传输）
rsync -avzn ./src/ user@server:/dest/

6.7 nc — 网络调试工具

# 测试端口是否开放
nc -zv 192.168.1.100 22

# 测试多个端口
nc -zv 192.168.1.100 80 443 8080

# 扫描端口范围
nc -zv 192.168.1.100 1-1000

# 简单聊天服务（监听端 9999）
nc -l 9999

# 简单文件传输
# 接收端：
nc -l 9999 > received_file
# 发送端：
nc server_ip 9999 < file_to_send

七、归档与压缩

7.1 tar — 打包与压缩

# 创建 gzip 压缩包
tar -czvf archive.tar.gz /path/to/dir/

# 解压 gzip 压缩包
tar -xzvf archive.tar.gz

# 解压到指定目录
tar -xzvf archive.tar.gz -C /target/dir/

# 创建 bzip2 压缩包（压缩率更高）
tar -cjvf archive.tar.bz2 /path/to/dir/

# 解压 bzip2
tar -xjvf archive.tar.bz2

# 创建 xz 压缩包（压缩率最高）
tar -cJvf archive.tar.xz /path/to/dir/

# 解压 xz
tar -xJvf archive.tar.xz

# 查看压缩包内容（不解压）
tar -tzvf archive.tar.gz

# 排除文件
tar -czvf backup.tar.gz --exclude='*.log' --exclude='.git' /project/

# 排除文件列表
tar -czvf backup.tar.gz --exclude-from=exclude.txt /project/

# 仅打包不压缩
tar -cvf archive.tar /path/to/dir/

7.2 gzip / gunzip

# 压缩文件
gzip file.txt # 生成 file.txt.gz，原文件删除

# 保留原文件
gzip -k file.txt

# 解压
gunzip file.txt.gz

# 指定压缩级别（1-9，9 最高）
gzip -9 large_file.txt

# 查看压缩文件内容
zcat file.txt.gz

7.3 zip / unzip

# 压缩文件
zip archive.zip file1.txt file2.txt

# 递归压缩目录
zip -r archive.zip /path/to/dir/

# 加密压缩
zip -e secure.zip secret.txt

# 解压
unzip archive.zip

# 解压到指定目录
unzip archive.zip -d /target/dir/

# 查看压缩包内容
unzip -l archive.zip

7.4 bzip2 / xz

# bzip2 压缩/解压
bzip2 file.txt
bunzip2 file.txt.bz2

# xz 压缩/解压
xz file.txt
unxz file.txt.xz

# 查看 xz 文件内容
xzcat file.txt.xz

八、服务管理 systemctl

8.1 服务基本操作

# 启动服务
sudo systemctl start nginx

# 停止服务
sudo systemctl stop nginx

# 重启服务
sudo systemctl restart nginx

# 重新加载配置（不中断服务）
sudo systemctl reload nginx

# 查看服务状态
systemctl status nginx

# 设置开机自启
sudo systemctl enable nginx

# 取消开机自启
sudo systemctl disable nginx

# 检查是否活跃
systemctl is-active nginx

# 检查是否开机自启
systemctl is-enabled nginx

# 列出所有已启动的服务
systemctl list-units --type=service --state=running

# 列出所有服务（包括未启动的）
systemctl list-units --type=service --all

# 重新加载 systemd 配置（修改 unit 文件后执行）
sudo systemctl daemon-reload

8.2 电源管理

# 关机
sudo systemctl poweroff
sudo shutdown -h now

# 重启
sudo systemctl reboot
sudo reboot

# 休眠（挂起到磁盘）
sudo systemctl hibernate

# 挂起（挂起到内存）
sudo systemctl suspend

# 定时关机
sudo shutdown -h +30 # 30 分钟后关机

# 取消定时关机
sudo shutdown -c

8.3 运行级别（target）

# 查看当前默认运行级别
systemctl get-default

# 设置默认运行级别
sudo systemctl set-default multi-user.target # 命令行模式
sudo systemctl set-default graphical.target # 图形界面模式

# 切换运行级别
sudo systemctl isolate multi-user.target

# 运行级别对照：
# poweroff.target → 关机
# rescue.target → 救援模式
# multi-user.target → 多用户命令行
# graphical.target → 图形界面
# reboot.target → 重启

8.4 journalctl — 日志查看

# 查看指定服务日志
journalctl -u nginx

# 实时跟踪日志
journalctl -u nginx -f

# 查看指定时间之后的日志
journalctl --since "2026-06-25 10:00:00"

# 查看今天的日志
journalctl --since today

# 按优先级过滤（0=emergency 到 7=debug）
journalctl -p err # 只看错误及以上
journalctl -p warning # 警告及以上

# 查看磁盘占用
journalctl --disk-usage

# 清理旧日志（保留最近 7 天）
sudo journalctl --vacuum-time=7d

# 清理日志（保留最多 500MB）
sudo journalctl --vacuum-size=500M

# 查看内核日志
journalctl -k

# 查看上次启动的日志
journalctl -b -1

九、包管理

9.1 apt — Debian/Ubuntu 系列

# 更新软件源列表
sudo apt update

# 升级所有已安装的包
sudo apt upgrade

# 更新并升级（处理依赖关系变化）
sudo apt full-upgrade

# 安装软件包
sudo apt install nginx

# 安装多个包
sudo apt install vim git curl wget

# 安装指定版本
sudo apt install nginx=1.24.0-1

# 卸载软件包（保留配置文件）
sudo apt remove nginx

# 卸载并删除配置文件
sudo apt purge nginx

# 搜索软件包
apt search nginx

# 查看包的详细信息
apt show nginx

# 列出已安装的包
apt list --installed

# 清理不需要的依赖包
sudo apt autoremove

# 清理下载的安装包缓存
sudo apt clean

# 修复损坏的依赖关系
sudo apt --fix-broken install

# 添加 PPA 源
sudo add-apt-repository ppa:deadsnakes/ppa

9.2 yum / dnf — RHEL/CentOS/Fedora 系列

# yum（CentOS 7 及以下）
sudo yum update
sudo yum install nginx
sudo yum remove nginx
sudo yum search nginx
sudo yum info nginx
sudo yum list installed
sudo yum clean all

# dnf（CentOS 8+ / Fedora）
sudo dnf update
sudo dnf install nginx
sudo dnf remove nginx
sudo dnf search nginx
sudo dnf autoremove

# 安装 EPEL 源
sudo yum install epel-release

9.3 pacman — Arch Linux

# 同步数据库并更新系统
sudo pacman -Syu

# 安装软件包
sudo pacman -S nginx

# 卸载软件包
sudo pacman -R nginx

# 卸载并移除未被其他包依赖的依赖
sudo pacman -Rs nginx

# 搜索
pacman -Ss nginx

# 查看已安装的包
pacman -Q

# 查看某个文件属于哪个包
pacman -Qo /usr/bin/nginx

# 清理包缓存
sudo pacman -Sc

十、磁盘与 I/O

10.1 dd — 底层数据复制

# 创建指定大小的空文件（测试用）
dd if=/dev/zero of=testfile bs=1M count=100

# 备份磁盘到镜像文件
sudo dd if=/dev/sda of=/backup/disk.img bs=4M status=progress

# 从镜像恢复磁盘
sudo dd if=/backup/disk.img of=/dev/sda bs=4M status=progress

# 创建可启动 USB
sudo dd if=ubuntu.iso of=/dev/sdb bs=4M status=progress oflag=sync

# 安全擦除磁盘
sudo dd if=/dev/urandom of=/dev/sdb bs=1M status=progress

10.2 fdisk — 磁盘分区

# 查看所有磁盘分区
sudo fdisk -l

# 对磁盘进行分区（交互式）
sudo fdisk /dev/sdb

# fdisk 交互命令：
# n — 新建分区
# d — 删除分区
# p — 打印分区表
# t — 更改分区类型
# w — 写入并退出
# q — 不保存退出

10.3 mkfs — 创建文件系统

# 创建 ext4 文件系统
sudo mkfs.ext4 /dev/sdb1

# 创建 xfs 文件系统
sudo mkfs.xfs /dev/sdb1

# 创建 vfat（FAT32）文件系统
sudo mkfs.vfat /dev/sdb1

# 创建 NTFS 文件系统
sudo mkfs.ntfs /dev/sdb1

# 指定标签
sudo mkfs.ext4 -L "DataDisk" /dev/sdb1

10.4 fsck — 文件系统检查

# 检查文件系统（需先卸载）
sudo fsck /dev/sdb1

# 自动修复
sudo fsck -y /dev/sdb1

# 只检查不修复
sudo fsck -n /dev/sdb1

10.5 blkid — 查看块设备信息

# 查看所有块设备的 UUID 和文件系统类型
sudo blkid

# 查看指定设备
sudo blkid /dev/sdb1

十一、性能监控

11.1 vmstat — 虚拟内存统计

# 每 2 秒采样一次，共采样 5 次
vmstat 2 5

# 查看磁盘统计
vmstat -d

# 查看内存统计（MB 为单位）
vmstat -S M

# 输出字段说明：
# procs: r=运行队列 b=阻塞进程
# memory: swpd=虚拟内存 free=空闲内存 buff=缓冲 cache=缓存
# swap: si=换入 so=换出
# io: bi=读入 bo=写出
# system: in=中断 cs=上下文切换
# cpu: us=用户 sy=系统 id=空闲 wa=等待

11.2 iostat — I/O 统计

# 显示 CPU 和磁盘 I/O 统计
iostat

# 扩展信息（含等待时间等）
iostat -x

# 每 2 秒刷新一次
iostat -x 2

# 只看磁盘
iostat -d -x

# 以 MB 为单位
iostat -m

11.3 sar — 系统活动报告

# 查看内存使用情况
sar -r

# 查看网络统计
sar -n DEV

# 查看磁盘 I/O
sar -d

# 查看 CPU 使用率（每 2 秒，共 10 次）
sar -u 2 10

# 查看历史数据
sar -r -f /var/log/sysstat/sa25 # 25 号的记录

11.4 strace — 系统调用追踪

# 追踪命令的系统调用
strace ls -l

# 追踪运行中的进程
sudo strace -p 1234

# 过滤特定系统调用
strace -e open,read,write cat /etc/hostname

# 统计系统调用次数和耗时
strace -c ls -l

# 追踪子进程
strace -f ./my_program

# 写入文件
strace -o trace.log ./my_program

11.5 lsof — 列出打开的文件

# 列出所有打开的文件
sudo lsof

# 查看指定用户打开的文件
lsof -u username

# 查看指定进程打开的文件
lsof -p 1234

# 查看某个端口被谁占用
lsof -i :80

# 查看某个 IP 的连接
lsof -i @192.168.1.100

# 查看某个文件被谁打开
lsof /var/log/syslog

# 查看 TCP 连接
lsof -i tcp

# 查看 ESTABLISHED 连接
lsof -i -sTCP:ESTABLISHED

十二、Shell 脚本基础

12.1 变量、字符串和数组

#!/bin/bash

# 变量定义（等号两边不能有空格）
name="Linux"
version=6
readonly PI=3.14 # 只读变量

# 使用变量
echo "System: $name, Version: $version"
echo "Path: ${HOME}/projects"

# 字符串操作
str="Hello World"
echo ${#str} # 字符串长度：11
echo ${str:0:5} # 截取前 5 个字符：Hello
echo ${str/World/Linux} # 替换：Hello Linux

# 字符串拼接
first="Hello"
second="World"
greeting="$first $second"
echo $greeting

# 数组
arr=("apple" "banana" "cherry" "date")
echo ${arr[0]} # 第一个元素：apple
echo ${arr[@]} # 所有元素
echo ${#arr[@]} # 数组长度：4

# 添加元素
arr+=("elderberry")

# 关联数组（Bash 4+）
declare -A user
user[name]="Alice"
user[age]=30
echo ${user[name]}

12.2 条件判断

#!/bin/bash

# if/elif/else
score=85

if [ $score -ge 90 ]; then
 echo "优秀"
elif [ $score -ge 80 ]; then
 echo "良好"
elif [ $score -ge 60 ]; then
 echo "及格"
else
 echo "不及格"
fi

# 文件测试
file="/etc/passwd"

if [ -f "$file" ]; then echo "是普通文件"; fi
if [ -d "/tmp" ]; then echo "是目录"; fi
if [ -e "$file" ]; then echo "文件存在"; fi
if [ -r "$file" ]; then echo "可读"; fi
if [ -w "$file" ]; then echo "可写"; fi
if [ -x "/bin/ls" ]; then echo "可执行"; fi
if [ -s "$file" ]; then echo "文件非空"; fi
if [ -L "/dev/stdin" ]; then echo "是软链接"; fi

# 字符串测试
str=""
if [ -z "$str" ]; then echo "字符串为空"; fi
if [ -n "$str" ]; then echo "字符串非空"; fi
if [ "$a" = "$b" ]; then echo "相等"; fi
if [ "$a" != "$b" ]; then echo "不等"; fi

# 数值比较
a=10; b=20
if [ $a -eq $b ]; then echo "相等"; fi
if [ $a -ne $b ]; then echo "不等"; fi
if [ $a -gt $b ]; then echo "大于"; fi
if [ $a -lt $b ]; then echo "小于"; fi
if [ $a -ge $b ]; then echo "大于等于"; fi
if [ $a -le $b ]; then echo "小于等于"; fi

# 逻辑组合
if [ $a -gt 5 ] && [ $a -lt 15 ]; then
 echo "a 在 5 和 15 之间"
fi

if [ $a -lt 5 ] || [ $a -gt 15 ]; then
 echo "a 不在 5 和 15 之间"
fi

# 双括号（支持算术运算）
if (( a > 5 && a < 15 )); then
 echo "条件成立"
fi

12.3 循环

#!/bin/bash

# for 循环 — 列表
for fruit in apple banana cherry; do
 echo "水果: $fruit"
done

# for 循环 — 范围
for i in {1..10}; do
 echo "数字: $i"
done

# for 循环 — C 风格
for ((i=0; i<10; i++)); do
 echo "计数: $i"
done

# for 循环 — 遍历文件
for file in /var/log/*.log; do
 echo "日志文件: $file"
done

# for 循环 — 命令替换
for user in $(cat /etc/passwd | cut -d: -f1); do
 echo "用户: $user"
done

# while 循环
count=1
while [ $count -le 5 ]; do
 echo "第 $count 次"
 ((count++))
done

# while 读取文件
while IFS= read -r line; do
 echo "行内容: $line"
done < /etc/hostname

# until 循环（条件为假时执行）
num=1
until [ $num -gt 5 ]; do
 echo "数字: $num"
 ((num++))
done

# 无限循环
while true; do
 echo "按 Ctrl+C 退出"
 sleep 1
done

# break 和 continue
for i in {1..10}; do
 if [ $i -eq 3 ]; then continue; fi
 if [ $i -eq 8 ]; then break; fi
 echo $i
done

12.4 函数

#!/bin/bash

# 定义函数
greet() {
 echo "Hello, $1!"
}

# 调用函数
greet "Alice"

# 带返回值的函数
add() {
 local result=$(( $1 + $2 ))
 echo $result
}

# 获取返回值
sum=$(add 3 5)
echo "3 + 5 = $sum"

# 多个返回值（通过全局变量或输出）
get_info() {
 local name=$1
 local age=$2
 echo "姓名: $name"
 echo "年龄: $age"
}

# 读取多行输出
info=$(get_info "Bob" 25)
echo "$info"

# 局部变量
myfunc() {
 local local_var="我在函数内部"
 global_var="我在函数外部也能访问"
 echo $local_var
}

myfunc
echo $global_var # 可以访问
# echo $local_var # 不可以访问

12.5 重定向

# 标准输出重定向（覆盖）
echo "Hello" > output.txt

# 标准输出重定向（追加）
echo "World" >> output.txt

# 标准错误重定向
ls /nonexist 2> error.log

# 标准错误追加
command 2>> error.log

# 标准输出和标准错误都重定向
command > output.txt 2>&1

# 简写形式（Bash 4+）
command &> all_output.txt

# 标准输出和标准错误分别重定向
command > stdout.log 2> stderr.log

# 丢弃输出
command > /dev/null 2>&1

# 标准输入重定向
while read line; do
 echo "$line"
done < input.txt

# Here Document
cat << EOF > config.txt
server_name=example.com
port=8080
debug=true
EOF

# Here String
grep "pattern" <<< "this is a pattern test"

12.6 管道

# 基本管道
ls -l | grep ".txt"

# 多级管道
cat /var/log/syslog | grep "error" | awk '{print $1, $2, $3}' | sort | uniq -c | sort -rn | head -10

# 统计当前登录用户数
who | wc -l

# 查找占用最多磁盘空间的前 10 个目录
du -sh /var/* 2>/dev/null | sort -rh | head -10

# 实时监控日志中的错误
tail -f /var/log/syslog | grep --line-buffered "error"

# 进程替换（比较命令输出的差异）
diff <(ls /dir1) <(ls /dir2)

12.7 特殊变量

#!/bin/bash

# $0 — 脚本名称
echo "脚本名: $0"

# $1, $2, $3... — 位置参数
echo "第一个参数: $1"
echo "第二个参数: $2"

# $# — 参数个数
echo "参数总数: $#"

# $@ — 所有参数（各自独立）
for arg in "$@"; do
 echo "参数: $arg"
done

# $* — 所有参数（作为整体字符串）
echo "所有参数: $*"

# $? — 上一个命令的退出状态
ls /tmp
echo "退出状态: $?" # 0 表示成功

ls /nonexist
echo "退出状态: $?" # 非 0 表示失败

# $$ — 当前脚本的进程 ID
echo "PID: $$"

# $! — 最近后台进程的 PID
sleep 100 &
echo "后台进程 PID: $!"

# $- — 当前 Shell 的选项标志
echo "Shell 选项: $-"

12.8 case 语句

#!/bin/bash

fruit="apple"

case $fruit in
 "apple")
 echo "苹果"
 ;;
 "banana"|"plantain")
 echo "香蕉"
 ;;
 "cherry")
 echo "樱桃"
 ;;
 *)
 echo "未知水果"
 ;;
esac

# case 用于脚本菜单
echo "请选择操作："
echo "1) 查看磁盘"
echo "2) 查看内存"
echo "3) 查看进程"
read -p "输入选项: " choice

case $choice in
 1) df -h ;;
 2) free -h ;;
 3) ps aux | head -20 ;;
 *) echo "无效选项" ;;
esac

# 模式匹配
read -p "输入文件名: " filename
case $filename in
 *.tar.gz) echo "gzip 压缩包"; tar -tzvf "$filename" ;;
 *.tar.bz2) echo "bzip2 压缩包"; tar -tjvf "$filename" ;;
 *.tar.xz) echo "xz 压缩包"; tar -tJvf "$filename" ;;
 *.zip) echo "zip 压缩包"; unzip -l "$filename" ;;
 *) echo "未知文件类型" ;;
esac

12.9 实用备份脚本示例

#!/bin/bash
# ============================================
# 自动备份脚本
# 用法: ./backup.sh [源目录] [备份目录]
# ============================================

set -euo pipefail

# ---- 配置区 ----
SOURCE_DIR="${1:-/var/www/html}"
BACKUP_DIR="${2:-/backup}"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="backup_${DATE}.tar.gz"
LOG_FILE="/var/log/backup.log"
RETAIN_DAYS=30
EXCLUDE_LIST=("*.log" "*.tmp" ".git" "node_modules" "__pycache__")

# ---- 函数定义 ----
log() {
 local level=$1
 shift
 echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $*" | tee -a "$LOG_FILE"
}

check_dependencies() {
 local deps=("tar" "gzip")
 for dep in "${deps[@]}"; do
 if ! command -v "$dep" &> /dev/null; then
 log "ERROR" "缺少依赖: $dep"
 exit 1
 fi
 done
}

cleanup_old_backups() {
 log "INFO" "清理 ${RETAIN_DAYS} 天前的旧备份..."
 local count=0
 while IFS= read -r -d '' old_file; do
 rm -f "$old_file"
 ((count++))
 done < <(find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +$RETAIN_DAYS -print0)
 log "INFO" "已清理 $count 个旧备份文件"
}

do_backup() {
 local src=$1
 local dest=$2
 local name=$3

 if [ ! -d "$src" ]; then
 log "ERROR" "源目录不存在: $src"
 exit 1
 fi

 mkdir -p "$dest"

 # 构建排除参数
 local exclude_args=""
 for pattern in "${EXCLUDE_LIST[@]}"; do
 exclude_args="$exclude_args --exclude=$pattern"
 done

 log "INFO" "开始备份: $src → $dest/$name"
 local start_time=$(date +%s)

 eval tar -czf "$dest/$name" $exclude_args "$src" 2>> "$LOG_FILE"
 local exit_code=$?

 local end_time=$(date +%s)
 local duration=$((end_time - start_time))
 local size=$(du -sh "$dest/$name" | cut -f1)

 if [ $exit_code -eq 0 ]; then
 log "INFO" "备份成功! 文件: $name, 大小: $size, 耗时: ${duration}秒"
 else
 log "ERROR" "备份失败! 退出码: $exit_code"
 exit 1
 fi
}

verify_backup() {
 local file=$1
 if tar -tzf "$file" > /dev/null 2>&1; then
 log "INFO" "备份完整性验证通过"
 return 0
 else
 log "ERROR" "备份文件损坏: $file"
 return 1
 fi
}

# ---- 主逻辑 ----
main() {
 log "INFO" "========== 备份任务开始 =========="

 check_dependencies
 do_backup "$SOURCE_DIR" "$BACKUP_DIR" "$BACKUP_NAME"
 verify_backup "$BACKUP_DIR/$BACKUP_NAME"
 cleanup_old_backups

 log "INFO" "========== 备份任务完成 =========="
}

main "$@"

速查表

场景	常用命令
查找文件	`find / -name "*.conf"`
搜索文本	`grep -rn "keyword" /path/`
查看端口	`ss -tuln \| grep :80`
查看进程	`ps aux \| grep name`
查看磁盘	`df -h`
查看内存	`free -h`
压缩目录	`tar -czvf archive.tar.gz dir/`
解压文件	`tar -xzvf archive.tar.gz`
远程复制	`scp -r dir user@host:/path/`
同步文件	`rsync -avz src/ user@host:/dest/`
查看日志	`tail -f /var/log/syslog`
服务管理	`systemctl status service_name`

以上就是 Linux 常用终端命令的完整指南。建议收藏本文，在日常工作中遇到问题时随时查阅。最好的学习方式是动手实践——在测试环境中逐个尝试这些命令，加深理解和记忆。

macOS 终端常用命令完全指南

Thu, 25 Jun 2026 12:00:00 +0000

macOS 自带的终端（Terminal）是一个功能强大的工具，掌握常用的终端命令能极大提升工作效率。本文整理了 macOS 环境下最常用的终端命令，涵盖文件管理、系统信息、网络调试、磁盘操作、Homebrew 包管理等方方面面，适合日常开发和运维参考。

一、文件管理

1.1 ls — 列出目录内容

ls 是最基础也最常用的命令之一。

# 基本列出当前目录
ls

# 列出详细信息（包括隐藏文件）
ls -la

# ls -la 各列含义：
# -rw-r--r-- 1 user staff 1024 Jun 25 10:00 file.txt
# │├─┤├─┤├─┤ │ │ │ │ │ │
# 权限 链接 用户 组 大小 修改时间 文件名
#
# 权限说明：
# 第1位: 文件类型 (- 普通文件, d 目录, l 符号链接)
# 2-4位: 所有者权限 (r 读, w 写, x 执行)
# 5-7位: 同组权限
# 8-10位: 其他用户权限

# 按大小排序
ls -lS

# 按时间排序（最新的在前）
ls -lt

# 人类可读的文件大小
ls -lh

# 只列出目录
ls -d */

# 递归列出子目录
ls -R

1.2 cp — 复制文件

# 复制文件
cp file.txt backup.txt

# 复制目录（递归）
cp -r source_dir/ dest_dir/

# 保留原始属性（权限、时间等）
cp -p file.txt backup.txt

# 覆盖前确认
cp -i file.txt backup.txt

# 复制时显示被复制的文件名（verbose，Linux/macOS 通用）
cp -v file.txt backup.txt

1.3 mv — 移动/重命名

# 重命名文件
mv old_name.txt new_name.txt

# 移动文件到目录
mv file.txt ~/Documents/

# 覆盖前确认
mv -i file.txt ~/Documents/

# 批量移动
mv *.jpg ~/Pictures/

1.4 rm — 删除文件

# 删除文件
rm file.txt

# 删除前确认
rm -i file.txt

# 递归删除目录
rm -r old_dir/

# 强制递归删除（慎用！）
rm -rf old_dir/

# macOS 特有：将文件移到废纸篓（需安装 trash 命令）
# brew install trash
trash file.txt

⚠️ 警告：rm -rf / 或 rm -rf ~ 会删除系统/用户所有文件，务必小心！

1.5 find — 查找文件

# 按名称查找
find . -name "*.txt"

# 不区分大小写查找
find . -iname "*.PDF"

# 按类型查找（f 文件, d 目录, l 符号链接）
find . -type f -name "*.log"
find . -type d -name "node_modules"

# 按大小查找（大于 100MB）
find . -type f -size +100M

# 按修改时间查找（7天内修改过的文件）
find . -type f -mtime -7

# 查找并执行操作（删除所有 .tmp 文件）
find . -name "*.tmp" -exec rm {} \;

# 查找并列出详细信息
find . -name "*.swift" -exec ls -lh {} \;

# 排除目录查找
find . -path "./node_modules" -prune -o -name "*.js" -print

# 按权限查找（可执行文件）
find . -type f -perm +111

1.6 touch — 创建空文件/更新时间戳

# 创建空文件
touch newfile.txt

# 批量创建文件
touch file{1..10}.txt

# 指定时间戳
touch -t 202606251200 file.txt

1.7 cat / head / tail — 查看文件内容

# 查看整个文件
cat file.txt

# 带行号显示
cat -n file.txt

# 查看文件前 20 行
head -n 20 file.txt

# 查看文件末尾 50 行
tail -n 50 file.txt

# 实时查看文件追加内容（监控日志）
tail -f /var/log/system.log

# 实时查看并带行号
tail -f -n 100 app.log

1.8 open — macOS 专属打开命令

open 是 macOS 特有的命令，相当于在 Finder 中双击。

# 用默认应用打开文件
open file.pdf

# 用指定应用打开
open -a "Visual Studio Code" file.txt

# 用 TextEdit 打开
open -a TextEdit file.txt

# 打开当前目录（在 Finder 中）
open .

# 打开 URL
open https://www.apple.com

# 打开应用程序
open -a Safari

# 以新窗口打开 Finder
open -n ~/Documents/

# 等待应用关闭再返回
open -W -a TextEdit file.txt

1.9 du / df — 磁盘使用情况

# 查看当前目录大小
du -sh .

# 查看各子目录大小
du -sh *

# 排序查看（从大到小）
du -sh * | sort -rh

# 查看磁盘总览
df -h

# 查看指定文件系统的使用情况
df -h /

二、系统信息

2.1 system_profiler — 系统详细信息

# 查看硬件概览
system_profiler SPHardwareDataType
# 输出示例：
# Model Name: MacBook Pro
# Chip: Apple M2 Pro
# Total Number of Cores: 12
# Memory: 32 GB

# 查看 USB 设备
system_profiler SPUSBDataType

# 查看存储设备
system_profiler SPStorageDataType

# 查看显示器信息
system_profiler SPDisplaysDataType

# 查看网络信息
system_profiler SPNetworkDataType

# 查看全部信息（输出很长）
system_profiler

# 以 JSON 格式输出
system_profiler SPHardwareDataType -json

2.2 sw_vers — 系统版本

# 查看 macOS 版本
sw_vers
# 输出示例：
# ProductName: macOS
# ProductVersion: 15.0
# BuildVersion: 24A335

# 只输出版本号
sw_vers -productVersion

# 只输出构建号
sw_vers -buildVersion

2.3 其他系统信息命令

# 主机名
hostname

# 系统运行时间
uptime
# 输出: 14:30 up 5 days, 3:22, 2 users, load averages: 1.87 2.03 1.95

# 内核信息
uname -a
# 输出: Darwin MacBook-Pro.local 24.0.0 Darwin Kernel Version 24.0.0 ...

# 只看内核名
uname -s

# CPU 架构
uname -m
# Apple Silicon 输出: arm64
# Intel 输出: x86_64

# 查看当前用户
whoami

# 查看登录用户
who

三、进程管理

3.1 ps — 查看进程

# 查看所有进程（详细格式）
ps aux

# 查看当前用户的进程
ps -x

# 按 CPU 使用率排序（macOS 的 BSD ps 用 -r，无 GNU 的 --sort 选项）
ps aux -r | head -20

# 按内存使用率排序（BSD ps 用 -m）
ps aux -m | head -20

# 查找特定进程
ps aux | grep -i chrome

3.2 top — 实时进程监控

# 启动 top
top

# 按内存排序显示
top -o MEM

# 按 CPU 排序
top -o CPU

# 只显示指定用户的进程
top -user $(whoami)

# 显示指定数量的进程
top -l 1 -n 10

# macOS top 常用交互快捷键：
# P — 按 CPU 排序
# M — 按内存排序
# q — 退出

3.3 kill / killall — 终止进程

# 根据 PID 终止进程
kill 12345

# 强制终止
kill -9 12345

# 根据进程名终止
killall Safari

# 不区分大小写匹配进程名（BSD killall 用大写 -I）
killall -I "google chrome"

# 把参数作为正则表达式匹配进程名
killall -m "node"

3.4 lsof — 查看打开的文件/端口

# 查看某个进程打开的所有文件
lsof -p 12345

# 查看某个文件被哪些进程使用
lsof /path/to/file

# 查看某个端口被哪个进程占用（最常用！）
lsof -i :8080
# 输出示例：
# COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
# node 1234 user 22u IPv6 ... 0t0 TCP *:8080 (LISTEN)

# 查看所有网络连接
lsof -i

# 查看 TCP 连接
lsof -i tcp

# 查看 UDP 连接
lsof -i udp

# 查看指定用户的打开文件
lsof -u $(whoami)

# 查看某个进程的网络连接
lsof -i -p 12345

四、网络命令

4.1 基础网络工具

# 测试网络连通性
ping -c 5 google.com

# 路由追踪
traceroute google.com

# 查看网络连接状态
netstat -an

# 查看监听中的端口
netstat -an | grep LISTEN

# macOS 替代方案（更推荐）
lsof -i -P | grep LISTEN

4.2 networksetup — 网络配置

# 列出所有网络服务
networksetup -listallnetworkservices
# 输出示例：
# An asterisk (*) denotes that a network service is disabled.
# Wi-Fi
# Bluetooth Pan
# Thunderbolt Bridge

# 查看 Wi-Fi 详细信息
networksetup -getinfo Wi-Fi
# 输出示例：
# DHCP Configuration
# IP Address: 192.168.1.100
# Subnet Mask: 255.255.255.0
# Router: 192.168.1.1

# 查看当前 DNS 服务器
networksetup -getdnsservers Wi-Fi

# 设置 DNS 服务器
sudo networksetup -setdnsservers Wi-Fi 8.8.8.8 8.8.4.4

# 还原为 DHCP 自动分配的 DNS
sudo networksetup -setdnsservers Wi-Fi "Empty"

# 查看 Wi-Fi 名称
networksetup -getairportnetwork en0

# 连接指定 Wi-Fi
sudo networksetup -setairportnetwork en0 "SSID" "password"

# 开关 Wi-Fi
sudo networksetup -setairportpower en0 off
sudo networksetup -setairportpower en0 on

# 设置代理
sudo networksetup -setwebproxy Wi-Fi 127.0.0.1 7890
sudo networksetup -setsocksfirewallproxy Wi-Fi 127.0.0.1 7891

# 关闭代理
sudo networksetup -setwebproxystate Wi-Fi off

4.3 DNS 查询

# nslookup 查询
nslookup apple.com

# dig 查询（更详细）
dig apple.com

# dig 简洁输出
dig +short apple.com

# 查询 MX 记录
dig MX apple.com

# 查询 NS 记录
dig NS apple.com

# 反向查询
dig -x 17.172.224.47

4.4 curl — HTTP 请求

# GET 请求
curl https://api.github.com/users/octocat

# 下载文件
curl -O https://example.com/file.zip

# 下载并指定文件名
curl -o output.html https://example.com

# POST 请求
curl -X POST -d '{"name":"test"}' \
 -H "Content-Type: application/json" \
 https://api.example.com/data

# 只看响应头
curl -I https://example.com

# 显示详细信息
curl -v https://example.com

# 跟随重定向
curl -L https://short.url/abc

# 带认证
curl -u username:password https://api.example.com

4.5 获取本机 IP

# 查看所有网络接口
ifconfig

# 获取 en0（通常是有线/无线）的 IP 地址
ipconfig getifaddr en0

# 获取公网 IP
curl -s ifconfig.me

# 获取公网 IP（备用）
curl -s ipinfo.io/ip

# 查看 MAC 地址
ifconfig en0 | grep ether

4.6 airport — Wi-Fi 信息（macOS 专属）

# airport 命令路径（较新系统可能需要完整路径）
/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport

# 创建便捷别名
alias airport='/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'

# 查看当前 Wi-Fi 信息
airport -I
# 输出示例：
# SSID: MyWiFi
# agrCtlRSSI: -45
# agrExtNoise: 0
# lastTxRate: 867
# maxRate: 867

# 扫描附近 Wi-Fi
airport -s

五、磁盘管理

5.1 diskutil — 磁盘工具

# 列出所有磁盘和分区
diskutil list
# 输出示例：
# /dev/disk0 (internal, physical):
# #: TYPE NAME SIZE IDENTIFIER
# 0: GUID_partition_scheme *1.0 TB disk0
# 1: EFI EFI 314.6 MB disk0s1
# 2: Apple_APFS Container disk1 999.7 GB disk0s2

# 查看磁盘详细信息
diskutil info disk0

# 查看指定分区信息
diskutil info disk0s2

# 卸载磁盘
diskutil unmountDisk /dev/disk2

# 卸载指定分区
diskutil unmount /dev/disk2s1

# 格式化磁盘为 APFS
diskutil eraseDisk APFS "MyDisk" /dev/disk2

# 格式化为 exFAT（兼容 Windows）
diskutil eraseDisk ExFAT "MyDisk" MBRFormat /dev/disk2

# 修复磁盘权限（旧版 macOS）
diskutil repairPermissions /

# 验证磁盘
diskutil verifyDisk disk0

# 修复磁盘
diskutil repairDisk disk0

# 安全擦除（3次覆写）
diskutil secureErase 3 /dev/disk2

# 创建加密分区
diskutil apfs encryptVolume disk0s2 -passphrase "YourPassword"

5.2 df / du — 磁盘空间

# 人类可读格式查看磁盘使用情况
df -h
# 输出示例：
# Filesystem Size Used Avail Capacity Mounted on
# /dev/disk1s1 932Gi 450Gi 450Gi 51% /

# 只看本地磁盘
df -Hl

# 查看某个目录大小
du -sh ~/Documents

# 查看各子目录大小并排序
du -sh ~/Documents/* | sort -rh | head -10

# 排除特定目录（macOS 的 BSD du 用 -I mask，无 GNU 的 --exclude）
du -sh -I node_modules ~/Projects

# 查看 inode 使用情况
df -i

六、Homebrew 完整教程

Homebrew 是 macOS 上最流行的包管理器，被称为"macOS 缺失的包管理器"。

6.1 安装 Homebrew

# 官方安装脚本
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 安装完成后，Apple Silicon Mac 需要添加 PATH
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc
source ~/.zshrc

# 验证安装
brew --version
brew --prefix

6.2 基本使用

# 搜索软件包
brew search wget
brew search python

# 安装软件包
brew install wget
brew install node
brew install python@3.12

# 查看软件包信息
brew info node

# 列出已安装的包
brew list

# 列出可升级的包
brew outdated

# 更新 Homebrew 自身
brew update

# 升级所有已安装的包
brew upgrade

# 升级指定包
brew upgrade node

# 清理旧版本
brew cleanup

# 卸载软件包
brew uninstall wget

# 卸载并删除配置
brew uninstall --force wget

6.3 Cask — 安装 GUI 应用

# 搜索应用
brew search --cask google-chrome

# 安装 GUI 应用
brew install --cask google-chrome
brew install --cask visual-studio-code
brew install --cask docker
brew install --cask iterm2
brew install --cask rectangle

# 列出已安装的 Cask 应用
brew list --cask

# 升级 Cask 应用
brew upgrade --cask google-chrome

# 卸载 Cask 应用
brew uninstall --cask google-chrome

# 常用 Cask 应用推荐
brew install --cask firefox # 浏览器
brew install --cask alfred # 效率工具
brew install --cask the-unarchiver # 解压工具
brew install --cask obsidian # 笔记
brew install --cask stats # 系统监控

6.4 Services — 管理后台服务

# 列出所有服务及状态
brew services list

# 启动服务（开机自启）
brew services start mysql

# 停止服务
brew services stop mysql

# 重启服务
brew services restart mysql

# 只运行一次（不设置开机自启）
brew services run mysql

# 示例：安装并启动 PostgreSQL
brew install postgresql@16
brew services start postgresql@16

# 示例：安装并启动 Redis
brew install redis
brew services start redis

七、macOS 专属命令

7.1 defaults — 系统偏好设置

# 显示隐藏文件
defaults write com.apple.finder AppleShowAllFiles -bool true
killall Finder

# 再次隐藏
defaults write com.apple.finder AppleShowAllFiles -bool false
killall Finder

# 显示 Finder 路径栏
defaults write com.apple.finder ShowPathbar -bool true

# 显示文件扩展名
defaults write NSGlobalDomain AppleShowAllExtensions -bool true

# 截图保存位置
defaults write com.apple.screencapture location ~/Screenshots

# 截图格式改为 jpg
defaults write com.apple.screencapture type jpg

# Dock 自动隐藏延迟
defaults write com.apple.dock autohide-delay -float 0

# Dock 动画时间
defaults write com.apple.dock autohide-time-modifier -float 0.5

# 读取某个设置值
defaults read com.apple.finder AppleShowAllFiles

# 删除某个设置
defaults delete com.apple.dock autohide-delay

# 重启 Finder 使设置生效
killall Finder

# 重启 Dock
killall Dock

7.2 pbcopy / pbpaste — 剪贴板操作

# 将文本复制到剪贴板
echo "Hello World" | pbcopy

# 将文件内容复制到剪贴板
cat file.txt | pbcopy

# 将命令输出复制到剪贴板
pwd | pbcopy

# 将剪贴板内容粘贴到文件
pbpaste > output.txt

# 将剪贴板内容追加到文件
pbpaste >> output.txt

# 复制 SSH 公钥到剪贴板
cat ~/.ssh/id_ed25519.pub | pbcopy

# 实用组合：复制当前路径
pwd | pbcopy

7.3 say — 文字转语音

# 朗读文本
say "Hello, welcome to macOS"

# 朗读中文
say "你好，欢迎使用 macOS"

# 列出可用语音
say -v ?

# 使用指定语音
say -v "Mei-Jia" "你好世界"

# 保存为音频文件
say -o output.aiff "Hello World"

# 调整语速
say -r 200 "Speaking fast"
say -r 100 "Speaking slowly"

7.4 screencapture — 截图

# 全屏截图
screencapture screenshot.png

# 区域截图（会触发交互选择）
screencapture -i screenshot.png

# 窗口截图（交互选择窗口）
screencapture -i -w screenshot.png

# 延迟截图（5秒后截图）
screencapture -T 5 screenshot.png

# 截图到剪贴板（不保存文件）
screencapture -c

# 区域截图到剪贴板
screencapture -ic

# 不含窗口阴影
screencapture -i -w -o screenshot.png

# PDF 格式截图
screencapture screenshot.pdf

7.5 mdfind / mdls / mdutil — Spotlight 命令行

# Spotlight 搜索文件
mdfind "filename:report"

# 按内容搜索
mdfind "budget report"

# 在指定目录搜索
mdfind -onlyin ~/Documents "invoice"

# 查看文件的 Spotlight 元数据
mdls file.pdf
# 输出包括 kMDItemContentType、kMDItemDateAdded 等

# 查看特定元数据
mdls -name kMDItemContentType file.pdf

# 禁用 Spotlight 索引（指定卷）
sudo mdutil -a off

# 启用 Spotlight 索引
sudo mdutil -a on

# 重建索引
sudo mdutil -E /

7.6 xattr — 扩展属性

# 查看文件的扩展属性
xattr file.txt

# 查看详细扩展属性
xattr -l file.txt

# 移除隔离属性（解决"无法打开因为无法验证开发者"问题）
xattr -d com.apple.quarantine /Applications/App.app

# 移除所有扩展属性
xattr -c file.txt

# 批量移除目录下所有文件的隔离属性
xattr -r -d com.apple.quarantine /Applications/App.app

7.7 codesign — 代码签名

# 验证应用签名
codesign --verify --verbose /Applications/Safari.app

# 查看签名信息
codesign -dv /Applications/Safari.app

# 深度验证（包括所有子组件）
codesign --deep --verify --verbose /Applications/SomeApp.app

# 移除签名
codesign --remove-signature /Applications/SomeApp.app

7.8 softwareupdate — 系统更新

# 列出可用更新
softwareupdate --list

# 安装所有可用更新
softwareupdate --install --all

# 安装指定更新
softwareupdate --install "macOS Sequoia 15.1 Update"

# 安装并重启
softwareupdate --install --all --restart

# 只下载不安装
softwareupdate --download --all

7.9 pmset — 电源管理

# 查看当前电源设置
pmset -g

# 查看电源适配器和电池设置
pmset -g batt

# 设置显示器休眠时间（分钟）
sudo pmset -a displaysleep 15

# 设置系统休眠时间
sudo pmset -a sleep 30

# 禁用休眠（接电源时）
sudo pmset -c sleep 0

# 防止系统休眠（临时）
caffeinate

# 防止系统休眠指定时间（秒）
caffeinate -t 3600

# 防止休眠直到指定命令完成
caffeinate -s make build

# 查看上次唤醒原因
pmset -g log | grep -i "wake from"

7.10 launchctl — 启动服务管理

# 列出所有用户级服务
launchctl list

# 列出系统级服务
sudo launchctl list

# 查找特定服务
launchctl list | grep -i "keyword"

# 停用服务
sudo launchctl unload /System/Library/LaunchDaemons/com.apple.smbd.plist

# 启用服务
sudo launchctl load /System/Library/LaunchDaemons/com.apple.smbd.plist

# 禁止服务（重启后仍禁用）
sudo launchctl disable system/com.apple.smbd

# 启用自定义开机脚本
# 将 plist 文件放到 ~/Library/LaunchAgents/

八、Shell 与终端技巧

8.1 zsh — macOS 默认 Shell

自 macOS Catalina（10.15）起，zsh 成为默认 Shell。

# 查看当前 Shell
echo $SHELL

# 切换到 zsh
chsh -s /bin/zsh

# 切换到 bash
chsh -s /bin/bash

# zsh 配置文件
~/.zshrc # 主配置文件
~/.zshenv # 环境变量
~/.zprofile # 登录时加载
~/.zlogout # 注销时加载

8.2 Oh My Zsh

# 安装 Oh My Zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# 常用主题（在 ~/.zshrc 中设置）
ZSH_THEME="robbyrussell" # 默认主题
ZSH_THEME="agnoster" # 经典 Powerline 风格
ZSH_THEME="powerlevel10k/powerlevel10k" # 最受欢迎

# 常用插件
plugins=(
 git
 zsh-autosuggestions # 自动建议
 zsh-syntax-highlighting # 语法高亮
 z # 快速跳转目录
 docker
 kubectl
)

# 安装常用插件
git clone https://github.com/zsh-users/zsh-autosuggestions \
 ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-syntax-highlighting \
 ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

# 重新加载配置
source ~/.zshrc

8.3 alias — 别名

# 在 ~/.zshrc 中添加别名
alias ll='ls -la'
alias la='ls -a'
alias ..='cd ..'
alias ...='cd ../..'
alias cls='clear'
alias grep='grep --color=auto'
alias ports='lsof -i -P | grep LISTEN'
alias myip='curl -s ifconfig.me'
alias flushdns='sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder'
alias brewup='brew update && brew upgrade && brew cleanup'
alias ip='ipconfig getifaddr en0'

# 带参数的别名
alias mkcd='mkdir -p "$1" && cd "$1"'

# 查看所有别名
alias

# 取消别名
unalias ll

8.4 历史命令

# 查看历史命令
history

# 搜索历史命令（Ctrl+R 进入交互搜索）
# 输入关键字即可反向搜索

# 执行上一条命令
!!

# 执行历史中第 123 条命令
!123

# 执行最近以 git 开头的命令
!git

# zsh 历史记录配置（~/.zshrc）
HISTSIZE=10000
SAVEHIST=10000
HISTFILE=~/.zsh_history
setopt SHARE_HISTORY # 共享历史
setopt HIST_IGNORE_DUPS # 忽略连续重复
setopt HIST_IGNORE_ALL_DUPS # 忽略所有重复

8.5 Ctrl 快捷键

快捷键	功能
`Ctrl + A`	移动到行首
`Ctrl + E`	移动到行尾
`Ctrl + U`	删除光标前所有字符
`Ctrl + K`	删除光标后所有字符
`Ctrl + W`	删除光标前一个单词
`Ctrl + Y`	粘贴上次删除的内容
`Ctrl + L`	清屏（相当于 clear）
`Ctrl + C`	终止当前命令
`Ctrl + Z`	挂起当前命令（用 `fg` 恢复）
`Ctrl + D`	退出当前 Shell
`Ctrl + R`	反向搜索历史命令
`Ctrl + T`	交换光标前两个字符

8.6 管道与重定向

# 管道：将前一个命令的输出作为后一个命令的输入
ps aux | grep -i chrome | grep -v grep

# 输出重定向（覆盖）
echo "Hello" > file.txt

# 输出重定向（追加）
echo "World" >> file.txt

# 错误重定向
command 2> error.log

# 同时重定向标准输出和错误
command > output.log 2>&1

# 简写（stdout + stderr 到同一文件）
command &> output.log

# Here Document（多行文本）
cat << EOF > config.txt
server=127.0.0.1
port=8080
EOF

# 将输出同时显示并保存到文件
ls -la | tee output.txt

# 追加模式
ls -la | tee -a output.txt

# 丢弃输出
command > /dev/null 2>&1

# 排序去重
cat file.txt | sort | uniq

# 统计行数
cat file.txt | wc -l

# 提取特定列
cat data.csv | awk -F',' '{print $2}'

九、安全相关

9.1 csrutil — 系统完整性保护 (SIP)

# 查看 SIP 状态
csrutil status

# 禁用 SIP（需要进入恢复模式）
# 1. 重启 Mac，按住 Command + R 进入恢复模式
# 2. 打开终端
# 3. 执行：
csrutil disable

# 重新启用 SIP（恢复模式下）
csrutil enable

9.2 spctl — Gatekeeper

# 查看 Gatekeeper 状态
spctl --status

# 禁用 Gatekeeper
sudo spctl --master-disable

# 启用 Gatekeeper
sudo spctl --master-enable

# 评估应用是否被允许运行
spctl --assess --verbose /Applications/SomeApp.app

# 添加开发者为可信
spctl --add --label "Approved" /Applications/SomeApp.app

9.3 fdesetup — FileVault 磁盘加密

# 查看 FileVault 状态
fdesetup status

# 启用 FileVault
sudo fdesetup enable

# 禁用 FileVault
sudo fdesetup disable

# 添加额外的恢复用户
sudo fdesetup add -usertoadd username

# 列出 FileVault 授权用户
fdesetup list

# 获取恢复密钥（启用时显示一次）
sudo fdesetup changerecovery -personal

9.4 防火墙

# 查看防火墙状态
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate

# 启用防火墙
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate on

# 阻止所有传入连接
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall on

# 允许特定应用
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add /Applications/SomeApp.app
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblockapp /Applications/SomeApp.app

十、快捷键速查

10.1 Finder 快捷键

快捷键	功能
`⌘ + N`	新建 Finder 窗口
`⌘ + T`	新建标签页
`⌘ + Shift + N`	新建文件夹
`⌘ + Delete`	移到废纸篓
`⌘ + Shift + Delete`	清倒废纸篓
`⌘ + I`	显示简介
`⌘ + Option + V`	移动文件（剪切粘贴）
`⌘ + Shift + .`	显示/隐藏文件
`Space`	快速预览
`⌘ + ↑`	前往上层目录
`⌘ + Shift + G`	前往文件夹（输入路径）
`⌘ + Option + C`	复制路径

10.2 Terminal 快捷键

快捷键	功能
`⌘ + T`	新建标签页
`⌘ + N`	新建窗口
`⌘ + W`	关闭标签页/窗口
`⌘ + D`	水平分屏
`⌘ + Shift + D`	垂直分屏
`⌘ + ←/→`	切换标签页
`⌘ + K`	清屏
`⌘ + F`	查找
`⌘ + +` / `⌘ + -`	放大/缩小字体
`⌘ + 0`	恢复默认字体大小
`Ctrl + C`	终止当前命令
`Ctrl + Z`	挂起当前命令
`Ctrl + R`	搜索历史命令

10.3 截图快捷键

快捷键	功能
`⌘ + Shift + 3`	全屏截图
`⌘ + Shift + 4`	区域截图（拖选）
`⌘ + Shift + 4 + Space`	窗口截图
`⌘ + Shift + 5`	截图和录屏工具栏
`⌘ + Shift + 6`	Touch Bar 截图

截图默认保存到桌面。按住 Ctrl 可将截图复制到剪贴板而不保存文件。

10.4 其他常用快捷键

快捷键	功能
`⌘ + Space`	打开 Spotlight 搜索
`⌘ + Tab`	切换应用
`⌘ + ~`	切换同一应用的窗口
`⌘ + Option + Esc`	强制退出应用
`⌘ + Q`	退出当前应用
`⌘ + H`	隐藏当前窗口
`⌘ + M`	最小化窗口
`⌘ + Option + D`	显示/隐藏 Dock
`Control + ⌘ + Q`	锁屏
`Control + ⌘ + Space`	打开字符面板（Emoji）

十一、实用小技巧

11.1 拖拽文件到终端获取路径

在 Finder 中选中文件或文件夹，直接拖拽到终端窗口中，路径会自动填入。这是快速获取带空格文件路径的最佳方式。

# 拖拽后的效果
open /Users/user/My\ Documents/project\ files/

11.2 右键打开终端

在当前文件夹打开终端：在 Finder 中将终端图标拖到工具栏，或使用以下方法：

# 在系统设置中启用
# 系统设置 → 键盘 → 键盘快捷键 → 服务 → "新建位于文件夹位置的终端窗口"
# 勾选后，右键文件夹即可看到"在终端中打开"选项

11.3 Quick Look（快速预览）

在 Finder 中选中文件后：

Space — 快速预览
Option + Space — 全屏预览
⌘ + Y — 同样效果

安装增强插件可预览更多格式：

brew install --cask qlcolorcode # 代码高亮
brew install --cask qlstephen # 无扩展名文本
brew install --cask qlmarkdown # Markdown
brew install --cask quicklook-json # JSON
brew install --cask suspicious-package # 查看 pkg 内容

安装后刷新 Quick Look 缓存：

qlmanage -r

11.4 AirDrop 命令行

macOS 没有官方的 AirDrop CLI，但可以通过以下方式管理：

# 检查 AirDrop 是否可用
defaults read com.apple.NetworkBrowser DisableAirDrop
# 0 = 启用, 1 = 禁用

# 启用 AirDrop（对所有人可见）
defaults write com.apple.NetworkBrowser DisableAirDrop -bool false

# 查看 AirDrop 接口
ifconfig | grep awdl

11.5 实用组合技巧

# 快速创建并编辑文件
touch newfile.txt && open -a TextEdit newfile.txt

# 批量重命名文件
for f in *.jpeg; do mv "$f" "${f%.jpeg}.jpg"; done

# 查看最占空间的前 10 个目录
du -sh ~/Documents/* 2>/dev/null | sort -rh | head -10

# 一键清理 DNS 缓存
sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder

# 监控 CPU 使用率最高的进程
top -l 1 -o cpu -n 10

# 快速查找大文件
find / -type f -size +100M 2>/dev/null | head -20

# 计算文件 MD5
md5 file.txt
shasum -a 256 file.txt

# 快速启动本地 HTTP 服务器
python3 -m http.server 8080

# 一行命令替换文本
sed -i '' 's/old_text/new_text/g' file.txt

# 查看文件编码
file -I file.txt

# 格式化 JSON
cat data.json | python3 -m json.tool

总结

掌握 macOS 终端命令不仅能大幅提升日常工作效率，还能让你更深入地理解和控制自己的电脑。从文件管理到网络调试，从 Homebrew 包管理到系统安全配置，终端几乎可以完成所有系统操作。

建议初学者从以下命令开始练习：

基础操作：ls、cd、cp、mv、rm、mkdir
文本查看：cat、head、tail、grep
系统信息：sw_vers、system_profiler、top
网络工具：ping、curl、ifconfig
包管理：安装 Homebrew，用 brew 管理软件

随着使用频率的增加，逐步学习管道、重定向、Shell 脚本编写等进阶技巧，最终你会发现终端是 macOS 上最强大的工具之一。

Linux 防火墙完全指南：UFW 与 firewalld 从入门到精通

Thu, 25 Jun 2026 11:30:00 +0000

服务器安全的第一道防线就是防火墙。Linux 下最常用的三款防火墙管理工具是 iptables、UFW 和 firewalld。本文将从对比入手，逐一深入讲解 UFW 和 firewalld 的完整用法，并通过大量实战场景帮你快速上手。

一、三大防火墙工具对比

iptables / UFW / firewalld 适用场景

工具	底层机制	适用发行版	复杂度	适用场景
iptables	Netfilter	所有 Linux	高	需要精细控制每条规则、编写脚本自动化、内核级调优
UFW	iptables/nftables	Ubuntu/Debian	低	快速配置主机防火墙、个人服务器、简单规则场景
firewalld	nftables（RHEL8+）/ iptables（RHEL7）	RHEL/CentOS/Fedora	中	企业服务器、需要 zone 隔离、动态规则管理

简而言之：

iptables：底层原始工具，功能最强大，但规则管理复杂，适合高级用户和脚本场景。
UFW：iptables 的前端封装，语法简洁，Ubuntu/Debian 用户首选。
firewalld：基于 zone 的动态管理，支持运行时/永久规则分离，RHEL 系首选。

重要说明：三者底层都是 Linux 内核的 Netfilter 框架。同一个系统上不要同时启用多个防火墙管理工具，避免规则冲突。

二、UFW 完整教程

2.1 安装与启用

# Ubuntu/Debian 通常预装，如果没有：
sudo apt update
sudo apt install ufw

# 启用 UFW（启用前务必先放行 SSH，否则远程服务器会断连！）
sudo ufw allow ssh
sudo ufw enable

# 查看状态
sudo ufw status
sudo ufw status verbose # 显示详细信息
sudo ufw status numbered # 带编号显示，方便删除规则

2.2 默认策略

# 查看默认策略
sudo ufw status verbose
# 输出示例：
# Default: deny (incoming), allow (outgoing), disabled (routed)

# 设置默认策略
sudo ufw default deny incoming # 拒绝所有入站（推荐）
sudo ufw default allow outgoing # 允许所有出站（推荐）
sudo ufw default deny routed # 拒绝转发（非路由器场景推荐）

最佳实践：默认拒绝入站，按需开放端口。这是最小权限原则的体现。

2.3 allow / deny 规则

# 允许特定端口
sudo ufw allow 80 # 允许 TCP 80
sudo ufw allow 443 # 允许 TCP 443
sudo ufw allow 8080/tcp # 仅允许 TCP 协议的 8080 端口
sudo ufw allow 53/udp # 仅允许 UDP 协议的 53 端口

# 允许端口范围
sudo ufw allow 3000:4000/tcp # 允许 TCP 3000-4000 端口段
sudo ufw allow 6000:6007/udp # 允许 UDP 6000-6007 端口段

# 拒绝特定端口
sudo ufw deny 23 # 拒绝 telnet 端口
sudo ufw deny 3306/tcp # 拒绝 MySQL 端口

# 按服务名称（需 /etc/services 中有定义）
sudo ufw allow http
sudo ufw allow https
sudo ufw allow ssh
sudo ufw allow ftp
sudo ufw allow smtp
sudo ufw allow dns

2.4 IP 限制

# 允许特定 IP 访问所有端口
sudo ufw allow from 192.168.1.100

# 允许特定 IP 访问特定端口
sudo ufw allow from 192.168.1.100 to any port 22
sudo ufw allow from 192.168.1.100 to any port 3306

# 允许特定子网
sudo ufw allow from 192.168.1.0/24
sudo ufw allow from 10.0.0.0/8 to any port 6379

# 拒绝特定 IP
sudo ufw deny from 203.0.113.50
sudo ufw deny from 203.0.113.0/24

# 指定网卡
sudo ufw allow in on eth0 to any port 80
sudo ufw allow in on eth1 from 192.168.1.0/24

2.5 应用配置文件

# 查看可用的应用配置文件
sudo ufw app list

# 查看某个应用的详细信息
sudo ufw app info 'Nginx Full'
# 输出示例：
# Profile: Nginx Full
# Title: Web Server (Nginx, HTTP + HTTPS)
# Ports:
# 80,443/tcp

# 使用应用配置文件添加规则
sudo ufw allow 'Nginx Full' # 放行 HTTP + HTTPS
sudo ufw allow 'Nginx HTTP' # 仅放行 HTTP
sudo ufw allow 'OpenSSH' # 放行 SSH

# 自定义应用配置文件
sudo vim /etc/ufw/applications.d/myapp

自定义配置文件格式：

[MyWebApp]
title=My Custom Web Application
description=My web app running on ports 8080 and 8443
ports=8080/tcp|8443/tcp

[MyDB]
title=Database Server
description=PostgreSQL and Redis
ports=5432/tcp|6379/tcp

# 重新加载应用列表
sudo ufw app update
sudo ufw app update 'MyWebApp'

# 使用自定义应用
sudo ufw allow 'MyWebApp'

2.6 删除规则

# 方法一：按规则内容删除
sudo ufw delete allow 80
sudo ufw delete deny from 203.0.113.50
sudo ufw delete allow from 192.168.1.100 to any port 3306

# 方法二：按编号删除（推荐）
sudo ufw status numbered
# 输出示例：
# [ 1] 22/tcp ALLOW IN Anywhere
# [ 2] 80/tcp ALLOW IN Anywhere
# [ 3] 443/tcp ALLOW IN Anywhere

sudo ufw delete 2 # 删除第 2 条规则

# 重置所有规则（谨慎使用！）
sudo ufw reset

2.7 日志

# 开启日志
sudo ufw logging on
sudo ufw logging low # 级别：off / low / medium / high / full
sudo ufw logging medium
sudo ufw logging high

# 日志位置
# /var/log/ufw.log
# /var/log/syslog（也会记录 UFW 日志）

# 查看日志
sudo tail -f /var/log/ufw.log
sudo grep "UFW" /var/log/syslog

# 实时监控被拒绝的连接
sudo tail -f /var/log/ufw.log | grep "BLOCK"

2.8 UFW 与 iptables 的关系

UFW 本质上是 iptables 的前端封装，所有 UFW 规则最终都会转换为 iptables 规则：

# 查看 UFW 生成的 iptables 规则
sudo iptables -L -n -v
sudo iptables -t nat -L -n -v

# UFW 的规则文件位于
# /etc/ufw/user.rules - IPv4 规则
# /etc/ufw/user6.rules - IPv6 规则
# /etc/ufw/before.rules - 在用户规则之前加载
# /etc/ufw/after.rules - 在用户规则之后加载
# /etc/ufw/sysctl.conf - 内核参数配置

# 可以直接编辑 before.rules 添加高级规则
# 例如：在 UFW 规则之前添加 NAT 规则
sudo vim /etc/ufw/before.rules

# 编辑后重新加载
sudo ufw reload

注意：不要混用 ufw 命令和直接 iptables 命令。如果需要自定义 iptables 规则，建议放在 before.rules 或 after.rules 文件中，由 UFW 统一管理。

三、firewalld 完整教程

3.1 安装与基本操作

# CentOS/RHEL 7+ 通常预装
sudo yum install firewalld # CentOS 7
sudo dnf install firewalld # CentOS 8/9、Fedora

# 启动与开机自启
sudo systemctl start firewalld
sudo systemctl enable firewalld
sudo systemctl status firewalld

# 检查是否正在运行
sudo firewall-cmd --state

# 重载配置
sudo firewall-cmd --reload

3.2 Zone（区域）概念

Zone 是 firewalld 的核心概念。每个网络接口绑定一个 zone，zone 决定了该接口的默认信任级别和允许的服务。

# 查看所有 zone
sudo firewall-cmd --get-zones
# 输出示例：block dmz drop external home internal public trusted work

# 查看当前活动的 zone 及其绑定的接口
sudo firewall-cmd --get-active-zones

# 查看默认 zone
sudo firewall-cmd --get-default-zone

# 修改默认 zone
sudo firewall-cmd --set-default-zone=public

# 将接口绑定到指定 zone
sudo firewall-cmd --zone=internal --change-interface=eth0 --permanent
sudo firewall-cmd --zone=public --change-interface=eth1 --permanent

# 查看某个 zone 的详细配置
sudo firewall-cmd --zone=public --list-all
sudo firewall-cmd --zone=public --list-all --permanent

3.3 Zone 信任级别

Zone	信任级别	说明
drop	最低	丢弃所有入站包，不回复任何信息
block	低	拒绝所有入站包，返回 ICMP 拒绝消息
public	默认	仅允许选定的入站连接（默认 zone）
external	中	用于 NAT 路由的外部网络，仅允许选定服务
dmz	中	隔离区域，仅允许选定服务
work	较高	工作网络，信任大部分计算机
home	较高	家庭网络，信任大部分计算机
internal	高	内部网络，信任大部分计算机
trusted	最高	信任所有网络连接

3.4 服务管理

# 查看所有预定义服务
sudo firewall-cmd --get-services

# 查看当前 zone 允许的服务
sudo firewall-cmd --list-services

# 添加服务（运行时生效，重启后失效）
sudo firewall-cmd --add-service=http
sudo firewall-cmd --add-service=https
sudo firewall-cmd --add-service=ssh
sudo firewall-cmd --add-service=mysql

# 添加服务（永久生效）
sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-service=https --permanent

# 批量添加
sudo firewall-cmd --add-service={http,https,ssh} --permanent

# 移除服务
sudo firewall-cmd --remove-service=http --permanent

# 在指定 zone 中操作
sudo firewall-cmd --zone=public --add-service=http --permanent
sudo firewall-cmd --zone=internal --add-service=mysql --permanent

# 自定义服务
sudo vim /etc/firewalld/services/myapp.xml

自定义服务 XML 文件示例：

<?xml version="1.0" encoding="utf-8"?>
<service>
 <short>MyApp</short>
 <description>My custom web application</description>
 <port protocol="tcp" port="8080"/>
 <port protocol="tcp" port="8443"/>
</service>

# 重新加载 firewalld 使自定义服务生效
sudo firewall-cmd --reload
sudo firewall-cmd --add-service=myapp --permanent

3.5 端口管理

# 添加端口
sudo firewall-cmd --add-port=8080/tcp
sudo firewall-cmd --add-port=3000-3100/tcp
sudo firewall-cmd --add-port=53/udp

# 永久添加端口
sudo firewall-cmd --add-port=8080/tcp --permanent

# 查看开放的端口
sudo firewall-cmd --list-ports

# 移除端口
sudo firewall-cmd --remove-port=8080/tcp --permanent

# 在指定 zone 中操作
sudo firewall-cmd --zone=public --add-port=8080/tcp --permanent

3.6 富规则（Rich Rules）

富规则提供了比简单服务/端口更精细的控制能力：

# 允许特定 IP 访问特定端口
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.100" port port="22" protocol="tcp" accept' --permanent

# 允许特定子网访问特定端口
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port port="3306" protocol="tcp" accept' --permanent

# 拒绝特定 IP
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="203.0.113.50" reject' --permanent

# 允许特定 IP 每分钟最多 5 次新连接（限流）
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.100" port port="22" protocol="tcp" accept limit value="5/m"' --permanent

# 允许特定 IP 段访问，并记录日志
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="10.0.0.0/8" port port="6379" protocol="tcp" log prefix="REDIS-ACCESS: " level="info" accept' --permanent

# 查看所有富规则
sudo firewall-cmd --list-rich-rules

# 删除富规则
sudo firewall-cmd --remove-rich-rule='rule family="ipv4" source address="203.0.113.50" reject' --permanent

3.7 永久规则 vs 运行时规则

firewalld 有两套规则：运行时规则（runtime） 和 永久规则（permanent）。

# 运行时规则：立即生效，重启 firewalld 后消失
sudo firewall-cmd --add-service=http
sudo firewall-cmd --add-port=8080/tcp

# 永久规则：写入配置文件，需要 reload 或重启才生效
sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-port=8080/tcp --permanent

# 查看差异
sudo firewall-cmd --list-all # 运行时
sudo firewall-cmd --list-all --permanent # 永久

# 将运行时规则持久化（保存当前运行时规则为永久规则）
sudo firewall-cmd --runtime-to-permanent

# 重新加载使永久规则生效
sudo firewall-cmd --reload

# 永久配置文件位置
# /etc/firewalld/zones/public.xml
# /etc/firewalld/firewalld.conf

最佳实践：生产环境建议总是使用 --permanent，然后 --reload。这样可以先用不带 --permanent 的命令测试，确认无误后再加 --permanent 持久化。

3.8 转发配置

# 启用 IP 转发（内核层面）
echo "net.ipv4.ip_forward = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# firewalld 端口转发（在 zone 中配置）
# 将外部 80 端口转发到内部 192.168.1.100:8080
sudo firewall-cmd --add-forward-port=port=80:proto=tcp:toport=8080:toaddr=192.168.1.100 --permanent

# 同端口不同主机的转发
sudo firewall-cmd --add-forward-port=port=443:proto=tcp:toport=443:toaddr=10.0.0.50 --permanent

# 启用伪装（NAT）
sudo firewall-cmd --add-masquerade --permanent

# 查看转发规则
sudo firewall-cmd --list-forward-ports

# 删除转发规则
sudo firewall-cmd --remove-forward-port=port=80:proto=tcp:toport=8080:toaddr=192.168.1.100 --permanent

四、UFW vs firewalld 对比表

对比项	UFW	firewalld
默认发行版	Ubuntu/Debian	RHEL/CentOS/Fedora
底层实现	iptables/nftables	nftables/iptables
配置方式	命令行为主	命令行 + XML 配置文件
核心概念	允许/拒绝规则	Zone 区域 + 服务/端口/富规则
运行时/永久	无区分，操作即持久	分离，需 `--permanent` 和 `reload`
默认策略	deny in, allow out	取决于 zone 配置
复杂度	⭐ 低	⭐⭐ 中
学习曲线	5 分钟上手	需要理解 zone 概念
精细控制	有限（需结合 iptables）	强（富规则支持条件组合）
图形界面	gufw（第三方）	firewall-config（官方）
Docker 兼容性	需额外配置	需额外配置
适合人群	个人开发者、小服务器	企业运维、多网卡服务器

选择建议：

Ubuntu/Debian 系统 → 优先用 UFW，简单高效
RHEL/CentOS/Fedora 系统 → 优先用 firewalld，功能全面
需要 zone 隔离、富规则、动态管理 → firewalld
只需要快速开关端口 → UFW

五、端口转发实战

5.1 UFW 端口转发

步骤一：编辑 sysctl 启用 IP 转发

sudo vim /etc/ufw/sysctl.conf
# 取消注释或添加：
# net/ipv4/ip_forward=1

步骤二：编辑 before.rules 添加 NAT 规则

sudo vim /etc/ufw/before.rules

在 *filter 部分之前添加 NAT 表：

# 在文件头部（*filter 之前）添加：
*nat
:PREROUTING ACCEPT [0:0]
-A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
COMMIT

步骤三：修改 UFW 默认转发策略并重载

# /etc/default/ufw 中修改
sudo sed -i 's/DEFAULT_FORWARD_POLICY="DROP"/DEFAULT_FORWARD_POLICY="ACCEPT"/' /etc/default/ufw

# 或者使用 UFW 转发规则
sudo ufw route allow in on eth0 out on eth0 to 192.168.1.100 port 8080

sudo ufw reload

简化方式（使用 ufw route）：

# 允许从 eth0 转发到本地 8080
sudo ufw route allow to 127.0.0.1 port 8080 proto tcp from any

5.2 firewalld 端口转发

# 方法一：使用内建的端口转发功能

# 启用伪装（NAT 必需）
sudo firewall-cmd --add-masquerade --permanent

# 转发规则：将 80 端口转发到本地 8080
sudo firewall-cmd --add-forward-port=port=80:proto=tcp:toport=8080 --permanent

# 转发到其他主机：将 80 端口转发到 192.168.1.100 的 8080
sudo firewall-cmd --add-forward-port=port=80:proto=tcp:toport=8080:toaddr=192.168.1.100 --permanent

# 重新加载
sudo firewall-cmd --reload

# 方法二：使用富规则（更灵活）
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" forward-port port="80" protocol="tcp" to-port="8080" to-addr="10.0.0.100"' --permanent

sudo firewall-cmd --reload

5.3 iptables 端口转发

# 启用 IP 转发
echo 1 | sudo tee /proc/sys/net/ipv4/ip_forward
echo "net.ipv4.ip_forward = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 方式一：DNAT 转发到其他主机
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.1.100:8080
sudo iptables -t nat -A POSTROUTING -j MASQUERADE

# 方式二：本地端口重定向
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080

# 方式三：使用 DNAT 转发到本地
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to-destination 127.0.0.1:8080
sudo iptables -A INPUT -p tcp --dport 8080 -j ACCEPT

# 保存规则（安装 iptables-persistent）
sudo apt install iptables-persistent # Debian/Ubuntu
sudo netfilter-persistent save

# CentOS/RHEL 保存方式
sudo service iptables save

六、常见场景速查

6.1 Web 服务器（Nginx/Apache）

UFW 方式：

sudo ufw allow 'Nginx Full' # 放行 80 + 443
# 或者
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow ssh
sudo ufw default deny incoming
sudo ufw enable

firewalld 方式：

sudo firewall-cmd --permanent --add-service={http,https,ssh}
sudo firewall-cmd --reload

6.2 数据库仅内网访问（MySQL/PostgreSQL/Redis）

UFW 方式：

# 允许内网段访问 MySQL
sudo ufw allow from 192.168.1.0/24 to any port 3306

# 允许内网段访问 Redis
sudo ufw allow from 192.168.1.0/24 to any port 6379

# 允许内网段访问 PostgreSQL
sudo ufw allow from 192.168.1.0/24 to any port 5432

# 确保默认策略为拒绝
sudo ufw default deny incoming

firewalld 方式：

# MySQL 只允许内网 zone 访问
sudo firewall-cmd --zone=internal --add-service=mysql --permanent

# 或使用富规则精确控制
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port port="3306" protocol="tcp" accept' --permanent
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port port="6379" protocol="tcp" accept' --permanent

# 从 public zone 移除（如果之前误加了）
sudo firewall-cmd --zone=public --remove-service=mysql --permanent
sudo firewall-cmd --reload

6.3 SSH 安全加固

UFW 方式：

# 限制 SSH 连接频率（30 秒内最多 6 次连接）
sudo ufw limit ssh
# 等价于：
sudo ufw limit 22/tcp

# 只允许特定 IP SSH 登录
sudo ufw allow from 203.0.113.10 to any port 22 proto tcp

# 只允许特定子网 SSH 登录
sudo ufw allow from 10.0.0.0/8 to any port 22 proto tcp

firewalld 方式：

# 使用富规则限流
sudo firewall-cmd --add-rich-rule='rule service name="ssh" limit value="3/m" accept' --permanent

# 只允许特定 IP SSH
sudo firewall-cmd --add-rich-rule='rule family="ipv4" source address="203.0.113.10" port port="22" protocol="tcp" accept' --permanent

# 修改 SSH 端口后放行新端口
sudo firewall-cmd --add-port=2222/tcp --permanent
sudo firewall-cmd --reload

6.4 Docker 与防火墙冲突

Docker 默认直接操作 iptables，会绕过 UFW/firewalld 的规则，这是个常见坑。

问题现象：即使 UFW 设置了 deny incoming，Docker 容器暴露的端口仍然可以从外部访问。

UFW 解决方案（推荐使用 ufw-docker）：

# 安装 ufw-docker
sudo apt install git
git clone https://github.com/chaifeng/ufw-docker.git
sudo cp ufw-docker/ufw-docker /usr/local/bin/
sudo chmod +x /usr/local/bin/ufw-docker

# 重新加载 UFW
sudo systemctl reload ufw

# 允许外部访问 Docker 容器端口
sudo ufw-docker allow 80 # 允许访问容器的 80 端口
sudo ufw-docker allow 443 # 允许访问容器的 443 端口

# 允许特定 IP 访问容器端口
sudo ufw-docker allow 3306 default # 只允许 default 网络

# 删除规则
sudo ufw-docker delete allow 80

# 查看规则
sudo ufw-docker list

firewalld 解决方案：

# 方法一：让 Docker 使用 firewalld 管理的 zone
# 编辑 Docker daemon 配置
sudo vim /etc/docker/daemon.json

{
 "iptables": false
}

# 然后使用 firewalld 手动管理 Docker 端口
sudo firewall-cmd --permanent --direct --add-rule ipv4 filter DOCKER-USER 0 -i docker0 -j ACCEPT
sudo firewall-cmd --permanent --direct --add-rule ipv4 filter DOCKER-USER 0 ! -i docker0 -p tcp --dport 8080 -j ACCEPT
sudo firewall-cmd --reload

方法二：修改 before.rules（UFW 方案替代）

sudo vim /etc/ufw/after.rules
# 在文件末尾添加：

*nat
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 172.16.0.0/12 ! -o docker0 -j MASQUERADE
COMMIT

sudo ufw reload

七、注意事项

7.1 远程操作防火墙的安全提示

# ⚠️ 永远先放行 SSH 再启用防火墙！
# 错误示范（会导致服务器失联）：
sudo ufw enable # 如果默认策略是 deny，SSH 被切断
sudo systemctl start firewalld # 如果 public zone 没有 ssh 服务

# 正确示范：
sudo ufw allow ssh
sudo ufw enable

7.2 规则顺序很重要

UFW：规则按添加顺序排列，但无编号管理时不方便调整。建议用 status numbered 查看并用编号删除。
firewalld：规则评估顺序为富规则 → 服务 → 端口，更具体的规则优先。

7.3 不要同时使用多个防火墙工具

# 检查当前活跃的防火墙
sudo ufw status
sudo systemctl status firewalld
sudo iptables -L -n

# 如果从 firewalld 迁移到 iptables，先禁用 firewalld
sudo systemctl stop firewalld
sudo systemctl disable firewalld

# 反之亦然
sudo ufw disable

7.4 备份与恢复

# UFW 备份
sudo cp -r /etc/ufw /etc/ufw.backup
sudo cp /etc/default/ufw /etc/default/ufw.backup

# UFW 恢复
sudo cp -r /etc/ufw.backup/* /etc/ufw/
sudo ufw reload

# firewalld 备份
sudo cp -r /etc/firewalld /etc/firewalld.backup

# firewalld 恢复
sudo cp -r /etc/firewalld.backup/* /etc/firewalld/
sudo firewall-cmd --reload

7.5 IPv6 支持

# UFW 自动启用 IPv6（如果 /etc/default/ufw 中 IPV6=yes）
# UFW 的 IPv6 规则存储在 /etc/ufw/user6.rules

# firewalld 默认支持 IPv6
sudo firewall-cmd --add-rich-rule='rule family="ipv6" source address="::1" port port="80" protocol="tcp" accept'

7.6 排错技巧

# 查看当前生效的规则
# UFW
sudo ufw status verbose
sudo iptables -L -n -v | head -40

# firewalld
sudo firewall-cmd --list-all
sudo firewall-cmd --list-all --permanent
sudo nft list ruleset # CentOS 9 / RHEL 9 查看 nftables 规则

# 测试端口连通性（从客户端）
nc -zv server_ip 22 # 测试 TCP 端口
telnet server_ip 80 # 测试 TCP 端口
nmap -p 22,80,443 server_ip # 扫描多个端口

# 检查服务是否监听
sudo ss -tlnp # 查看所有 TCP 监听端口
sudo ss -ulnp # 查看所有 UDP 监听端口
sudo netstat -tlnp # 传统方式（需安装 net-tools）

总结

你需要做什么	用 UFW	用 firewalld
放行 HTTP/HTTPS	`ufw allow 80,443`	`firewall-cmd --add-service={http,https} --permanent`
仅内网访问数据库	`ufw allow from 192.168.1.0/24 to any port 3306`	富规则指定 source 地址
限制 SSH 连接频率	`ufw limit ssh`	富规则 + limit
查看所有规则	`ufw status numbered`	`firewall-cmd --list-all`
持久化	自动持久	加 `--permanent` 后 `--reload`
端口转发	编辑 before.rules	`firewall-cmd --add-forward-port`

防火墙配置是服务器安全的基石。建议在每台新服务器部署时就把防火墙配置纳入初始化流程，避免裸奔上线。记住三条原则：默认拒绝、按需开放、定期审计。

Linux iptables 防火墙与端口转发完全指南

Thu, 25 Jun 2026 11:00:00 +0000

Linux iptables 防火墙与端口转发完全指南

iptables 是 Linux 系统中最经典、最强大的防火墙管理工具之一，几乎所有 Linux 运维工程师都需要熟练掌握。本文将从原理到实战，全面讲解 iptables 的使用方法。

一、iptables 与 netfilter 的关系

很多初学者容易混淆 iptables 和 netfilter，它们的关系如下：

netfilter 是 Linux 内核中的一个框架，它在内核网络协议栈的多个关键位置设置了"钩子点"（hooks），允许内核模块注册回调函数来处理数据包。
iptables 是运行在用户空间的命令行工具，用于向 netfilter 框架中添加、删除、查看规则。

简单来说：

用户空间： iptables（用户态管理工具） ←→ libipq / libiptc（库）
 ↕
内核空间： netfilter（内核框架） → 钩子点 → 规则表 → 链 → 规则

一句话总结：netfilter 是内核态的包过滤框架，iptables 是用户态的规则管理工具。iptables 通过内核接口将规则写入 netfilter。

二、四表五链详解

2.1 四表（Tables）

iptables 用"表"来组织不同功能的规则：

表名	功能	包含的链
filter	过滤数据包（默认表）	INPUT, OUTPUT, FORWARD
nat	网络地址转换	PREROUTING, OUTPUT, POSTROUTING
mangle	修改数据包头部信息（TTL、TOS 等）	全部五条链
raw	连接跟踪豁免，用于处理不期望被跟踪的包	PREROUTING, OUTPUT

表的优先级（数据包经过多个表时的处理顺序）：

raw → mangle → nat → filter

2.2 五链（Chains）

链是数据包经过内核网络协议栈时触发的检查点：

链名	触发时机	适用场景
PREROUTING	数据包进入路由判断之前	DNAT、raw 豁免
INPUT	数据包目的地是本机	保护本机服务
FORWARD	数据包需要转发（非本机目的地）	路由器/网关场景
OUTPUT	本机产生的出站数据包	限制本机出站
POSTROUTING	数据包离开本机之前（路由之后）	SNAT、MASQUERADE

2.3 表与链的对应关系

┌──────────┬─────────────────────────────────────┐
│ 表名 │ 包含的链 │
├──────────┼─────────────────────────────────────┤
│ raw │ PREROUTING, OUTPUT │
│ mangle │ PREROUTING, INPUT, FORWARD, │
│ │ OUTPUT, POSTROUTING │
│ nat │ PREROUTING, OUTPUT, POSTROUTING │
│ filter │ INPUT, FORWARD, OUTPUT │
└──────────┴─────────────────────────────────────┘

三、数据包匹配流程

理解数据包在 iptables 中的流转路径是正确配置规则的关键。

3.1 入站数据包（目标是本机）

网卡收到数据包
 │
 ▼
PREROUTING 链
 ├── raw 表
 ├── mangle 表
 └── nat 表（DNAT）
 │
 ▼
路由判断：目的地是本机？
 │ 是
 ▼
INPUT 链
 ├── mangle 表
 └── filter 表
 │
 ▼
 本机进程处理

3.2 转发数据包（目标不是本机）

网卡收到数据包
 │
 ▼
PREROUTING 链
 │
 ▼
路由判断：目的地不是本机
 │
 ▼
FORWARD 链
 ├── mangle 表
 └── filter 表
 │
 ▼
POSTROUTING 链
 ├── mangle 表
 └── nat 表（SNAT/MASQUERADE）
 │
 ▼
 网卡发出

3.3 本机发出的数据包

本机进程产生数据包
 │
 ▼
OUTPUT 链
 ├── raw 表
 ├── mangle 表
 ├── nat 表（DNAT/OUTPUT）
 └── filter 表
 │
 ▼
POSTROUTING 链
 │
 ▼
 网卡发出

规则匹配原则：在同一条链中，数据包按规则顺序逐条匹配。一旦匹配成功，就执行该规则的控制类型（如 ACCEPT、DROP），并且不再继续匹配后续规则（LOG 除外）。如果所有规则都不匹配，则执行该链的默认策略。

四、常用命令语法

4.1 命令基本格式

iptables [-t 表名] 管理选项 [链名] [匹配条件] [-j 控制类型]

-t 表名：指定操作的表，默认为 filter
管理选项：增删查改规则
链名：指定操作的链
匹配条件：数据包的匹配特征
-j 控制类型：匹配后的动作

4.2 管理选项速查

追加规则（-A）

在链的末尾追加一条规则：

# 允许所有来自 192.168.1.0/24 网段的 SSH 连接
iptables -A INPUT -s 192.168.1.0/24 -p tcp --dport 22 -j ACCEPT

插入规则（-I）

在链的指定位置插入规则（默认第 1 条）：

# 在 INPUT 链的第 1 位插入一条允许 loopback 的规则
iptables -I INPUT 1 -i lo -j ACCEPT

# 不指定序号，默认插入到第 1 位
iptables -I INPUT -s 10.0.0.1 -j ACCEPT

删除规则（-D）

删除指定规则：

# 按规则内容删除
iptables -D INPUT -s 192.168.1.0/24 -p tcp --dport 22 -j ACCEPT

# 按序号删除（先用 -L --line-numbers 查看序号）
iptables -D INPUT 3

替换规则（-R）

替换指定位置的规则：

# 将 INPUT 链第 2 条规则替换为新规则
iptables -R INPUT 2 -s 192.168.1.100 -p tcp --dport 80 -j ACCEPT

查看规则（-L）

# 查看所有规则（默认 filter 表）
iptables -L

# 显示详细信息（含包计数器和字节计数器）
iptables -L -v

# 以数字形式显示地址和端口（不进行 DNS 解析，速度更快）
iptables -L -v -n

# 显示规则序号
iptables -L -v -n --line-numbers

# 查看指定表的规则
iptables -t nat -L -v -n

# 查看指定链的规则
iptables -L INPUT -v -n

# 以精确命令格式显示（可直接复制用来恢复规则）
iptables -S
iptables -S INPUT

清空规则（-F）

# 清空 filter 表的所有规则
iptables -F

# 清空指定表的所有规则
iptables -t nat -F

# 清空指定链的规则
iptables -F INPUT

设置默认策略（-P）

# 设置 INPUT 链默认策略为 DROP（丢弃）
iptables -P INPUT DROP

# 设置 FORWARD 链默认策略为 ACCEPT
iptables -P FORWARD ACCEPT

# 设置 OUTPUT 链默认策略为 ACCEPT
iptables -P OUTPUT ACCEPT

⚠️ 注意：-P 只能设置为 ACCEPT 或 DROP，不能设置为 REJECT。

新建自定义链（-N）、重命名（-E）、删除（-X）

# 创建自定义链
iptables -N MY_CHAIN

# 在自定义链中添加规则
iptables -A MY_CHAIN -s 192.168.1.0/24 -j ACCEPT
iptables -A MY_CHAIN -j DROP

# 将自定义链挂载到 INPUT 链
iptables -A INPUT -j MY_CHAIN

# 重命名自定义链
iptables -E MY_CHAIN CUSTOM_RULES

# 删除自定义链（必须先清空链中的规则，并且没有引用）
iptables -X CUSTOM_RULES

五、匹配条件

5.1 协议匹配（-p）

# 匹配 TCP 协议
iptables -A INPUT -p tcp -j ACCEPT

# 匹配 UDP 协议
iptables -A INPUT -p udp -j ACCEPT

# 匹配 ICMP 协议（ping）
iptables -A INPUT -p icmp -j ACCEPT

# 使用协议编号（可查看 /etc/protocols）
iptables -A INPUT -p 6 -j ACCEPT # 6 = TCP

5.2 地址匹配（-s / -d）

# 源地址匹配
iptables -A INPUT -s 192.168.1.100 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
iptables -A INPUT -s 10.0.0.0/8 -j DROP

# 目标地址匹配
iptables -A OUTPUT -d 8.8.8.8 -j ACCEPT
iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT

# 排除某个地址（取反）
iptables -A INPUT ! -s 192.168.1.0/24 -j DROP

5.3 端口匹配（–sport / –dport）

# 目标端口匹配（需要配合 -p tcp 或 -p udp）
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 源端口匹配
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT

# 多端口匹配（逗号分隔）
iptables -A INPUT -p tcp -m multiport --dports 80,443,8080 -j ACCEPT

# 端口范围
iptables -A INPUT -p tcp --dport 1024:65535 -j ACCEPT
iptables -A INPUT -p tcp --dport 8000:9000 -j ACCEPT

5.4 网络接口匹配（-i / -o）

# 入站接口
iptables -A INPUT -i eth0 -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT # loopback 回环接口

# 出站接口
iptables -A OUTPUT -o eth0 -j ACCEPT

# 转发时的入/出接口
iptables -A FORWARD -i eth0 -o eth1 -j ACCEPT

5.5 状态匹配（-m state / -m conntrack）

# 使用 state 模块
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 22 -j ACCEPT

# 使用更现代的 conntrack 模块
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

连接状态说明：

状态	含义
NEW	新建连接（第一个包）
ESTABLISHED	已建立的连接（双向有流量）
RELATED	与已建立连接相关的（如 FTP 数据通道）
INVALID	无法识别或无效的数据包

最佳实践：允许 ESTABLISHED 和 RELATED 状态的数据包，是构建有状态防火墙的基础。

5.6 速率限制匹配（-m limit / -m hashlimit）

# limit 模块：限制匹配速率
# 每秒最多 3 个 ICMP 包，允许突发 5 个
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 3/s --limit-burst 5 -j ACCEPT
iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

# 限制每分钟最多 10 个新 SSH 连接
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m limit --limit 10/minute --limit-burst 3 -j ACCEPT

# recent 模块：基于 IP 记录连接频率
# 60 秒内同一个 IP 最多 5 次新 SSH 连接
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set --name SSH
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 5 --name SSH -j DROP

5.7 其他常用匹配模块

# 字符串匹配：阻止包含特定字符串的数据包
iptables -A INPUT -p tcp --dport 80 -m string --string "malware" --algo bm -j DROP

# MAC 地址匹配
iptables -A INPUT -m mac --mac-source 00:11:22:33:44:55 -j ACCEPT

# 时间匹配：只在工作时间（周一到周五 9:00-18:00）允许访问
iptables -A INPUT -p tcp --dport 80 -m time --timestart 09:00 --timestop 18:00 --weekdays Mon,Tue,Wed,Thu,Fri -j ACCEPT

# TTL 匹配
iptables -A INPUT -m ttl --ttl-eq 64 -j ACCEPT

六、控制类型（Targets）

6.1 ACCEPT

允许数据包通过。

iptables -A INPUT -p tcp --dport 80 -j ACCEPT

6.2 DROP

静默丢弃数据包，不向发送方返回任何信息。安全性较高，但会导致连接超时。

iptables -A INPUT -s 10.0.0.5 -j DROP

6.3 REJECT

丢弃数据包并向发送方返回一个 ICMP 错误消息（如 port-unreachable）。对调用者友好，但会暴露防火墙存在。

# 默认返回 port-unreachable
iptables -A INPUT -s 10.0.0.5 -j REJECT

# 指定返回的 ICMP 类型
iptables -A INPUT -s 10.0.0.5 -j REJECT --reject-with icmp-host-unreachable
iptables -A INPUT -p tcp --dport 23 -j REJECT --reject-with tcp-reset

6.4 LOG

将匹配的数据包记录到系统日志（/var/log/messages 或 /var/log/kern.log），然后继续匹配下一条规则。

# 记录所有被丢弃的入站包
iptables -A INPUT -j LOG --log-prefix "IPT-DROP: " --log-level 4

# 记录新 SSH 连接
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j LOG --log-prefix "IPT-SSH-NEW: "

# 配合 limit 避免日志洪水
iptables -A INPUT -j LOG --log-prefix "IPT-INPUT: " --log-level 4 -m limit --limit 5/minute

日志查看：tail -f /var/log/messages 或 tail -f /var/log/kern.log 或 journalctl -k -f

6.5 自定义链跳转

# 将匹配条件的包交给自定义链处理
iptables -A INPUT -p tcp -m multiport --dports 80,443 -j WEB_CHAIN

七、NAT 与端口转发

7.1 开启 IP 转发

作为路由器或进行 NAT 转发时，必须先开启内核的 IP 转发功能：

# 临时生效（重启后失效）
echo 1 > /proc/sys/net/ipv4/ip_forward
# 或
sysctl -w net.ipv4.ip_forward=1

# 永久生效：编辑 /etc/sysctl.conf
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sysctl -p

# 验证
cat /proc/sys/net/ipv4/ip_forward
# 输出 1 表示已开启

7.2 SNAT（源地址转换）

用于内网主机通过网关访问外网时，将数据包的源地址替换为网关的公网 IP。

适用场景：内网所有主机通过一个公网 IP 上网。

# 将来自 192.168.1.0/24 网段的数据包源地址转换为网关的公网 IP 203.0.113.1
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to-source 203.0.113.1

# 多个公网 IP 做 SNAT（自动分配）
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to-source 203.0.113.1-203.0.113.10

# 指定端口范围
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -p tcp -j SNAT --to-source 203.0.113.1:10000-20000

7.3 MASQUERADE（地址伪装）

自动使用出站接口的 IP 地址作为源地址，适用于动态 IP（如拨号上网、DHCP）场景。

# 适用于外网 IP 不固定的场景
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE

# 带端口范围的伪装
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -p tcp -j MASQUERADE --to-ports 1024-65535

SNAT vs MASQUERADE：SNAT 性能更好，适用于固定公网 IP；MASQUERADE 适用于动态 IP，但性能略差（每次都需要查询接口 IP）。

7.4 DNAT（目标地址转换/端口转发）

将外部访问网关某个端口的数据包目标地址转发到内网指定主机。

场景 1：将外部 8080 端口转发到内网 Web 服务器

# 将访问网关 8080 端口的流量转发到内网 192.168.1.100 的 80 端口
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 8080 -j DNAT --to-destination 192.168.1.100:80

# 同时需要允许 FORWARD 链转发该流量
iptables -A FORWARD -i eth0 -o eth1 -p tcp --dport 80 -d 192.168.1.100 -j ACCEPT
iptables -A FORWARD -i eth1 -o eth0 -m state --state ESTABLISHED,RELATED -j ACCEPT

场景 2：将整个端口段转发

# 将外部 3000-4000 端口范围转发到内网主机对应端口
iptables -t nat -A PREROUTING -p tcp --dport 3000:4000 -j DNAT --to-destination 192.168.1.100

场景 3：负载均衡（简单轮询）

# 以概率方式将流量分配到不同的后端服务器
iptables -t nat -A PREROUTING -p tcp --dport 80 -m statistic --mode random --probability 0.5 -j DNAT --to-destination 192.168.1.101:80
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.1.102:80

7.5 完整的 NAT 网关示例

#!/bin/bash
# NAT 网关配置脚本
# eth0 = 外网接口（203.0.113.1）
# eth1 = 内网接口（192.168.1.1）

# 清空规则
iptables -F
iptables -t nat -F
iptables -X

# 开启 IP 转发
echo 1 > /proc/sys/net/ipv4/ip_forward

# 默认策略
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# 允许 loopback
iptables -A INPUT -i lo -j ACCEPT

# 允许已建立和相关连接
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许内网到外网的转发
iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

# NAT：内网通过网关上网
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to-source 203.0.113.1

# 端口转发：外网 8080 → 内网 192.168.1.100:80
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 8080 -j DNAT --to-destination 192.168.1.100:80
iptables -A FORWARD -i eth0 -o eth1 -p tcp -d 192.168.1.100 --dport 80 -j ACCEPT

# 允许 SSH 访问网关本身
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

echo "NAT 网关配置完成"

八、规则备份与恢复

iptables 规则默认保存在内存中，重启后会丢失。以下是持久化方案。

8.1 手动备份与恢复

# 备份所有表的规则
iptables-save > /opt/data/iptables-backup.rules

# 备份指定表的规则
iptables-save -t nat > /opt/data/iptables-nat-backup.rules

# 以可读格式备份（带注释）
iptables-save -c > /opt/data/iptables-backup-with-counters.rules

# 恢复规则
iptables-restore < /opt/data/iptables-backup.rules

# 恢复时清空现有规则再导入
iptables-restore -c < /opt/data/iptables-backup.rules

8.2 备份文件格式示例

# 查看备份文件内容
cat /opt/data/iptables-backup.rules

输出类似：

# Generated by iptables-save v1.8.9
*filter
:INPUT DROP [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -i lo -j ACCEPT
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j ACCEPT
COMMIT
# Completed
*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE
COMMIT
# Completed

8.3 使用发行版工具持久化

Debian / Ubuntu：

# 安装持久化工具
apt install iptables-persistent

# 保存当前规则
netfilter-persistent save

# 加载规则
netfilter-persistent reload

# 规则文件位置
cat /etc/iptables/rules.v4 # IPv4
cat /etc/iptables/rules.v6 # IPv6

CentOS / RHEL / Fedora：

# CentOS 7 及之前
service iptables save
# 规则保存到 /etc/sysconfig/iptables

# 或手动保存
iptables-save > /etc/sysconfig/iptables

# 开机自动加载
systemctl enable iptables

8.4 使用脚本管理规则

#!/bin/bash
# /opt/data/iptables-setup.sh — iptables 规则管理脚本

IPTABLES_SAVE="/opt/data/iptables-backup.rules"

case "$1" in
 save)
 echo "备份 iptables 规则..."
 iptables-save > "$IPTABLES_SAVE"
 echo "已保存到 $IPTABLES_SAVE"
 ;;
 restore)
 echo "恢复 iptables 规则..."
 iptables-restore < "$IPTABLES_SAVE"
 echo "规则已恢复"
 ;;
 show)
 echo "当前 iptables 规则："
 iptables -L -v -n --line-numbers
 echo ""
 echo "NAT 规则："
 iptables -t nat -L -v -n --line-numbers
 ;;
 flush)
 echo "清空所有规则..."
 iptables -F
 iptables -t nat -F
 iptables -t mangle -F
 iptables -X
 iptables -P INPUT ACCEPT
 iptables -P FORWARD ACCEPT
 iptables -P OUTPUT ACCEPT
 echo "规则已清空"
 ;;
 *)
 echo "用法: $0 {save|restore|show|flush}"
 exit 1
 ;;
esac

九、实用综合示例

9.1 Web 服务器防火墙配置

#!/bin/bash
# Web 服务器安全防火墙规则

# 清空现有规则
iptables -F
iptables -X

# 默认策略：入站拒绝，出站允许
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# 允许 loopback 接口
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

# 允许已建立和相关连接
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许 SSH（限制来源网段）
iptables -A INPUT -p tcp -s 10.0.0.0/8 --dport 22 -m state --state NEW -m limit --limit 3/minute --limit-burst 5 -j ACCEPT

# 允许 HTTP 和 HTTPS
iptables -A INPUT -p tcp -m multiport --dports 80,443 -m state --state NEW -j ACCEPT

# 允许 ICMP（ping）
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j ACCEPT

# 防 SYN Flood 攻击
iptables -A INPUT -p tcp --syn -m limit --limit 25/s --limit-burst 50 -j ACCEPT
iptables -A INPUT -p tcp --syn -j DROP

# 防端口扫描：标记并丢弃 XMAS 和 NULL 扫描
iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP # XMAS scan
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP # NULL scan
iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -j DROP

# 记录并丢弃其他所有流量
iptables -A INPUT -j LOG --log-prefix "IPT-INPUT-DROP: " --log-level 4 -m limit --limit 5/minute
iptables -A INPUT -j DROP

9.2 内网穿透（跳板机配置）

场景：通过公网跳板机（203.0.113.1）将 SSH 连接转发到内网服务器（192.168.1.100）。

#!/bin/bash
# 跳板机 iptables 配置

# 开启转发
echo 1 > /proc/sys/net/ipv4/ip_forward

# 外部通过 2222 端口访问跳板机，转发到内网 192.168.1.100 的 22 端口
iptables -t nat -A PREROUTING -p tcp --dport 2222 -j DNAT --to-destination 192.168.1.100:22

# 允许转发该流量
iptables -A FORWARD -p tcp -d 192.168.1.100 --dport 22 -m state --state NEW -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT

# SNAT 以便回程包能正确返回
iptables -t nat -A POSTROUTING -o eth1 -p tcp -d 192.168.1.100 --dport 22 -j SNAT --to-source 192.168.1.1

客户端连接：

ssh -p 2222 user@203.0.113.1 # 实际连接到内网 192.168.1.100

9.3 多服务端口转发

#!/bin/bash
# 将多个外部端口转发到不同的内网服务

# 开启转发
echo 1 > /proc/sys/net/ipv4/ip_forward

# SSH → 192.168.1.100:22
iptables -t nat -A PREROUTING -p tcp --dport 2222 -j DNAT --to-destination 192.168.1.100:22

# MySQL → 192.168.1.200:3306
iptables -t nat -A PREROUTING -p tcp --dport 3306 -j DNAT --to-destination 192.168.1.200:3306

# Redis → 192.168.1.200:6379（仅内网可访问）
iptables -t nat -A PREROUTING -s 10.0.0.0/8 -p tcp --dport 6379 -j DNAT --to-destination 192.168.1.200:6379

# Web HTTP → 192.168.1.100:80
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.1.100:80

# Web HTTPS → 192.168.1.100:443
iptables -t nat -A PREROUTING -p tcp --dport 443 -j DNAT --to-destination 192.168.1.100:443

# 允许转发
iptables -A FORWARD -i eth0 -o eth1 -j ACCEPT
iptables -A FORWARD -i eth1 -o eth0 -m state --state ESTABLISHED,RELATED -j ACCEPT

# SNAT
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE

9.4 Docker 容器 + iptables 注意事项

# Docker 默认会向 iptables 添加自己的规则链（DOCKER、DOCKER-ISOLATION 等）
# 查看 Docker 相关规则
iptables -L -n | grep -i docker
iptables -t nat -L -n | grep -i docker

# ⚠️ 不要使用 iptables -F 清空所有规则，否则会破坏 Docker 网络
# 正确做法：只操作自定义规则或使用自定义链

# 如果需要限制 Docker 容器的网络访问
# DOCKER-USER 链是在 Docker 自定义链之前执行的，适合添加自定义规则
iptables -I DOCKER-USER -i eth0 -p tcp --dport 3306 -j DROP

十、注意事项

10.1 避免 SSH 锁定

在远程服务器上配置 iptables 时，务必确保 SSH 端口规则在 DROP 策略之前添加：

# ❌ 错误顺序：先设置 DROP 策略，SSH 会断开
iptables -P INPUT DROP
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # 已经连不上了

# ✅ 正确顺序：先添加允许规则，再设置默认策略
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -P INPUT DROP

或者使用 cron 定时任务 作为安全网：

# 添加一个 5 分钟后自动恢复的安全措施
echo "sleep 300 && iptables -P INPUT ACCEPT && iptables -F" | at now

10.2 规则顺序很重要

# ❌ 规则顺序错误：先 DROP 了所有包，后面的 ACCEPT 永远不会生效
iptables -A INPUT -j DROP
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # 永远执行不到

# ✅ 正确顺序：先精确规则，后宽泛规则
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -j DROP

10.3 DROP vs REJECT 的选择

DROP：静默丢弃，安全性高，但客户端会等待超时。适合面向公网的防护。
REJECT：明确拒绝，客户端能立即收到错误。适合内网或调试场景。

# 公网服务器：对外部非法流量使用 DROP
iptables -A INPUT -p tcp --dport 3306 -j DROP

# 内网服务器：对内部服务使用 REJECT（方便排查问题）
iptables -A INPUT -s 192.168.1.0/24 -p tcp --dport 3306 -j REJECT --reject-with tcp-reset

10.4 保存规则！

# 每次修改规则后都要保存，否则重启后丢失！

# Debian/Ubuntu
netfilter-persistent save

# CentOS/RHEL
service iptables save

# 通用方法
iptables-save > /etc/iptables/rules.v4

10.5 不要盲目清空规则

# ⚠️ 在生产环境慎用！这会清空所有规则，包括 Docker、Kubernetes 等的规则
iptables -F

# 更安全的做法：只清空指定链或自定义规则
iptables -F INPUT
iptables -F FORWARD

# 或者先备份，再操作
iptables-save > /tmp/before-change.rules
iptables -F
# ... 添加新规则 ...
# 出问题时恢复
iptables-restore < /tmp/before-change.rules

10.6 调试技巧

# 查看数据包匹配情况（带计数器）
iptables -L -v -n
# 如果 pkts 和 bytes 都是 0，说明规则没有被匹配

# 用 LOG 规则跟踪数据包
iptables -I INPUT 1 -j LOG --log-prefix "IPT-DEBUG: "
# 查看日志
tail -f /var/log/kern.log | grep "IPT-DEBUG"

# 测试后删除 LOG 规则
iptables -D INPUT 1

# 模拟规则匹配（使用 iptables-apply，如果可用）
# 它会在超时后自动回滚，避免锁定
iptables-apply -t 60 /tmp/new-rules.txt

10.7 性能建议

将最常匹配的规则放在链的前面，减少遍历次数
使用 -m set + ipset 管理大量 IP 地址比逐条规则效率高得多
对于大量端口，使用 -m multiport 而不是写多条规则
NAT 规则在 nat 表中处理，不要放在 filter 表

# 使用 ipset 管理大量 IP
ipset create blacklist hash:net
ipset add blacklist 10.0.0.0/8
ipset add blacklist 172.16.0.0/12
iptables -A INPUT -m set --match-set blacklist src -j DROP

# 持久化 ipset
ipset save > /etc/ipset.conf
ipset restore < /etc/ipset.conf

速查：常用 iptables 命令汇总

# ===== 规则管理 =====
iptables -A INPUT ... # 追加规则
iptables -I INPUT 1 ... # 插入规则
iptables -D INPUT 1 # 删除规则
iptables -R INPUT 1 ... # 替换规则
iptables -F # 清空规则

# ===== 查看规则 =====
iptables -L -v -n --line-numbers # 查看详细规则（带序号）
iptables -S # 以命令格式输出规则
iptables -t nat -L -v -n # 查看 NAT 规则

# ===== 策略设置 =====
iptables -P INPUT DROP # 设置默认策略
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

# ===== 备份恢复 =====
iptables-save > rules.bak # 备份
iptables-restore < rules.bak # 恢复

# ===== 常见放行 =====
iptables -A INPUT -i lo -j ACCEPT # loopback
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # 已建立连接
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # SSH
iptables -A INPUT -p tcp -m multiport --dports 80,443 -j ACCEPT # Web
iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT # Ping

# ===== NAT 转发 =====
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE # 共享上网
iptables -t nat -A PREROUTING -p tcp --dport 8080 -j DNAT --to-destination 192.168.1.100:80 # 端口转发
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to-source 203.0.113.1 # SNAT

延伸阅读：在较新的 Linux 发行版中，nftables 是 iptables 的继任者，提供了更简洁的语法和更好的性能。但 iptables 仍然被广泛使用，掌握 iptables 是学习 nftables 的基础。如果系统已经迁移到 nftables，可以使用 iptables-translate 命令将 iptables 规则转换为 nftables 语法。

nftables 常用命令速查 — Flux Panel 转发规则排查指南

Wed, 24 Jun 2026 10:00:00 +0000

前言

在使用 Flux Panel 做流量转发时，节点服务器的防火墙规则由 flux-nftables 服务自动管理，底层使用的是 Linux 的 nftables。排查转发问题时，经常需要查看、筛选 nftables 规则。本文整理了最常用的 nftables 命令，方便日常运维快速定位问题。

1. Flux Panel 的 nftables 表名

Flux Panel 创建的 nftables 表名为：

inet flux_panel

所有自动下发的转发规则都在这张表里，后续命令都围绕它展开。

2. 查看规则

2.1 列出所有表

nft list tables

确认 inet flux_panel 是否存在。

2.2 查看整张表的规则

nft list table inet flux_panel

输出包含所有链（chain）和规则，内容较多时可以配合 grep 使用。

2.3 带 handle 编号查看

nft -a list table inet flux_panel

每条规则前会显示 # handle X，方便定位和删除指定规则。

2.4 只看某个链

# 入站 DNAT（端口转发目标）
nft list chain inet flux_panel prerouting

# 转发流量（上下行计数）
nft list chain inet flux_panel forward

# 出站伪装（SNAT / masquerade）
nft list chain inet flux_panel postrouting

3. 查看转发计数

nft list chain inet flux_panel forward

输出示例：

counter packets 10 bytes 1234 comment "fp:1:1:1:up"
counter packets 8 bytes 900 comment "fp:1:1:1:down"

comment 字段的格式为：

fp:转发ID:用户ID:用户隧道ID:方向

字段	含义
`转发ID`	Flux Panel 中的转发规则 ID
`用户ID`	所属用户 ID
`用户隧道ID`	用户下的隧道 ID
`方向`	`up` = 上行，`down` = 下行

通过 packets 和 bytes 可以判断流量是否正常通过。

4. 筛选规则

4.1 筛选所有 Flux Panel 转发规则

nft list table inet flux_panel | grep 'fp:'

4.2 查看某个转发 ID 的规则

例如转发 ID 为 1：

nft list table inet flux_panel | grep 'fp:1:'

可以快速确认某条转发是否已正确下发到节点。

5. 查看 DNAT 转发目标

nft list chain inet flux_panel prerouting

输出示例：

tcp dport 8080 dnat to 1.2.3.4:80

表示访问节点 8080 端口的流量会被转发到 1.2.3.4:80。排查"转发不通"时，先确认这里的目标 IP 和端口是否正确。

6. 查看出口伪装

nft list chain inet flux_panel postrouting

正常情况下会看到：

masquerade

表示出站流量会使用节点的 IP 进行 SNAT，保证回程流量能正确返回。

7. 检查服务状态与日志

如果规则没有正确下发，需要检查 flux-nftables 相关服务：

# 查看服务状态
systemctl status flux-nftables.service
systemctl status flux-nftables-agent.service

# 查看最近 100 行日志
journalctl -u flux-nftables.service -n 100 --no-pager
journalctl -u flux-nftables-agent.service -n 100 --no-pager

常见排查场景：

现象	检查方向
规则不存在	看 `flux-nftables.service` 日志是否报错
规则存在但不通	看 `prerouting` 的 DNAT 目标是否正确
流量无计数	看目标机器是否放行了对应端口
服务启动失败	检查 `nft` 命令是否安装、内核是否支持 nftables

8. 常用命令汇总

日常排查最常用的一组命令：

# 查看完整规则（带 handle）
nft -a list table inet flux_panel

# 查看转发计数
nft list chain inet flux_panel forward

# 查看 DNAT 转发目标
nft list chain inet flux_panel prerouting

# 查看服务日志
journalctl -u flux-nftables-agent.service -n 100 --no-pager

9. 注意事项

所有命令需要 root 权限 执行
不要手动修改 flux_panel 表的规则，Flux Panel 会自动管理，手动改的可能被覆盖
如果误操作导致规则丢失，重启 flux-nftables.service 即可重新下发
nftables 是 iptables 的替代方案，内核版本 >= 3.13 即支持，推荐 CentOS 8+ / Debian 10+ / Ubuntu 18.04+

免费SSL申请及Nginx反向代理配置教程

Tue, 11 Mar 2025 18:13:48 +0800

一、申请免费SSL证书

1. 从服务商申请（以阿里云为例）

步骤：
1. 登录阿里云控制台，搜索并进入SSL证书服务。
2. 选择免费型DV SSL证书，完成购买并提交申请（需验证域名所有权）。
3. 下载证书文件（通常包含.pem证书和.key私钥文件）。

2. 使用Let’s Encrypt（通用方法）

若需自动化申请，可使用Certbot工具：

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d 你的域名

（注：此方法需域名已解析到服务器且Nginx配置了对应域名的站点）

二、安装Nginx并确认SSL模块

安装Nginx：

sudo apt update && sudo apt install nginx

检查SSL模块：

nginx -V 2>&1 | grep -o with-http_ssl_module

若输出为空，需重新编译Nginx：

./configure --with-http_ssl_module
make && sudo make install

三、配置SSL证书

1. 上传证书文件

将下载的证书（如.pem和.key）上传至服务器，推荐存放路径：

sudo mkdir -p /etc/nginx/certs
# 将文件复制到该目录

2. 修改Nginx配置文件

编辑站点配置文件（如/etc/nginx/sites-available/your_site）：

# 反向代理核心配置（保存为 /etc/nginx/sites-available/your_domain.conf）
server {
 listen 80;
 server_name your-domain.com www.your-domain.com;
 return 301 https://&#36;server_name&#36;request_uri; # 强制HTTPS
}

server {
 listen 443 ssl http2;
 server_name your-domain.com www.your-domain.com;

 # SSL证书配置（根据实际路径修改）
 ssl_certificate /etc/nginx/certs/fullchain.pem;
 ssl_certificate_key /etc/nginx/certs/privkey.key;

 # SSL安全配置
 ssl_session_timeout 1d;
 ssl_session_cache shared:MozSSL:10m;
 ssl_protocols TLSv1.2 TLSv1.3;
 ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
 ssl_prefer_server_ciphers on;
 ssl_stapling on;
 ssl_stapling_verify on;

 # 反向代理核心配置
 location / {
 proxy_pass http://localhost:3000; # 修改为实际后端服务地址

 # 基础代理头设置
 proxy_set_header Host &#36;host;
 proxy_set_header X-Real-IP &#36;remote_addr;
 proxy_set_header X-Forwarded-For &#36;proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Proto &#36;scheme;

 # WebSocket支持（如需）
 proxy_http_version 1.1;
 proxy_set_header Upgrade &#36;http_upgrade;
 proxy_set_header Connection "upgrade";

 # 超时与缓冲优化
 proxy_connect_timeout 60s;
 proxy_send_timeout 60s;
 proxy_read_timeout 60s;
 proxy_buffers 8 16k;
 proxy_buffer_size 32k;
 }

 # 静态文件分离示例（可选）
 location /static/ {
 alias /var/www/static/;
 expires 30d;
 access_log off;
 }

 # 阻止敏感文件访问
 location ~* /(\.git|config|\.env) {
 deny all;
 return 403;
 }

 # 错误页面定制
 error_page 500 502 503 504 /50x.html;
 location = /50x.html {
 root /usr/share/nginx/html;
 }
}

注意：若证书包含中间证书，需合并到.pem文件中：

cat certificate.pem intermediate.pem > combined.pem

四、重启Nginx并测试

检查配置语法：
```
sudo nginx -t
```
重启服务：
```
sudo systemctl restart nginx
```
访问测试：
- 浏览器输入https://你的域名，确认证书有效性和站点加载。
- 使用SSL Labs测试工具检查安全性评分。

常见问题解决

Nginx报错unknown directive "ssl"
- 需重新编译Nginx并启用--with-http_ssl_module。
浏览器提示证书不受信任
- 检查证书链是否完整（需合并中间证书）。
- 确保证书文件路径权限正确（建议设为644）。
HTTPS无法访问
- 确认防火墙开放443端口：
```
sudo ufw allow 443
```

扩展：自签名证书（仅测试环境）

生成自签名证书：

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/nginx/certs/self.key -out /etc/nginx/certs/self.crt

配置方法与正式证书相同，但浏览器会提示不安全。

以上步骤综合了阿里云、Let’s Encrypt及自签名证书的配置方案，适用于生产与测试环境。如需更详细参数调整（如加密套件优化），可参考SSL/TLS最佳实践文档。

运维 on 吾爱主机

TLS 1.3 握手与证书链校验：原理、流程与工程排查

问题背景：TLS 到底在保护什么

核心原理：TLS 1.3 握手的三个阶段

完整握手消息流（1-RTT）

相对 TLS 1.2 的关键变化（工程相关）

0-RTT：快，但默认不适合“写操作”

证书链校验：从信任锚走到叶子

叶子身份：SAN 才是名字的主战场

CA 与路径长度：basicConstraints

服务端交付的链 vs 客户端验证出的链

实践：用 OpenSSL 复现握手与链问题

1）看协议版本、套件与服务端发送的证书

2）让校验错误真正失败（贴近生产客户端）

3）从 PEM 文件本地拆解链

4）Nginx 侧：链顺序与协议底线

常见坑与排查清单

总结

参考资料

Kubernetes 探针机制：Liveness / Readiness / Startup 原理与工程实践

一、问题背景：进程存活 ≠ 服务可用

二、三类探针：职责完全不同

1. Startup：给慢启动留窗口

2. Liveness：死锁与不可恢复故障的“硬重启”

3. Readiness：接不接流量，而不是杀不杀进程

三、四种检查机制

四、关键参数与默认值

五、可落地的组合配置

六、常见坑与排查

七、选型速查

八、总结

参考资料

OceanBase 多平台搭建教程：Linux / Windows / macOS / Docker 从零到可连接

一、先选对安装路径

资源底线（很重要）

二、通用概念：端口、租户、客户端

三、最快路径：Docker（Linux / Windows / macOS 通用）

1. 前置条件

2. 启动实例

3. 等待 bootstrap 完成

4. 连接验证

5. 常用运维命令

6. 初始化 SQL（可选）

四、Linux 原生：all-in-one + OBD（官方推荐体验路径）

1. 一键安装 all-in-one

2. 一键拉起演示实例

3. 单独安装 OBD（CentOS/RHEL 系）

4. obd demo 前自检清单

五、Windows 搭建

方案 A：Docker Desktop（最简单）

方案 B：WSL2 + Linux 路径

六、macOS 搭建

1. 安装 Docker Desktop for Mac

2. 启动 OceanBase

3. 连接

4. macOS 特别提醒

七、进阶：Kubernetes 与多节点

1. Kubernetes：ob-operator

2. OBD 自定义集群

八、连接后的最小验收清单

九、常见问题排查

1. 容器一直起不来 / 没有 boot success!

2. 2881 端口冲突

3. Docker Hub 拉取失败

4. 能进容器但不能从宿主机连接

5. obd demo 预检失败

十、平台选型建议（实战版）

十一、精简命令速查

Docker（全平台）

Linux all-in-one

OBD RPM（CentOS/RHEL）

总结

参考资料

Linux cgroup v2 内存控制与 OOM Killer：原理、观测与容器化实践

一、先建立两层模型：全局 OOM vs cgroup OOM

二、cgroup v2 的内存阶梯：min / low / high / max

1. 为什么要有 high，而不是只设 max？

2. min/low 保护不是免费的

三、OOM Killer：它到底怎么选人

1. 评分：oom_score 与 oom_score_adj

4. `obd demo` 前自检清单

1. Kubernetes：`ob-operator`

1. 容器一直起不来 / 没有 `boot success!`

2. `2881` 端口冲突

5. `obd demo` 预检失败

1. 为什么要有 `high`，而不是只设 `max`？

2. `min`/`low` 保护不是免费的

1. 评分：`oom_score` 与 `oom_score_adj`

2. 系统级可调旋钮（`/proc/sys/vm/*`）

坑 2：limit 设太紧，没有 `high` 缓冲与观测

坑 3：把 `oom_score_adj=-1000` 到处贴

坑 4：`--oom-kill-disable` 却没有硬上限