Operations · XB 现场笔记

发布一个静态站点并证明边缘一致

Tue, 11 Aug 2026 00:00:00 +0000

一次发布，只有在所需公共边缘检查与选定产物一致时才算完成，而不是上传退出码为零就完成。本教程串起构建、校验、发布与验证，同时区分本地检查和部署变更。发布会改变服务器；结尾的探针才是只读网络观察。

命令假定使用 Bash、GNU find/sort/sha256sum、rsync、Python 3 与项目固定版本的 Hugo。构建步骤从仓库根运行。接触线上主机前，先在一次性目录演练目录切换示例。明确实际服务根、部署负责人、上一版目标与回滚过程。下面的 /srv 布局要求部署已配置完成，不是仓库会自动安装的东西。

指针切换改变失败边界：之前停止可保留旧版，之后需要显式回滚并重验。磁盘检查与边缘样本证明不同事实。

1. 从已记录输入构建一份产物

从干净源码版本开始，运行项目构建并记录已安装生成器版本：

set -eu
git status --short
git rev-parse HEAD
hugo version
make build

短状态为空可支持干净工作树的判断，但命令本身不会强制执行。在称其为某个提交的发布前，应检查所有变更。make build 将短提交号和当前 UTC 构建时间写入 data/buildinfo.toml，再生成 public/。页面中的标记说明记录了哪些输入，不能证明有未提交修改的工作树只含那个提交。

固定 Hugo 与 vendored 主题可减少漂移，但构建时间字段使不同时间的普通构建不一定逐字节相同。应构建选定发布一次、验证后传输这份准确产物，而不是在服务器另行重建。

2. 检查完整离线契约

make check 检查当前产物的生成视觉资源、离线包新鲜度、内部链接、无脚本输出、来源链接及下载校验和。完整仓库关卡则使用：

set -eu
make verify
make check-upstream

完整关卡还运行回归测试、双语文章检查和审阅清单新鲜度校验，再重新构建并检查输出。因此要在最后一次构建后才生成发布清单。构建成功及审阅记录未过期，不能证明每篇文章技术正确，也不证明公共服务器使用了预期头部。页数与耗时会变化，应保留实际输出，不与文章里复制来的计数作比较。

3. 用清单标识产物字节

计算哈希前，确认 public/ 只包含目录与常规文件，并停止所有写入，直到暂存完成。下面的命令不会创建快照，也不会检查每种特殊文件类型。清单放在 public/ 外，避免把自身纳入哈希。NUL 分隔文件名可保留空格及其他 shell 敏感字符：

set -euo pipefail
manifest="$(pwd)/release.sha256"
(
 cd public
 find . -type f -print0 | LC_ALL=C sort -z | xargs -0 sha256sum
) > "$manifest"
(cd public && sha256sum -c "$manifest")
sha256sum "$manifest"

GNU 校验行的摘要在文件名前。sha256sum -c 成功说明已列出的文件匹配，不证明没有额外文件。全新的空发布目录可避免目标端残留旧文件，但不能发现计算哈希后在源端新增的额外文件。要证明常规文件清单完整一致，应按相同路径、排序与哈希规则重算暂存清单，在选择指针前比较完整列表。另行检查符号链接：find -type f 不包含它们，而意外链接可能暴露预期根外的文件。将清单及其自身摘要留在发布记录中；校验和证明相对于清单的一致性，不能证明不可信清单的真实性。

4. 暂存并选择完整发布

假定 Caddy 已服务 /srv/www/example-site/current，它是指向 releases/ 内部的符号链接，所有权与读取权限正确。releases 父目录须事先存在。发布者必须串行执行，并选择唯一发布 ID。把此块作为独立 Bash 脚本，在部署机器上包含已验证 public/ 与 release.sha256 的目录中运行。运行前按部署策略检查产物的所有权与读取权限。此块自行设置清单路径和遇错停止策略；前置条件、复制或校验和失败时，必须在选择指针前停止。它拒绝暂存产物内的符号链接；这是会修改部署的步骤。

set -euo pipefail
base=/srv/www/example-site
manifest="$(pwd)/release.sha256"
test -f "$manifest"
test -d public
release_id=20261015T120000Z
release="$base/releases/$release_id"
test -L "$base/current"
previous=$(readlink "$base/current")
mkdir "$release" # Fail if this release already exists.
rsync -a public/ "$release/"
(cd "$release" && sha256sum -c "$manifest")
links=$(find "$release" -type l -print -quit)
if [ -n "$links" ]; then
 echo "Refusing symlinks in the staged artifact" >&2
 exit 1
fi
# Ownership and readable permissions must match the deployment policy.
python3 - "$base" "$release_id" <<'PYTHON'
from pathlib import Path
import os, sys, uuid
base = Path(sys.argv[1])
release = base / "releases" / sys.argv[2]
current = base / "current"
if not current.is_symlink() or not release.is_dir():
 raise SystemExit("Expected current symlink and a complete release directory")
pending = base / (".current-" + uuid.uuid4().hex)
pending.symlink_to(os.path.relpath(release, base), target_is_directory=True)
os.replace(pending, current)
print("selected:", os.readlink(current))
PYTHON
printf 'Previous target: %s\n' "$previous"

临时链接与 current 共用父目录，因此替换通过同文件系统的一次 rename 完成。普通 mv new existing-directory 不会交换两个非空目录。不要用此片段转换已有的真实目录服务根，应单独规划迁移。在预发布环境验证真实服务器的根解析及文件系统行为。

旧目标仍在磁盘上，不等于切换后旧资源 URL 仍可访问。应在新服务命名空间或稳定资源库中保留旧版指纹资源字节。浏览器多个请求可能跨越两个发布，缓存也可能持有旧 HTML。原子命名空间替换不是跨请求快照隔离，也不是断电持久性保证。

5. 验证实际交付字节与策略

切换后，用固定表示选择比较公共响应样本与相应产物文件：

set -euo pipefail
url=https://www.xbcatm.com/
status=$(curl -sS --max-time 20 -H 'Accept-Encoding: identity' \
 -D served.headers -o served.html -w '%{http_code}' "$url")
test "$status" = 200
cmp public/index.html served.html
sh public/downloads/check-http-headers.sh "$url"

从暂存时使用的同一产物目录运行此块。头部辅助脚本使用该可信产物内的副本；此步骤无需源码工作树。cmp 成功证明这个首页样本逐字节匹配。遇到意外重定向、返回 200 的代理错误页、CDN 转换或编码响应时，需要调查。检查 served.headers 中的 Content-Encoding、缓存年龄、CSP 与内容类型。头部脚本打印响应及最终状态，不会强制所有预期条件。

对中文内容、嵌套文章、CSS、SVG、下载项、重定向及错误路由重复适用检查。记录 URL 到文件的映射，包括目录索引。示例的逐项校验只证明所列文件的一致性，不证明暂存清单完整，也不证明所有公共缓存节点的交付结果。完整边缘论断需要更广泛抓取和表示感知检查；少数探针始终只是样本。

切换后的检查失败时，新版仍被选中，直到你采取行动。用新临时链接指向已记录的 previous 值，再次原子替换 current，随后重做探针。不要只移走新树，诊断期间也不要删除证据或上一版。

6. 分别检查 TLS 身份和到期窗口

从仓库根运行到期辅助脚本：

sh static/downloads/check-tls-expiry.sh www.xbcatm.com 30

它提取证书、打印日期、检查剩余到期间隔，却不是完整 TLS 身份测试：当前实现没有让主机名或信任验证失败成为致命错误。应按照公共边缘信任教程执行显式验证握手与 SAN 检查。不能从“至少还有 30 天有效期”推断信任链或吊销检查成功。

临近过期是另一项发布风险。保留实际 notAfter、信任结果与客户端环境，不要把历史签发者或日期复制到发布日志。

7. DNS 变化时纳入缓存窗口

纯内容发布不一定改变 DNS。若主机或边缘变化，应在缓存过期期间继续维护旧目标服务。变更时才降低 TTL，不会缩短已经按旧 TTL 缓存的条目。解析器 serve-stale、负缓存和客户端缓存会让窗口更复杂；TTL 不是保证所有客户端都完成迁移的统一截止点。CAA 变化影响签发策略，不负责把流量路由到新内容。

8. 保留演练过的恢复路径

上一版目录有利于快速回滚，但不是独立备份。磁盘故障、误清理或部署账户被攻破，都可能影响所有本地发布。应保留源码、构建输入、配置及适当的独立产物备份，并在隔离环境演练恢复。一次成功演练证明的是那个时刻的那条恢复路径，不会永久保证之后的变更。

9. 精确记录结果

保留源码版本与干净工作树状态、构建元数据和工具版本、清单摘要、选中与上一版目标、探针时间、HTTP/TLS 观察及任何回滚。说明覆盖的是样本、全部映射 URL，还是多个观测点。关卡失败时，应记录失败与恢复过程，而不是“它工作过”。

切换前失败可以让旧版保持不变；切换后恢复则是需要单独验证的显式操作。区分这两点，才能让发布路径可审计，而不假装每次失败都会自动恢复旧树。

来源

rsync 手册，归档复制与源路径尾斜线语义，已核验 2026-10-15。
RFC 8767：Serving Stale Data，TTL 过期后的 DNS serve-stale 行为，已核验 2026-10-15。
GNU sha256sum 手册，Debian 软件包，校验和输出及验证选项，已核验 2026-10-15。
Python os.replace，原子替换与文件系统限制，已核验 2026-10-15。
Caddy file_server，根与符号链接处理，已核验 2026-10-15。
curl 手册，状态捕获、响应头及内容解码，已核验 2026-10-15。
OpenSSL s_client，显式证书验证，已核验 2026-10-15。
Reproducible Builds：定义，产物身份与可复现性的区别，已核验 2026-10-15。

像客户端一样读取活动边缘

Fri, 07 Aug 2026 00:00:00 +0000

HTTP 基础篇的每条笔记各取一纸契约并展示单独的证据。本教程则按顺序走完一次客户端请求触达的完整路径，只用只读命令。目标是区分协议要求与某个服务器的选择，而不是要求所有端点都返回相同状态和头部。

我们全程用 www.xbcatm.com。把它换成你要检查的主机。请求使用 HTTP 安全方法，但仍可能产生访问日志或消耗速率额度。只检查你有权查询的端点。下面输出块是示意，不是当前生产测量。请在一次性工作目录运行 shell 片段，保留错误，并记录时间和客户端版本。

保持所选表示一致，并在各自契约内解读观察结果。本图未查询活动边缘。

1. 先确定方法可以问什么

在读响应体之前，先确定服务器允许你问什么。静态处理器通常支持 GET 和 HEAD，代理也可能实现 OPTIONS。先询问边缘对目标资源的处理：

$ curl -sS --max-time 20 -D - -o /dev/null -w 'OPTIONS -> HTTP %{http_code}\n' -X OPTIONS https://www.xbcatm.com/
HTTP/2 405
allow: GET, HEAD

OPTIONS -> HTTP 405

若服务器识别 OPTIONS、但该资源不支持它，405 Method Not Allowed 是合法答案，且 405 必须携带 Allow。成功的 200 或 204 OPTIONS 响应也可能正确。501 表示服务器未实现该方法。一次 OPTIONS 不能证明其他方法的行为。不要为了测试拒绝而向不熟悉的线上服务发送 POST：它不是安全方法，单有 200 也不能描述其副作用。

2. 读取表示行

第一行告诉你协商出来的交换；头部随后告诉你将要到达的是什么字节。像客户端看到的那样捕获它们、丢弃响应体：

$ curl -sS --max-time 20 -D - -o /dev/null https://www.xbcatm.com/
HTTP/2 200
accept-ranges: bytes
content-length: 15890
content-security-policy: default-src 'self'; base-uri 'self'; form-action 'none'; frame-ancestors 'none'; object-src 'none'; script-src 'none'; style-src 'self'; img-src 'self' data:
content-type: text/html; charset=utf-8
etag: "dkx84jwth7nkc9e"
last-modified: Mon, 24 Aug 2026 13:55:23 GMT
strict-transport-security: max-age=31536000; includeSubDomains
x-content-type-options: nosniff

三个头部值得停下来。content-type: text/html; charset=utf-8 命中了媒体类型，content-type-and-nosniff 说明为什么它必须描述你真正发送的字节。etag: "dkx84jwth7nkc9e" 交给你强验证器。x-content-type-options: nosniff 限制浏览器的 MIME 处理，尤其是脚本与样式表抓取；它不会验证正文确实是 HTML。每一个都是证据而不是装饰，合在一起是说：该响应声明了应与正文及预期策略比较的元数据。语法上为强 ETag 的值仍是服务器的声明，不是独立的内容哈希证明。

3. 对同一表示比较 HEAD 与 GET

HEAD 使用 GET 的语义，但不带响应正文。服务器应返回相同头部，不过可以省略只有生成内容时才能确定的字段。Content-Length 可省略；若在 HEAD 中发送，它必须等于相应 GET 会发送的内容大小。应在内容稳定时使用相同编码及其他选择头比较：

$ curl -sSI --max-time 20 -H 'Accept-Encoding: identity' https://www.xbcatm.com/ | grep -i content-length
content-length: 15890
$ curl -sS --max-time 20 -H 'Accept-Encoding: identity' https://www.xbcatm.com/ | wc -c
15890

两者一致：都是 15890。这就是 head-request-parity 契约。仅缺少 HEAD 长度不是协议违规。长度不符需要调查，也要排除两次请求之间发生发布、或选中不同表示的可能。没有 pipefail 的 shell 中，传给 wc 的管道可能隐藏 curl 失败；自动关卡应先确认 curl 成功保存正文，再统计文件字节。

4. 用范围请求精确的字节

因为源站知道自己的表示，它可以只服务其中一部分。范围请求要求一个字节区间，只得到那个区间：

$ curl -sS --max-time 20 -D - -o /dev/null -H 'Accept-Encoding: identity' -H 'Range: bytes=0-99' -w 'HTTP %{http_code} bytes=%{size_download}\n' https://www.xbcatm.com/
HTTP/2 206
content-range: bytes 0-99/15890
content-length: 100

HTTP 206 bytes=100

对于至少 100 字节的表示，成功的单范围响应应有 206、匹配的 Content-Range: bytes 0-99/…，以及 100 个内容字节。服务器可合法忽略 Range 并返回完整 200，这不说明它缺少校验器。无法满足的范围可能返回 416。普通 Range 请求不要求 ETag；使用 If-Range 恢复特定表示，或安全拼接部分响应时，才要遵守相关强校验器规则。范围针对所选编码后的字节，因此这里显式选择 identity。

5. 用验证器让缓存重新验证

现在把方法、表示与字节选择通过缓存结合。新鲜的已存响应可能无需检查校验器就可复用。测试重新验证时，应抓取当前响应，并用相同表示选择重放其实际 ETag，不要复制文章里的旧标签：

set -eu
url=https://www.xbcatm.com/
work=$(mktemp -d)
status=$(curl -sS --max-time 20 -H 'Accept-Encoding: identity' \
 -D "$work/headers" -o "$work/body" -w '%{http_code}' "$url")
test "$status" = 200
etag=$(awk 'tolower($1)=="etag:" {sub(/\r$/, ""); sub(/^[^:]*:[ \t]*/, ""); print; exit}' "$work/headers")
test -n "$etag" || { echo 'No ETag: inspect Last-Modified instead' >&2; exit 1; }
curl -sS --max-time 20 -H 'Accept-Encoding: identity' \
 -H "If-None-Match: $etag" -D - -o /dev/null \
 -w 'HTTP %{http_code}\n' "$url"

把此片段作为独立 shell 脚本运行。只有初次传输完整成功且状态为 200，才有可用的已存响应；错误表示也可能有 ETag。若所选表示仍匹配且正常处理成功，预期得到 304，并用更新后的元数据复用这份完整正文。表示变化时，200 完全可能是正确结果。检查结果期间保留临时目录，完成后仅删除此处生成的目录。If-None-Match 使用弱比较，所以 304 不一定证明字节完全一致。新鲜度寿命与当前年龄决定能否直接复用；校验器回答的是另一问题，本身不设定寿命。

6. 协商更小的表示

同样的内容在客户端表明能解压时可以传递更少字节。请求 gzip 并观察正文缩水而语义不变：

$ curl -sS --max-time 20 -H 'Accept-Encoding: identity' -o /dev/null -w 'no-enc: %{size_download} bytes\n' https://www.xbcatm.com/
$ curl -sS --max-time 20 -o /dev/null -H 'Accept-Encoding: gzip' -w 'gzip: %{size_download} bytes\n' https://www.xbcatm.com/
no-enc: 15890 bytes
gzip: 4368 bytes

示例大小展示一种可能的缩减；服务器也可以选择 identity。这是 http-compression-negotiation 笔记的核心：改变选中的表示会改变线上字节，元数据（content-length、encoding）也随之改变。请求压缩的客户端与存储编码形式的缓存必须就选了哪种表示达成一致，否则缓存可能交付不匹配结果。除字节数外，还应检查 Content-Encoding 与 Vary: Accept-Encoding。手工设置 Accept-Encoding 不会让 curl 自动解压；--compressed 才会请求受支持编码并解码响应。应比较解码后的正文来确认内容相同，也不要假定不同编码共用同一个强 ETag。

7. 跟随 URL 变化时的故事

身份变化时，响应应说明故事在哪里继续，而不去猜正文：

$ curl -sS --max-time 20 -o /dev/null -w '%{http_code} -> %{redirect_url}\n' -I http://www.xbcatm.com/ | head -1
308 -> https://www.xbcatm.com/

308 Permanent Redirect 保持方法与故事，正是 redirects-and-status-codes 关心的。无论是永久移动的 301/308，还是由站点处理的 404，状态行都是故事的第一句，应在读正文前先读。

8. 最后让爬虫读地图

边缘也会被根本不请求 HTML 的机器读取。发现机制回答两个不同的问题，robots-and-sitemaps 有说明。确认发现机制指向真实 sitemap：

$ curl -sS --max-time 20 https://www.xbcatm.com/robots.txt
User-agent: *
Disallow:
Sitemap: https://www.xbcatm.com/sitemap.xml

也应抓取 sitemap URL，核对规范主机名与语言 URL。robots.txt 是爬虫指引，不是访问控制；被列入 sitemap 不保证抓取或索引。

所有检查一览

检查	应检查什么	笔记
`OPTIONS` 状态 + Allow	对该资源观察到的方法策略	http-method-semantics
`content-type` + 正文 + `nosniff`	声明的类型与 MIME 处理策略	content-type-and-nosniff
HEAD/GET 元数据	对应表示，允许规定的字段省略	head-parity
Range + Content-Range	观察到的部分传输支持	http-range-requests
抓取的 `ETag` -> 304	条件表示匹配	conditional-requests
308 保留方法	重定向保留故事	redirects-and-status-codes
robots -> sitemap	发现答案不同	robots-and-sitemaps

每一行原来是一条笔记；现在是你可对任意边缘运行的命令。需要细节时读链接的笔记，把这个表留作再次检查时的速查。

来源

WHATWG Fetch Standard，nosniff 处理与请求目标，已核验 2026-10-15。
RFC 9110 — HTTP Semantics，方法、验证器与状态码，已核验 2026-10-15。
RFC 9111 — HTTP Caching，新鲜度与重新验证，已核验 2026-10-15。
RFC 7538 — 308 Permanent Redirect，保留方法的重定向，已核验 2026-10-15。
curl 手册，只读检查选项，已核验 2026-10-15。

维护定时器应让其最近结果可见

Tue, 04 Aug 2026 00:00:00 +0000

cron 式语法并不是维护任务契约的全部。命令需要一个清晰的服务身份、一个有界的运行时间，以及能区分"未调度"与"运行但失败"的证据。一个 systemd 定时器与 oneshot 服务能把这些关注点分开。

定时器触发只证明发生了调度事件。用服务结果、退出状态和新的时间戳判断本次运行。

把工作定义成服务

使用显式用户与绝对命令路径：

# /etc/systemd/system/site-check.service
[Unit]
Description=Read-only public site check

[Service]
Type=oneshot
User=sitecheck
ExecStart=/usr/local/bin/check-public-site
TimeoutStartSec=2min

TimeoutStartSec 限制 oneshot 的激活过程，其中包括命令运行时间；oneshot 默认没有启动超时。超时处理之后还可能需要停止超时，且不能立即结束不可中断的内核 I/O，因此工具本身也需要有界的网络请求。当契约失败时，helper 应返回非零退出码，并且不得修改它所检查的服务。

调度该服务

# /etc/systemd/system/site-check.timer
[Unit]
Description=每小时运行公共站点检查

[Timer]
OnCalendar=hourly
Persistent=true
RandomizedDelaySec=5min
Unit=site-check.service

[Install]
WantedBy=timers.target

若至少错过一次日历事件，Persistent=true 会在定时器重新激活时触发一次补跑；它不会逐小时重放所有错过的运行。补跑仍受随机延迟限制。RandomizedDelaySec 把一个窗口内的例行工作分散开；当任务必须在精确时刻运行时它并不合适。

启用前先验证

创建两个单元文件后，先验证并重载管理器，再手动启动服务。这些是在目标测试主机上的管理操作，不是只读检查：

systemd-analyze verify /etc/systemd/system/site-check.service \
 /etc/systemd/system/site-check.timer
systemd-analyze calendar hourly
systemctl daemon-reload
systemctl start site-check.service
systemctl status site-check.service
journalctl -u site-check.service -n 50 --no-pager
systemctl show site-check.service -p Result -p ExecMainCode -p ExecMainStatus

只有当服务在预期的用户、环境、路径与网络访问下成功时才启用定时器：

systemctl enable --now site-check.timer
systemctl list-timers site-check.timer

对服务结果告警

定时器触发并不等于成功。要监控 oneshot 服务的退出状态或日志结果。保持 stdout 简洁，调试需要的详细制品写入一个有界的路径。

成功的 oneshot 通常回到 inactive (dead)；这本身不是失败，systemctl status 对非活动服务可能返回非零。应将 Result、退出状态与新的日志时间戳对应，避免把旧运行的成功误认成本次结果。不要为了显示绿色而添加 RemainAfterExit=yes：服务仍处于活动状态时，重复定时器不会启动一个新实例。日历时间默认使用主机时区，而且常规定时器精度会在随机延迟之外增加调度余量。

来源

systemd.timer(5)，日历定时器、持久化与延迟行为，已核验 2026-08-04。
systemd.time(7)，日历表达式语法，已核验 2026-08-04。
systemd.service，oneshot 服务语义，已核验 2026-08-04。
systemd.service upstream manual (v257)，Type=exec/oneshot、就绪、激活超时与重启语义，已核验 2026-10-15。
systemd.timer upstream manual (v257)，持久化会合并错过的运行；活动单元、随机延迟与精度，已核验 2026-10-15。

重启策略需要一个速率限制

Mon, 03 Aug 2026 00:00:00 +0000

对长驻服务来说，自动重启很有用，但无界的循环会把一个清晰的失败变成一个嘈杂的失败。单元文件应同时描述正常进程生命周期与可接受的恢复量。

按配置窗口统计启动次数。启动速率限制可以停止快速反复重启，但不能证明健康，也不限制生命周期重试总数。

捕获启动失败

对长驻进程，Type=exec 能在启动时暴露配置程序执行失败，而不是把一次 fork 当成功。把它与显式的 ExecStart 以及能完成工作所需最小权限的 User 搭配使用。

[Unit]
Description=Example foreground site service
StartLimitIntervalSec=60s
StartLimitBurst=5

[Service]
Type=exec
User=site
ExecStart=/srv/site/bin/server
Restart=on-failure
RestartSec=5s

Type=exec 确认程序已执行，并不确认应用已就绪。程序应保持前台运行；应用支持显式就绪通知时可用 Type=notify。Restart=on-failure 是恢复策略，不是健康检查。如果进程在提供错误响应的同时保持存活，systemd 不会知道站点坏了；外部冒烟测试仍有其职责。

限制循环

Systemd 通过 StartLimitIntervalSec= 与 StartLimitBurst= 应用启动速率限制。这两个指令放在 [Unit]，RestartSec 放在 [Service]。示例允许 60 秒内启动五次；快速失败之间只有五秒重启延迟，因此可能达到限制。更长延迟可能让循环一直低于该速率：这并不是整个生命周期的重试次数预算。应按预期故障模式选择限制。当达到限制时，日志里应包含区分"重启成功"与"重复失败后放弃"所需的证据。

在获准使用的测试主机上安装或修改单元后，先验证文件、重载管理器并检查有效配置，再重启。下列命令会改变服务状态，可能中断流量：

systemd-analyze verify /etc/systemd/system/example.service
systemctl daemon-reload
systemctl cat example.service
systemctl show example.service -p Restart -p RestartUSec \
 -p StartLimitIntervalUSec -p StartLimitBurst
systemctl restart example.service
systemctl status --no-pager example.service
journalctl -u example.service -n 80 --no-pager

不要用重启策略掩盖缺失文件、无效权限或糟糕的环境。先修复第一次失败，再测试恢复路径。

启动限制停止自动重启后，单纯等到间隔结束不会自动排定下一次尝试。修复原因后，可等待间隔结束再启动，或有意识地用 systemctl reset-failed example.service 清除计数器后启动。在隔离服务中测试可执行文件缺失与快速崩溃，并保存第一次失败日志，不要只留下最后的“达到启动限制”消息。

来源

systemd.service，服务类型、重启与启动速率限制器，已核验 2026-08-03。
systemd.unit，通用单元段与 drop-in 语义，已核验 2026-08-03。
systemd.service upstream manual (v257)，Type=exec/oneshot、就绪、激活超时与重启语义，已核验 2026-10-15。
systemd.unit upstream manual (v257)，启动限制所属配置段、速率窗口与 reset-failed 行为，已核验 2026-10-15。

SSH 主机密钥是部署记录的一部分

Tue, 28 Jul 2026 00:00:00 +0000

在公钥认证中，客户端证明自己持有私钥，但它并不告诉客户端到达的是哪台服务器。服务器的主机密钥与本地 known_hosts 数据库，提供身份检查的后一半。

SSH 服务器身份依赖观察到的主机密钥与独立可信参考之间的比较。严格检查拒绝未知或变化的密钥。首次使用时信任与网络密钥扫描，都不能独立认证首次接触的服务器。

把首次接触与轮换分开

在 StrictHostKeyChecking=yes 下，SSH 拒绝未知主机与变化的密钥。对于一个固定生产端点，只要期望密钥通过可信渠道安装，这就是最安全的默认值。accept-new 是面向预期会出现新主机的、更窄的方便选项：它接受一个从未见过的密钥，但仍拒绝被更改的密钥。

Host production-site
HostName www.example.test
User deploy
IdentityFile ~/.ssh/site_ed25519
StrictHostKeyChecking yes
UserKnownHostsFile ~/.ssh/known_hosts

不要通过给部署脚本加 StrictHostKeyChecking=no 来"修复"警告。它会在客户端限制条件下允许连接到密钥已变化的主机；警告可能仍被打印，但原本遇到身份问题就拒绝的检查已被削弱。如果主机被重建，请记录替换后的指纹，并复核旧密钥为何不再有效。

让指纹可复核

在首次连接之前，从主机所有者或控制台获取指纹，再与客户端看到的值比较。密钥变更应有工单、维护说明或其他他人可检视的解释。

同一规则适用于自动化：known-hosts 文件是带有安全后果的配置，不是可丢弃的缓存数据。把它与部署记录一起备份，但不要把私钥或复制的凭据随站点制品一起公开。

accept-new 是首次使用时信任，并不能独立证明第一次连接的服务器真实可信。ssh-keyscan 能采集候选公钥，但通过同一条不可信网络取回它，并不能认证它。安装前先将指纹与独立可信渠道取得的值比较。

把上面的配置单独保存为 deploy.conf，在不连接服务器的情况下检查有效配置：

ssh -G -F ./deploy.conf production-site | \
 grep -E '^(hostname|user|stricthostkeychecking|userknownhostsfile) '

结果应显示配置中的主机、用户、known-hosts 路径与严格检查（客户端输出可能为 true 或 yes）。这只解析配置，并不测试真实握手。非标准端口的 known-hosts 条目通常采用 [hostname]:port。将主机公钥指纹保存在私有运维发布记录中，不要随公共网站发布；即使主机公钥不是秘密，主机名也可能暴露内部拓扑。

来源

OpenBSD ssh_config，StrictHostKeyChecking 与 UserKnownHostsFile，已核验 2026-07-28。
OpenSSH ssh-keygen 手册，指纹检视，已核验 2026-07-28。
OpenSSH ssh-keyscan，未经核验采集的密钥不能防止中间人攻击，已核验 2026-10-15。
OpenSSH ssh，-G 不建立会话，打印求值后的客户端配置，已核验 2026-10-15。

小系统的优势

Mon, 27 Jul 2026 00:00:00 +0000

小不等于未完成。它意味着每个组件职责清晰、依赖经过斟酌，并且从请求到结果之间始终可见。

明确每个请求边界、相关证据与负责人。组件更少只会减少需要理解的路径；恢复承诺仍靠备份与恢复演练支撑。

可见性是一种特性

当运维人员能说出每个边界时，他们也能指出缺少哪份证据。日志变得更有用，告警更具体，例行维护风险更低。

对静态网站而言，重要的边界通常很容易列出：

DNS 把主机名指向预期的边缘。
TLS 在预期的代理处终结。
代理只服务一个已知的输出目录。
输出只包含站点需要的文件。
404 响应由站点本身处理，而不是意外的上游。

把这些写下来，比加上一块回答不了任何上述问题的仪表盘更有价值。

复杂性要用实力取得位置

当新的一层消除的不确定性多于它引入的，它才值得。缓存重要时，给资源加指纹的构建步骤会有用；内容需要事务时，数据库才有用。但对一个小而多为静态的站点，这两者都不必然是改进。

对客户端 JavaScript 也适用同一规则。如果页面确实需要客户端脚本，应选择满足需求的最小实现，并有意识地审查内容安全策略。对本站而言，这首先需要重新评估已接受的零脚本架构及其验证契约，并不是当前策略的例外。如果页面是一份文档，纯 HTML 往往更容易检视、更有韧性。

让所有权明确

每个文件都应有存在的理由与明确的更新方式。vendored 主题应记录其上游版本与许可。生成目录应标记为生成物。资源下载应说明它包含什么、何时更新、校验和如何产生。

这些简短声明能防止未来的运维者把偶然产生的制品当作受支持的接口。

为下一次变更留出空间

最好的小系统不是行数最少的那个，而是下一次变更看得见去处的那一个。笔记站可以从 Markdown、静态生成器与一个 Web 服务器起步；如果以后需要搜索或评论，可以独立评估这个新需求，而不是一开始就假设它存在。

规模小并不自动带来容错。一个边缘、磁盘或运维者仍可能成为单点故障。明确可接受的恢复时间与数据损失，保留独立备份并演练恢复。组件更少的好处是需要理解的故障路径更少，而不是不会停机。

来源

Hugo directory structure，内容与资源的目录约定，已核验 2026-07-27。
Caddy file_server 指令，设计中引用的静态文件服务默认值，已核验 2026-07-27。

robots.txt 与 sitemap 回答不同的问题

Tue, 21 Jul 2026 00:00:00 +0000

两个小文件常被当成安全边界使用，但它们不是。robots.txt 描述爬虫偏好，sitemap 则给搜索系统一份属于该站点的 URL 清单。

发现工具不会授予或拒绝访问。继续检查索引列出的每份 sitemap，验证不止 XML 语法，并按真实错误类别处理 robots 响应。

robots.txt 能做什么、不能做什么

规则发布于源站根路径 /robots.txt，由配合的爬虫读取。它不会保护私有目录、不会从网络上移除 URL，也不能替代认证。不应公开的路由需要服务器授权或网络边界。

让文件保持平实，并测试它的实际位置：

User-agent: *
Disallow:
Sitemap: https://www.example.test/sitemap.xml

文件应为 UTF-8。如果部署会重定向它，请核验你想要的爬虫行为，而不是假设每个客户端都遵循同一条链。

sitemap 增加了什么

sitemap 是一份清单，而不是权限列表。使用单一主机的绝对 URL、正确做 XML 转义，并且只列出你准备发布的规范页面。不要因为某个 URL 存在于构建目录就把它列出。

每份 sitemap 最多包含 50,000 个 URL，未压缩大小不超过 50 MB（52,428,800 字节）；gzip 不会提高该限制。小站可以不用 index，但多语言生成器也可以合理地生成指向各语言 sitemap 的索引。应检查根元素并继续检查列出的各份 sitemap，而不是假设 /sitemap.xml 一定是 URL 集合。把它的 XML 校验通过，并像普通页面一样通过同一 HTTPS 边缘请求它。

curl -fsS https://www.example.test/robots.txt
curl -fsS -o sitemap.xml https://www.example.test/sitemap.xml && \
 xmllint --noout sitemap.xml

把下载与解析分开，避免下载失败被解析成功掩盖。XML 格式正确只代表语法通过；还要验证命名空间、URL 数量、规范主机名，以及列出的页面是否存在。若未安装 xmllint，请在发布它的同一个 CI 环境里解析该 XML。重要的是检查要在文件被替换到边缘之前运行。

robots 的 Disallow 不是可靠的搜索索引删除指令。还要测试错误响应：RFC 9309 在 robots 返回 4xx、表示文件不可用时允许抓取，而网络或服务器错误在最初要求全部禁止。意外返回状态为 200 的 HTML 兜底页，因此可能改变爬虫行为，即使 URL 看起来仍然可访问。

来源

RFC 9309 — Robots Exclusion Protocol，robots 规则、文件位置与 user-agent 匹配，已核验 2026-07-21。
Sitemaps Protocol，sitemap XML 结构与发现，已核验 2026-07-21。

可靠的默认行为胜过聪明的恢复

Mon, 20 Jul 2026 00:00:00 +0000

小服务往往在正常路径被充分理解之前，就先累积了恢复逻辑。每一次重试、备用端点与兼容分支，都增加了必须被观察和测试的一个状态。

让常见路径可见。先判断并限制重试，再恢复到保留的已知良好状态，避免选择半成品副本。

让常见路径变得无聊

一个有用的默认行为是明确的、易于检视的、且可安全重复的。对静态站点，可以简单到：

构建自固定的工具链。
检查生成的 HTML、资源与完整的待发布目录。
发布该目录，再把公共响应与它核对。
保留上一个目录以便回滚。

这段序列不如多阶段部署系统炫目，但它的状态可见。当某处失败时，运维者能回答：问题在源码、构建、复制还是 Web 服务器。

只对可限定范围的操作重试

当故障可能是瞬时的、且重复操作不会改变其预期效果时，重试才有用。幂等不等于每次响应或附带日志都相同；响应丢失后，第一次尝试可能早已成功。从源站下载可能可安全重试；数据库迁移则未必。把每个错误都看作可重试的，会掩盖需要关注的边界。

当重试适当时，记录尝试次数与最终原因。类似"发布失败：校验和不匹配"的日志条目，比一串静默重试后跟一个笼统超时更有可操作性。

偏好单一权威状态

配置、运行时状态与文档应一致地说明哪个目录是活动的、哪条命令产生它。如果一个发布可以被不同的人复制到三条不同路径，恢复就变成了猜谜。

对静态部署，一份简短的发布记录就够了：

release: 2026-07-20
source: git commit <commit-id>
builder: Hugo 0.165.0
output: public/
verification: links + headers + checksums

占位符 commit ID 应按设计在发布时解析，而不是在文档里杜撰。

恢复应回到已知状态

当恢复把服务带回最后一个已知良好目录，而不是在几个半成品替代品之间选择时，恢复最容易。保留上一次输出直到新输出通过检查，再按保留策略移除旧副本。

目标不是消除失败，而是把失败缩小到能解释、把恢复缩小到能信任。

同时限制重试次数与总耗时。多个客户端可能一起重试时，使用带随机抖动的退避，并避免每一层都重试。权限错误与确定性的无效输入需要修正，而不是更长的重试循环。

来源

RFC 9110 — HTTP Semantics，9.2.2 节关于幂等方法与重试，已核验 2026-07-20。
静态网站发布检查清单，本地配套资源。
AWS Builders’ Library: Timeouts, retries, and backoff with jitter，重试放大、有界重试预算、退避与随机抖动，已核验 2026-10-15。

重定向与错误码应保留故事的完整性

Tue, 14 Jul 2026 00:00:00 +0000

HTTP 状态码是接口的一部分。浏览器可能渲染出一个友好的页面，但监控、爬虫、缓存与 API 客户端也需要状态码与响应头来讲述同一个故事。

有意选择迁移或缺失语义。保留所需方法，解析 Location，考虑缓存，并让错误页状态与事实一致。

永久移动并不都等价

308 Permanent Redirect 在保留请求方法的同时，传达资源有了新的永久 URI。这对发送 POST、PUT 或其他非 GET 方法的客户端很重要。旧页面到新页面的重定向用 GET 很容易测试；端点的迁移则必须用真实调用方实际使用的方法来测试。

curl -sS -D - -o /dev/null https://old.example.test/api/item

不带 --location 时，curl 不会跟随重定向。相对原 URI 解析 Location：绝对 URI、根相对路径或其他相对引用都可能有效。检查解析后的主机、路径与协议。301/302 允许将 POST 改为 GET；307/308 保留方法。改变状态的方法只能在隔离端点测试。308 可以启发式缓存，但仍受方法与缓存控制限制，因此缓存的迁移结果可能在服务器配置变化后继续存在。

如果目的是在完成操作后展示结果，303 See Other 会指向客户端可用 GET 或 HEAD 获取的另一资源。它不是要求客户端在新地址重放原来的写入操作；应有意选择这种行为，而不是把所有重定向都当作迁移。

区分"缺失"与"被移除"

当服务器找不到当前表示且缺失可能是暂时或未知时，使用 404 Not Found。410 Gone 更强：它表示资源已不可访问，且这种情况很可能是永久的；它并不能说明资源消失的原因。两者都应有帮助人类的正文，但都不应因为自定义错误页成功渲染就返回 200。

404 也可以用于隐藏某个禁止访问的资源是否存在。404 与 410 都可以启发式缓存，但仍受方法与缓存控制约束。应为错误响应明确选择缓存策略：路由修复后，已缓存的缺失结果仍可能继续显示。

这条检查应放在边缘：

curl -sS -D missing.headers -o missing.html -w '%{http_code} %{url_effective}\n' \
 https://www.example.test/a-route-that-does-not-exist

在错误路径上也应保留安全响应头。安全头、有用的内容类型与正确的状态码，比一个装饰性的错误动画更有价值。

来源

RFC 9110 — HTTP Semantics，第 15 与 13 节，已核验 2026-07-14。
RFC 7538 — 308 Permanent Redirect，第 3 节，已核验 2026-07-14。
curl manual，状态与重定向检查标志，已核验 2026-07-14。

用两条命令读取公共边缘

Mon, 13 Jul 2026 00:00:00 +0000

部署完成意味着公共响应符合发布契约，而不是最后一条上传命令退出码为零。操作套件里的两个只读工具能提供有用证据，但不能证明整个制品都已正确发布。

这些片段仅为示意。分别判断 HTTP 状态与到期结果；主机名、信任与正文一致性需要对应的独立检查。

检查响应头

check-http-headers.sh 发出 GET、丢弃正文、跟随重定向，打印每一跳的响应头以及最终状态和 URL：

check-http-headers.sh https://www.xbcatm.com/

以下输出只演示要检查的字段，并非刚刚采集的生产观察结果：

HTTP/2 200
accept-ranges: bytes
content-security-policy: default-src 'self'; base-uri 'self'; form-action 'none'; frame-ancestors 'none'; object-src 'none'; script-src 'none'; style-src 'self'; img-src 'self' data:
content-type: text/html; charset=utf-8
last-modified: Mon, 24 Aug 2026 11:20:54 GMT
permissions-policy: accelerometer=(), camera=(), geolocation=(), gyroscope=(), microphone=(), payment=(), usb=()
referrer-policy: strict-origin-when-cross-origin
strict-transport-security: max-age=31536000; includeSubDomains
x-content-type-options: nosniff
x-frame-options: DENY

HTTP_STATUS 200
FINAL_URL https://www.xbcatm.com/

核对预期状态、最终主机与路径，以及最终响应上的策略。工具没有使用 curl 的 --fail：HTTP 404 或 500 仍可能使 shell 命令成功结束。必须判断它打印的状态。响应头不一致需要调查服务器、代理或缓存配置；单凭这种不一致，不能证明活动输出目录选错了。

检查证书日期

check-tls-expiry.sh HOST [DAYS] 提取使用 SNI 时服务器呈现的证书，并检查距离到期是否至少还有指定天数对应的秒数：

check-tls-expiry.sh www.xbcatm.com 30

下面是省略了指纹行的示意片段：

subject=CN=www.xbcatm.com
issuer=C=US, O=Let's Encrypt, CN=YE1
notBefore=Aug 21 08:37:13 2026 GMT
notAfter=Nov 19 08:37:12 2026 GMT

certificate remains valid for at least 30 day(s)

工具打印主体、签发者、日期与 SHA-256 指纹，不打印剩余天数。成功消息只描述到期检查：脚本没有强制验证主机名或信任链，-checkend 也不验证 notBefore。主体 CN 不足以证明主机身份；服务身份应与证书的主体备用名称匹配。有效的通配符也可能合法覆盖该主机。

需要验证这些属性时，另行运行：

openssl s_client -connect www.xbcatm.com:443 -servername www.xbcatm.com \
 -verify_hostname www.xbcatm.com -verify_return_error </dev/null

这使用已配置的信任库，并在 OpenSSL 匹配规则下的证书验证出错时失败。在 OpenSSL 3.0 中，没有合适的 DNS 主题备用名称时，主机名验证可能回退到主题 CN。因此，命令成功本身不能证明符合 RFC 9525 仅使用 SAN 的身份策略：还要检查 SAN 扩展，并单独验证目标客户端的策略。TLS 工具本身没有网络截止时间，应在任务层设置超时。证书检查与自动续期配置仍是两项独立检查。

在发布前后使用两者

发布前：保存预期策略、最终 URL、验证器与证书日期，并注明 UTC 采集时间。
部署已经验证的制品。
发布后：重复探测，并下载代表性正文与该制品比较。

响应头与证书日期不能证明字节一致。Last-Modified 可能不变，也可能在复制中被重写。发布冒烟测试保存正文并直接比较；完整清单可将检查扩展到单个页面之外。浏览器行为、不同地区边缘的差异，以及只在负载下出现的故障，需要另行测试。记录实际检查过的路径与观察点。

来源

curl manual，GET、重定向、响应头输出与 HTTP 失败行为，已核验 2026-10-15。
OpenSSL s_client，SNI、显式主机名检查与验证错误时失败，已核验 2026-10-15。
OpenSSL verification options，主机名匹配与主题 CN 回退，已核验 2026-10-15。
OpenSSL x509，证书显示与只检查到期的 -checkend 行为，已核验 2026-10-15。
RFC 9525 — Service Identity in TLS，主体备用名称与通配符身份匹配，已核验 2026-10-15。
Caddy Automatic HTTPS，自动证书管理与续期配置，已核验 2026-10-15。
MDN: Content Security Policy guide，所示策略的背景说明，已核验 2026-07-13。
RFC 9110 — HTTP Semantics，响应元数据与验证器不能证明完整制品匹配，已核验 2026-10-15。

事故复盘应留下一份事实记录

Tue, 07 Jul 2026 00:00:00 +0000

一份复盘在它的说法能被重新检查时才赢得信任。记录每项观察的来源、采集时间与时区、命令或查询，以及适用时的退出状态。日志、指标与明确注明来源的人工观察也属于证据；把已确认事实与假设分开，保存脱敏后的证据，不要保存秘密。下面的四个阶段让任何写下来的复盘在日后都可复核。

每个阶段都要连接真实证据。修复后的采样成功仍是有范围的观察；原因、不确定项和有负责人的预防动作仍需明确记录。

检测：症状，而且要带证据

从最小的可验证症状与展示它的命令开始。保存真实采集结果。以下只是格式示例，并不代表刚刚执行过探测：

$ check-http-headers.sh https://www.xbcatm.com/
HTTP/2 200
content-security-policy: ... script-src 'none' ...
last-modified: Mon, 24 Aug 2026 11:20:54 GMT

如果症状是某个响应头变了，那么展示旧策略与新策略的输出应并排放在一起。如果是失败，请包含退出状态与错误行。

界定范围：影响多广，以及你如何知道

用证据而不是形容词陈述影响范围。先界定能够检视的边界：

哪些主机与路径出现症状？记录每次探测的 URL 与观察时间；一次成功请求不能代表所有边缘或访问者的状态。
缓存与源站是否不同？使用相同请求头，比较两条路径的实际响应、缓存元数据与验证器。Vary 描述选择输入，不能证明响应来自缓存。
什么因素拖延恢复？DNS 变更需记录旧 TTL 与解析器观察结果；HTTP 缓存需另记新鲜度与重新验证策略。DNS TTL 不是通用的回滚期限。

修复：变更及其预期效果

记录实际配置差异与部署标识，让修复动作可理解，并在安全时可重放。下面的响应头片段是预期观察结果，不是 shell 命令，也不是完整策略。优先选择恢复契约的最小变更，并说明修复后运行应显示什么：

Content-Security-Policy: script-src 'none'

验证：事后运行

变更后重复检测命令，并演示观察到的输出现在与预期契约一致。没有最后这一节的复盘只是一个故事；有了它，它就是一份允许自己未来被再检查的记录。

最后记录促成事故的因素、仍不确定的事项，以及带负责人、到期日和验收检查的预防动作。一次探测成功只确认该时刻的采样路径；它本身不能确定原因，也不能防止复发。

来源

RFC 9110 — HTTP Semantics，响应元数据与条件请求，已核验 2026-07-07。
制品 HTTP 响应头检查，贯穿本记录使用的只读检查。
Google SRE: Postmortem Culture，影响、促成因素、证据复核与预防动作，已核验 2026-10-15。
RFC 9111 — HTTP Caching，缓存选择与新鲜度不同于 DNS 缓存寿命，已核验 2026-10-15。

用实际拒绝结果验证 systemd 服务边界

Sat, 27 Jun 2026 00:00:00 +0000

服务加固应该把一种明确不需要的操作变为被拒绝的操作，同时保留应用必须完成的工作。systemd 为文件系统视图、命名空间、权限和其他资源提供执行设置，但这些是边界各不相同的独立控制。添加四条熟悉的指令，并不意味着所有可读文件、可接触进程、继承的文件描述符或允许的系统调用都会消失。判断依据应是配置的真实语义与进程的实际行为。

坏掉的样子

ProtectSystem=strict 让服务挂载命名空间内的大部分文件系统层级变为只读。只读不代表不可读取，而且该设置有文档明确的例外，例如还需要单独控制的接口文件系统。服务仍然可能泄露它能够读取的信息，也仍然可以破坏可写目录中的数据。因此应该先使用专用服务身份，列清必要访问，再选择对应限制，而不是把一个只读开关当成覆盖所有资源的隔离墙。

PrivateTmp=yes 给服务提供私有临时目录。如果应用原本依赖另一个服务通过普通 /tmp 交换文件，这项设置可能直接打断协作。PrivateNetwork=yes 创建拥有独立回环接口的网络命名空间，因此宿主回环上的监听器不再是里面的同一个端点。需要直接连接数据库或公共接口的程序，若没有有意安排所需连接，就不适合直接套用这一设置。应先查真实调用路径，不能假定网络隔离不会影响正常功能。

NoNewPrivileges=yes 阻止执行程序时通过设置用户身份的二进制文件、文件能力等机制取得新的特权，并不删除进程已经拥有的权限。同样，单独写一条 IPAddressAllow，不意味着其他地址全部被拒绝：地址过滤有允许与拒绝的优先关系，还依赖内核功能支持。选项名称不是完整安全策略，每项控制都需要按其契约理解，尤其不能把未验证的限制写成已经成立的保证。

不同 systemd 控制拒绝选定操作，同时保留受管理状态与临时写入。

快速验证

这个实验要求一次性 Linux 系统中的 root 身份、作为 PID 1 的 systemd、可用的挂载与网络命名空间、位于 /usr/bin/python3 的 Python 3.8 或更新版本，以及用户管理工具。保持 Python 断言启用；生成的 worker 必须能被服务账号读取。早期记录报告 Debian 12、systemd 252.39；这里没有复现该次运行。脚本创建唯一命名的账号、运行时单元、状态目录与文件。前后两阶段使用同一个非 root 工作负载：

from pathlib import Path
from tempfile import mkdtemp
import grp,json,os,pwd,socket,subprocess,sys,uuid

def cleanup_steps(steps, primary):
 failures=[]
 for label, action in steps:
 try:action()
 except BaseException as error:
 failures.append(label+': '+type(error).__name__+': '+str(error))
 if failures:
 message='cleanup incomplete or uncertain: '+'; '.join(failures)
 try:print(message,file=sys.stderr)
 except (OSError,ValueError):pass
 if primary is None:raise RuntimeError(message)
 return failures

def remove_file(path):
 try:path.unlink()
 except FileNotFoundError:pass

def require_empty(value):
 if value:raise RuntimeError('residual resources: '+str(value))

suffix=uuid.uuid4().hex[:12];name='xbcatm-hardening-'+suffix
unit=name+'.service';unit_path=Path('/run/systemd/system')/unit
state=Path('/var/lib')/name;marker=Path('/tmp')/(name+'-marker');scratch=Path('/tmp')/(name+'-scratch')
assert os.geteuid()==0,'requires an explicitly prepared disposable systemd test system'
for path in [unit_path,state,marker,scratch]:assert not os.path.lexists(path),path
def account_exists():
 try:pwd.getpwnam(name);return True
 except KeyError:return False
def group_exists():
 try:grp.getgrnam(name);return True
 except KeyError:return False
assert not account_exists() and not group_exists()
def command(args):
 result=subprocess.run(args,capture_output=True,text=True,timeout=10)
 assert result.returncode==0,(args,result.stderr)
 return result.stdout.strip()
def ctl(*args):return command(['systemctl',*args])
def delete_account():
 if account_exists():command(['userdel',name])
def delete_group():
 if group_exists():command(['groupdel',name])
root=None;listener=connection=None;owned_files=[];account_attempted=False;unit_attempted=False
# Reserve each ordinary file exclusively and record it before writing or chmod.
def create_file(path,text,mode):
 with path.open('x') as output:
 owned_files.append(path)
 output.write(text)
 path.chmod(mode)
print('fixture:',name,'unit:',unit_path,'state:',state,'marker:',marker,'scratch:',scratch,flush=True)
try:
 root=Path(mkdtemp(prefix=name+'-',dir='/run'));root.chmod(0o755)
 outside=root/'outside';create_file(outside,'initial\n',0o666)
 create_file(marker,'host namespace marker\n',0o644)
 create_file(scratch,'',0o666)
 listener=socket.socket();listener.settimeout(2)
 listener.bind(('127.0.0.1',0));listener.listen(2)
 worker=root/'worker.py'
 create_file(worker,r"""from pathlib import Path
import json,socket,sys
root=Path(__file__).parent;state=Path(sys.argv[1]);marker=Path(sys.argv[2]);scratch=Path(sys.argv[3]);port=int(sys.argv[4]);phase=sys.argv[5]
result={}
try:
 with (root/'outside').open('a') as output:output.write(phase+'\n')
 result['outside_write']=True
except OSError as error:result['outside_write']=False;result['outside_errno']=error.errno
result['host_tmp_visible']=marker.exists()
scratch.write_text(phase);result['tmp_write']=scratch.read_text()==phase
try:
 with socket.create_connection(('127.0.0.1',port),timeout=0.5):pass
 result['network_connect']=True
except OSError as error:result['network_connect']=False;result['network_errno']=error.errno
status=dict(line.split(':',1) for line in Path('/proc/self/status').read_text().splitlines() if ':' in line)
result['no_new_privs']=status['NoNewPrivs'].strip()
(state/'result.json').write_text(json.dumps(result))
""",0o644)
 definition=f'''[Service]
Type=oneshot
User={name}
Group={name}
StateDirectory={name}
StateDirectoryMode=0700
TimeoutStartSec=5s
TimeoutStopSec=5s
KillMode=control-group
ExecStart=/usr/bin/python3 {worker} {state} {marker} {scratch} {listener.getsockname()[1]} PHASE
'''
 account_attempted=True
 command(['useradd','--system','--no-create-home','--user-group','--shell','/usr/sbin/nologin',name])
 create_file(unit_path,definition.replace('PHASE','baseline'),0o644)
 unit_attempted=True
 ctl('daemon-reload');ctl('start',unit)
 baseline=json.loads((state/'result.json').read_text())
 assert baseline=={'outside_write':True,'host_tmp_visible':True,'tmp_write':True,'network_connect':True,'no_new_privs':'0'},baseline
 connection,_=listener.accept()
 connection.close();connection=None
 original=outside.read_text()
 settings='ProtectSystem=strict\nPrivateTmp=yes\nPrivateNetwork=yes\nNoNewPrivileges=yes\n'
 unit_path.write_text(definition.replace('PHASE','hardened')+settings)
 command(['systemd-analyze','verify',str(unit_path)])
 ctl('daemon-reload');ctl('start',unit)
 hardened=json.loads((state/'result.json').read_text())
 assert hardened['outside_write'] is False and hardened['outside_errno']==30,hardened
 assert hardened['host_tmp_visible'] is False and hardened['tmp_write'] is True
 assert hardened['network_connect'] is False and hardened['network_errno']==111,hardened
 assert hardened['no_new_privs']=='1'
 assert outside.read_text()==original and scratch.read_text()=='baseline'
 print('baseline: outside write, host tmp visibility, loopback connection permitted; NoNewPrivs=0')
 print('hardened: outside write=EROFS; host tmp hidden; host listener refused; NoNewPrivs=1')
 print('managed state directory and private temporary writes still succeed')
finally:
 primary=sys.exc_info()[1];failures=[];quiescent=not unit_attempted
 # A failed stop does not skip the independently attempted state query or socket close.
 def attempt(label,action):
 try:return action()
 except BaseException as error:
 failures.append(label+': '+type(error).__name__+': '+str(error))
 if unit_attempted:
 attempt('stop '+unit,lambda:ctl('stop',unit))
 status=attempt('unit state',lambda:ctl('show',unit,'-p','ActiveState','-p','MainPID','-p','ControlPID'))
 if status is not None:
 properties=dict(line.split('=',1) for line in status.splitlines() if '=' in line)
 quiescent=properties.get('ActiveState') in ('inactive','failed') and properties.get('MainPID')=='0' and properties.get('ControlPID')=='0'
 if connection is not None:attempt('accepted socket close',connection.close)
 if listener is not None:attempt('listener close',listener.close)
 if quiescent:
 if unit_attempted:
 attempt('reset failed state',lambda:ctl('reset-failed',unit))
 for path in reversed(owned_files):attempt('file '+str(path),lambda path=path:remove_file(path))
 if unit_attempted:attempt('daemon reload',lambda:ctl('daemon-reload'))
 if unit_attempted and os.path.lexists(state):
 if state.is_symlink():failures.append('unexpected state symlink; retained '+str(state))
 else:
 attempt('state result',lambda:remove_file(state/'result.json'))
 attempt('state directory',state.rmdir)
 if account_attempted:
 attempt('account '+name,delete_account)
 attempt('group '+name,delete_group)
 if root is not None:attempt('temporary directory '+str(root),root.rmdir)
 for path in owned_files+([state] if unit_attempted else [])+([root] if root is not None else []):
 attempt('absence '+str(path),lambda path=path:require_empty(str(path) if os.path.lexists(path) else ''))
 if account_attempted:
 attempt('account absence',lambda:require_empty(name if account_exists() else ''))
 attempt('group absence',lambda:require_empty(name if group_exists() else ''))
 else:
 failures.append('unit may still run; retain its unit, account/group, state and files for manual recovery: '+name)
 if failures:
 message='cleanup incomplete or uncertain: '+'; '.join(failures)
 try:print(message,file=sys.stderr)
 except (OSError,ValueError):pass
 if primary is None:raise RuntimeError(message)

修订后的夹具尚未运行，只能使用独占控制的一次性系统；root 身份或容器标记不证明隔离。准备前建立保护，预检 scratch、账号和组，排他创建文件，并把 worker 与目录权限设为 0644/0755；ACL 仍须核验。管理命令设十秒超时，单元启动及停止限五秒，接受连接限两秒。停止失败不会跳过状态检查或套接字关闭；服务状态不明时保留文件与账号，供人工恢复。其余删除及残留检查独立尝试；错误不替换最初异常，只有清理失败时也会失败。超时操作稳定后须检查打印出的名称。进程创建、文件系统或 NSS 停滞与突然终止仍不受时限约束。

基线阶段故意让该账号能够写入一个样本文件，同时在管理器看到的临时目录里创建标记，并在其回环接口启动监听器。尚未加限制时，工作进程能够追加文件、看到标记、连接监听器，且读取到零值的 NoNewPrivs 标志。这一步排除了普通文件权限本来就禁止写入、或者监听器根本不存在等混淆因素，之后的拒绝才有明确对照。

加固阶段加入四项执行设置，然后重复同样的探测。外部样本文件写入以 EROFS 失败，因此不是仅仅因为文件所有者不匹配而失败。原来的临时标记在新视图中不可见，连接原监听端点得到 ECONNREFUSED，而进程报告 NoNewPrivs=1。这些证据来自实际工作进程，不是只检查单元解析器是否认识几个配置名字；每个结果都对应本次改变的具体边界。

必要的写入仍然成功：StateDirectory 创建服务使用的受管理可写状态位置，私有临时目录也允许写入自己的样本文件。从管理器命名空间观察，同名临时文件仍保留基线阶段的内容，说明第二次写入发生在另一份临时目录视图中。外部样本文件同样保持此前内容，进一步确认失败操作没有悄悄改变目标文件。

脚本断言这些精确结果，并在启动前验证修改后的单元定义。它没有测试漏洞利用、系统调用过滤或基于 BPF 的地址策略。因此本实验是在配置检查之外，补上所展示几项控制的运行时证据，而不是声称所有可能的访问路径都已经被封闭。部署时如果增加其他控制，应为那些控制寻找对应的行为验证，不能借用本例结果替代。

让必要访问保持明确

限制应施加在真实部署的服务定义上，同时考虑覆盖文件和执行身份。可写路径例外改变的是挂载视图，不会授予普通 Unix 文件权限，也不能让底层本来只读的文件系统变成可写。若状态、缓存或运行时目录的生命周期和所有权契约适合应用，优先使用对应的受管理目录，减少手工建目录造成的权限和清理差异。

加固之后，应按应用实际支持的能力检查启动、正常请求、维护、重载与停止。一个命令刚运行一次成功，仍可能在稍后轮转文件或建立新连接时失败。应定位具体被拒绝的操作，调整真正必要的边界，并保留“服务完成有用工作”与“不需要的操作仍被阻止”两类检查。这样配置才能说明当前已验证的限制，而不是一份看似严格却与工作负载脱节的开关清单。

来源

systemd 252 执行环境，挂载命名空间、受管理目录、私有网络与权限控制，已核验 2026-09-12。
systemd 252 资源控制，IP 允许与拒绝规则的优先关系和实现条件，已核验 2026-09-12。
systemd 252 分析命令，单元验证及其范围，已核验 2026-09-12。

DNS 变更需要一个感知缓存的回滚窗口

Thu, 18 Jun 2026 00:00:00 +0000

改一条地址记录很容易，预测每个解析器何时停止使用旧应答却很难。生存时间（TTL）值随 DNS 响应传播，控制通常情况下的缓存新鲜度。在迁移那一刻降低 TTL，并不能改写更早被缓存下来的应答。

TTL 随每个应答传播。切换前做好准备，让两侧持续有效，并结合旧端点流量与余量决定下线和回滚。

在事件前降低 TTL

如果既有记录是一天的 TTL，至少要在计划切换前一个旧 TTL 时就把它降低。这样在权威记录仍指向旧端点时，缓存有时间去取较短的值。确切间隔应写进变更计划，而不是在迁移中即兴执行。

单独记录权威服务器的应答。下面两条探针比较系统配置的解析器与公共递归解析器，并不天然属于权威查询：

dig +noall +answer www.example.test A
dig @1.1.1.1 +noall +answer www.example.test A

要取得权威证据，应向该区域实际的名称服务器发起非递归查询，并检查 AA 标志、状态、答案与权威部分。递归解析器的剩余 TTL 反映其当前缓存状态，不同解析器可以合理地不同。还应检查服务使用的 AAAA 与 CNAME 链，不能只检查 A。

让两侧都保持有效

切换期间，保持旧端点与新端点都能为预期主机名提供服务。TLS 名称、重定向与应用配置在两侧必须一致。权威记录改变后立刻移除旧端点，会给仍持有先前应答的客户端造成本可避免的停机。

否定应答也会被缓存。一个最近返回 NXDOMAIN 的名字，其出现可能很慢才可见，因为根据区域的权威数据，否定响应可能仍留在递归缓存里。

观察后恢复 TTL

一旦权威与具有代表性的递归应答都指向新端点，且旧缓存窗口已过，就恢复正常 TTL。在变更记录中保留旧值、新值、权威应答与回滚条件。

TTL 不是所有客户端统一的下线期限。解析器在解析失败时可能提供过期数据，长连接与应用缓存也可能超过 DNS 新鲜期。应观察旧端点流量并预留余量；把 DNS 改回去同样有缓存窗口。对否定应答，应检查由 SOA 决定的否定 TTL，不能假设新 A 记录的 TTL 适用。

来源

RFC 1034 — Domain Names: Concepts and Facilities，缓存模型，已核验 2026-10-15。
RFC 1035 — Domain Names: Implementation and Specification，TTL 字段，已核验 2026-10-15。
RFC 2308 — Negative Caching of DNS Queries，否定缓存模型与保留的错误 TTL，已核验 2026-10-15。
RFC 8767 — 提供过期数据，DNS 解析失败时提供过期应答，已核验 2026-10-15。
BIND 9 dig 手册，服务器选择与递归控制，已核验 2026-10-15。

DNS 迁移应提前降低 TTL，并保留回滚缓存窗口

Thu, 18 Jun 2026 00:00:00 +0000

DNS TTL 表示一条资源记录通常可以在缓存中保留多久，之后需要刷新。修改权威记录会改变未来回答，却不会向所有曾经存储该数据的解析器发送失效通知。因此，一次迁移既包含权威更新，也包含一段客户端可能合法发现不同地址的时期。规划服务可用性时，需要同时考虑新答案和仍然存在的旧答案，而不是只看控制台保存成功。

图示表达事件先后，并非等比例时间轴。缓存可能保留不同代际；应用缓存和已有连接还有各自的生命周期。

坏掉的样子

在修改地址的同一时刻降低 TTL，并不会缩短此前缓存回答的寿命。保存了旧长 TTL 的解析器尚未获知新短 TTL。此时立即移除旧服务，可能让那些客户端失败，即使所有权威查询都已返回新地址。问题来自服务重叠期与尚未消失的发现状态不匹配；反复检查权威端的新值正确，并不能解决使用旧缓存的客户端请求。

回滚也具有同样的不对称性。把区域改回去，不会从已经学到新地址的缓存里撤回该地址。短暂正常的新目的地，可能在回滚命令完成后继续收到请求。应让回滚目标与刚发布过的目标在相关重叠期内都可用，或者明确客户端访问任何一个时如何获得可接受结果。DNS 回滚不是立即停止新地址流量的开关。

也不要把每层缓存的原始 TTL 简单相加，作为传播时间。普通转发缓存返回剩余寿命，下游再对收到的值继续计时；不同解析器群体则可能在不同时间填充缓存。应用自有缓存、长连接、权威同步延迟以及配置的陈旧回答策略，还会让单个 TTL 无法成为端到端完成保证。应把这些行为分别调查，不能用一个“传播中”笼统覆盖。

快速验证

将脚本保存为 check-dns-move.py，准备 Docker 后执行 python3 check-dns-move.py。固定环境以 BIND 9.18.49 为权威，以 dnsmasq 2.90 为一个转发缓存，二者运行在隔离容器回环接口上。程序只修改自己的临时区域，每次递增序列号并确认权威重载完成，再观察缓存。整个过程不改变公共 DNS，也不调整系统时间：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
def record(address,ttl):return f'move {ttl} IN A {address}'
with lab(record('127.0.0.2',8)) as (_,update,cache,queries):
 cache();before=queries('move.lab.test');started=time.monotonic();initial=query('move.lab.test.',port=1054)
 wait(lambda: queries('move.lab.test')==before+1)
 assert values(initial)==['127.0.0.2'] and initial.answer[0].ttl==8
 update(record('127.0.0.2',3));lowered=query('move.lab.test.');cached_after_lower=query('move.lab.test.',port=1054)
 assert lowered.answer[0].ttl==3 and cached_after_lower.answer[0].ttl>3
 update(record('127.0.0.3',3));new_authority=query('move.lab.test.');old_cache=query('move.lab.test.',port=1054)
 assert values(new_authority)==['127.0.0.3'] and values(old_cache)==['127.0.0.2']
 time.sleep(3.3);after_new_ttl=query('move.lab.test.',port=1054)
 assert values(after_new_ttl)==['127.0.0.2']
 observations=[]
 def changed():
 answer=query('move.lab.test.',port=1054);observations.append(show(answer));return values(answer)==['127.0.0.3']
 wait(changed,timeout=8);migration_delay=round(time.monotonic()-started,3)
 update(record('127.0.0.2',3));rollback_authority=query('move.lab.test.');rollback_cache=query('move.lab.test.',port=1054)
 assert values(rollback_authority)==['127.0.0.2'] and values(rollback_cache)==['127.0.0.3']
 wait(lambda: values(query('move.lab.test.',port=1054))==['127.0.0.2'],timeout=6)
 print(json.dumps({'initial':show(initial),'lowered_authority':show(lowered),'cache_after_lower':show(cached_after_lower),
 'after_address_change':{'authority':show(new_authority),'cache':show(old_cache)},'after_new_TTL_elapsed':show(after_new_ttl),
 'new_address_observed_after_seconds':migration_delay,'rollback':{'authority':show(rollback_authority),'cache':show(rollback_cache)},
 'rollback_eventually_observed':True},sort_keys=True))
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

开始时，move.lab.test 指向 127.0.0.2，TTL 为八秒。经 dnsmasq 查询后存入该回答，权威日志确认发生一次上游查询。程序随后保持地址不变，把权威 TTL 改为三秒。直接查询看到三秒，先前填充的缓存却仍显示大于三秒的剩余 TTL。这说明修改源数据没有重写现有缓存状态，旧回答仍按照收到时的信息计时。

权威接着把地址改为 127.0.0.3，TTL 仍为三秒。直接查询立即看到新地址，缓存则继续返回 127.0.0.2。再等待三点三秒后，旧地址仍存在于缓存中。实验有意等待超过新配置 TTL 的时间，证明不能拿新数字作为更早那份回答的到期时间。只依据“已经等了新 TTL”就关闭旧端点，会忽略真实存在的旧寿命。

文章保留的历史实测约在首次填充后的七点三五秒返回 127.0.0.3。整数秒到期与进程调度影响观测间隔，因此不能把八秒配置当作跨环境的精密秒表。关键是现有副本持续超过新三秒窗口。随后脚本将权威回滚至 127.0.0.2，立即查询缓存仍得到 127.0.0.3；等这一代缓存过期后，才获得恢复的地址。前后两次对照说明，切换和回滚都会留下已有回答，而不是只有正向迁移需要等待。

在改变发现数据前准备服务重叠期

先在旧目的地仍健康时降低 TTL，确认相关权威服务器数据一致，再等待旧的较长缓存寿命耗尽后进行计划迁移。观察对服务重要的解析器和客户端群体。一次公共解析器查询只能采样一种视图，不能证明所有用户已持有相同记录。若权威副本尚未同步完成，等待起点也不能简单取最早一次编辑保存的时间。

切换时，通过真实主机名和所需协议验证新端点，并让旧端点在计划重叠期内继续服务或安全转发流量。地址发现、TLS 身份、应用状态与连接排空分别承担不同责任。DNS 变更不能修复新服务器缺失的证书，也不会把旧进程上已经建立的连接移动过去。验收应覆盖这些真实行为，而不是只有解析结果已经变化。

第一次测试成功后仍保留可用回滚窗口。记录新地址何时成为权威、使用何种 TTL，以及哪些端点必须继续存在。客户端仍访问旧地址时，先确认它是重新查询、使用缓存，还是复用旧连接。这三类观察对应不同处理和时间预期；不能因为新 DNS 查询正确，就认定旧连接一定异常，也不能为了消除尾部流量立即删除仍有调用方的服务。

RFC 8767 描述刷新失败时受控提供过期数据的行为。本例没有启用该功能，实验中的旧回答仍处于普通缓存有效期内。遇到过期回答，应先检查真实解析器策略，再判断是否违反预期。围绕明确的缓存代次与端点重叠期制定迁移计划，比把区域编辑器的保存时间当作全球完成时刻更可靠，也更便于制定和验证回滚步骤。

来源

RFC 1035 domain names，资源记录 TTL 与缓存寿命，已核验 2026-09-12。
RFC 8767 serving stale DNS data，刷新失败时受控复用过期数据，已核验 2026-09-12。
dnsmasq manual，转发、缓存与 TTL 控制，已核验 2026-09-12。

HTTP 状态码描述这次响应的契约

Sun, 14 Jun 2026 00:00:00 +0000

状态码需要放在请求方法的上下文里理解，它告诉客户端怎样解释本次 HTTP 响应。首位数字只能缩小类别，不能说明完整业务结果。例如，任务已经接受，仍可能没有完成；三开头的响应，也未必表示页面搬家。服务器应根据实际完成的事情选择具体状态，并提供相应响应头和内容，避免让一个看起来合理的数字承担它从未承诺的含义。

结合请求方法、正文、响应头和显式状态变化阅读这七次响应。200 状态读取可以返回仍在等待的任务，304 则不传输资源正文。调用方保留先前的资源字节；夹具不自动跟随重定向，也没有测试浏览器缓存，不能证明持久入队或最终完成。

成功不只有一种含义

二百表示请求按照相应方法的语义成功。成功读取任务状态资源，可以如实返回“任务仍在等待”的表示；这不代表任务本身已经结束。二零一表示创建了一个或多个资源，提供 Location 时，它用于识别主要的新建资源。接口需要说明客户端接下来应操作哪个资源，而不是把所有二开头的响应都解释成“用户最初想要的整个业务已经完成”。

二零二表示请求已经接受处理，但尚未完成，也不会对最终一定执行成功作出保证。应提供观察进度的途径，并定义最终成功与失败，否则客户端很难区分任务缓慢与任务丢失。二零四表示请求成功完成且没有响应内容；不能因为框架平常总是序列化 JSON，就给这种响应也附加正文。具体状态对应的消息约束需要贯穿最终输出。

三开头也可能是在验证已有表示

三零一与三零八表达永久重定向，三零二与三零七表达临时重定向，并具有不同的方法保留规则。三零三可以让调用方在处理步骤之后转而读取另一个资源。请求携带正文或具有副作用时，更要明确选择：可能改变方法的跳转，与必须保留方法的跳转，不能随意互换。客户端是否跟随，也应依据它实际要完成的动作判断。

三零四是另一种情况：它回应条件 GET 或 HEAD，表示无需重新传输选中的表示。接收方按缓存规则使用合适的已存内容，并更新相关元数据。三零四没有响应内容，也不是要求客户端沿 Location 导航。此时显示为空，是协议预期，并不能证明服务器把文件弄丢了。如果调用方没有相应缓存表示，就不能把这个空正文直接当作完整资源交给上层。

坏掉的样子

把所有四开头都归为“不能重试”，会误处理限流等情况；把所有五开头都归为“立即重试”，又可能重复非幂等操作或加剧过载。五零三覆盖暂时的服务不可用，包括过载或维护，并不只用于计划停机。重试决策还要结合方法、服务器提示和客户端预算。状态类别提供线索，不是能够无条件套用的完整重试算法。

四零四没有保证缺失只是暂时的：它可以表示找不到当前表示，也可以表示服务器不愿披露该表示。四一零才传达可能永久不可用的含义。同样，四零三并不普遍证明调用者已通过身份验证。业务代码不能在这些数字上附加比协议更强的假设；响应正文也应符合接口已声明的契约，否则下游即使正确识别了状态，仍可能误解实际处理结果。

快速验证

保存为 status-contract.py，运行 python3 status-contract.py。实验通过真实回环 HTTP 请求操作一个很小的内存任务状态和固定资源。这里使用的 Python HTTP 客户端不会自动跟随 Location，也没有实现缓存，所以脚本中每一步后续动作都明确写出。它不需要真实队列或数据库，避免把未验证的后台处理能力混进状态语义实验。

验证记录（2026-10-17）：原样响应契约实验在 macOS arm64 的 Python 3.14.4 上执行一次并通过，运行时启用断言和仅限回环的限制。下文所述的验证范围限制仍然适用。

from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread
import json

job = {'state': 'absent'}


class Handler(BaseHTTPRequestHandler):
 def reply(self, status, data=b'', headers=None):
 self.send_response(status)
 if status not in (204, 304):
 self.send_header('Content-Length', str(len(data)))
 for key, value in (headers or {}).items():
 self.send_header(key, value)
 self.end_headers()
 if status not in (204, 304):
 self.wfile.write(data)

 def do_POST(self):
 if self.path != '/jobs':
 self.reply(404)
 return
 job['state'] = 'pending'
 self.reply(202, b'{"state":"pending"}',
 {'Content-Type': 'application/json', 'Location': '/jobs/42'})

 def do_GET(self):
 if self.path == '/jobs/42':
 if job['state'] == 'complete':
 self.reply(303, headers={'Location': '/results/42'})
 elif job['state'] == 'pending':
 self.reply(200, b'{"state":"pending"}', {'Content-Type': 'application/json'})
 else:
 self.reply(404)
 elif self.path == '/results/42' and job['state'] == 'complete':
 self.reply(200, b'{"value":7}', {'Content-Type': 'application/json'})
 elif self.path == '/asset':
 if self.headers.get('If-None-Match') == '"v1"':
 self.reply(304, headers={'ETag': '"v1"'})
 else:
 self.reply(200, b'artifact', {'ETag': '"v1"'})
 else:
 self.reply(404)

 def log_message(self, *args):
 pass


server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
thread = Thread(target=server.serve_forever)
thread.start()
try:
 responses = []

 def request(method, path, headers=None):
 connection = HTTPConnection('127.0.0.1', server.server_port, timeout=5)
 try:
 connection.request(method, path, headers=headers or {})
 response = connection.getresponse()
 value = {'status': response.status, 'body': response.read().decode(),
 'location': response.getheader('Location'), 'etag': response.getheader('ETag')}
 responses.append(value)
 return value
 finally:
 connection.close()

 accepted = request('POST', '/jobs')
 assert accepted['status'] == 202 and job['state'] == 'pending'
 assert request('GET', '/results/42')['status'] == 404
 assert json.loads(request('GET', accepted['location'])['body']) == {'state': 'pending'}
 job['state'] = 'complete' # Explicit fixture transition, not a background worker.
 redirect = request('GET', '/jobs/42')
 assert redirect['status'] == 303 and redirect['location'] == '/results/42'
 assert json.loads(request('GET', redirect['location'])['body']) == {'value': 7}
 cached = request('GET', '/asset')
 validation = request('GET', '/asset', {'If-None-Match': cached['etag']})
 assert validation['status'] == 304 and validation['body'] == '' and validation['location'] is None
 assert cached['body'] == 'artifact'
 print(json.dumps({'responses': responses, 'reuse_cached_body': cached['body']}))
finally:
 server.shutdown()
 thread.join()
 server.server_close()

POST 首先返回二零二，任务此时仍为等待状态；结果地址仍返回四零四，读取状态资源则返回二百和 pending 表示。之后脚本显式把内存状态改成完成，这不是已经测试过的后台工作进程。状态端点随即返回三零三，客户端再读取 Location 指向的位置，取得数值为七的结果。每个数字描述的都是当前响应，并没有提前承诺后面的步骤一定成功。

固定资源首次 GET 返回 artifact 与 ETag "v1"。客户端把验证器带回去后，得到没有内容、也没有 Location 的三零四，同时保留之前收到的字节用于复用。这展示响应契约，不意味着已经运行过浏览器缓存测试。实验只识别一个完全匹配的 If-None-Match 字符串，没有实现列表、通配符，也没有实现一般条件 GET 所要求的弱比较规则。初次表示与条件响应需要共同解释，不能只拿最后一条响应的正文是否为空来判断资源是否可用。

七个实际响应区分了接受处理、成功读取状态、跳转到结果，以及条件复用，没有证明任务持久入队或最终一定完成。审阅接口时，应把状态选择与响应头、内容和状态迁移放在一起检查。仅有一个看似合理的数字，既不能让未完成的业务自动完成，也不能让不符合契约的表示变成可用结果。

来源

RFC 9110: HTTP Semantics，成功、重定向和错误响应的精确定义，已核验 2026-09-13。
MDN: HTTP response status codes，具体状态行为及相应响应头，已核验 2026-09-13。

为什么小型站点可以保持静态

Mon, 08 Jun 2026 00:00:00 +0000

静态站点在请求到来之前准备好文档。判断是否适用，关键是不同访问者是否需要服务器即时生成不同表示，而不是站点到底有多少页面。几百篇文章也可以共享一条发布流程：编辑源文件、构建 HTML 和资源、检查生成结果，再通过服务器或 CDN 对外提供这些文件。页面数量本身不是引入动态运行时的充分理由。

把文档生成放在合适边界

一篇文章对每位读者含义相同，逐次请求重新拼装通常不会增加多少价值。模板、导航、翻译关系和索引都可以提前生成。对外服务此时依赖的是发布产物，而不是作者使用的内容数据库或生成器。请求仍然需要加密、日志、缓存和必要的访问控制；静态交付只改变文档生成时机，并没有消除托管层的这些职责。

静态 HTML 完全可以包含 JavaScript 和交互控件。规模适中的公开文集可以使用客户端搜索索引，私有搜索或个性化结果则需要能执行权限检查的服务。表单、评论、支付和需要登录的写入，同样要由合适的处理端负责。应逐个识别这些边界：文章静态化，并不意味着浏览器能够成为权限判断或持久状态的权威来源。

提前生成是转移工作，而不是消灭工作。大型文集可能重建缓慢，构建依赖可能失败，内容新鲜度也受到发布流水线限制。源文件刚刚保存，并不代表读者已经看到更新。对于有时效的内容，需要观察从编辑到发布的延迟、明确暴露构建失败，并直接验证发布后的页面，而不能以编辑器保存成功代替上线证据。

坏掉的样子

常见错误是把整个仓库根目录当成网站根目录。这样即使没有导航链接，源数据、构建脚本和私有草稿也可能被直接下载。应使用专门的输出目录，其中只放准备公开的产物。从文章索引隐藏一项，与从发布文件中排除它，是两件不同的事。检查必须覆盖真实文件清单，包括复制进来的附件以及生成的客户端搜索数据。

另一个问题是请求到来时逐个覆盖文件。新 HTML 可能先引用尚未上传的脚本，旧页面也可能在清理过程中失去依赖。应先准备完整发布集，保留必要的旧资源，再使用托管平台支持的切换机制。仅仅恢复旧源码提交，不会自动恢复当时的依赖、构建产物、缓存状态或外部服务，因此回退能力必须按真实交付链验证。

静态输出同样可能存在注入问题。来自不可信输入的文字需要按所在上下文转义，直接插进 HTML 可能把普通字段变成可执行标记。文本转义也不是万能的：它不负责判断任意链接是否安全，不负责清洗有意允许的富文本，更不能直接用于 JavaScript 上下文。应审阅实际模板位置和源数据的信任边界，而不是因为没有请求时渲染就默认安全。

修改源码不会自动发布。依据原文与明确限制静态绘制；未为本图重跑原文夹具。

快速验证

将下面程序保存为 static-build.py，用 Python 3 执行 python3 static-build.py。它先在临时目录创建内容源，并把源码放在 public 目录之外，再构建一个 HTML 文件。回环服务器只提供 public 内的文件。所有关键结果都通过实际 HTTP 请求确认；服务器关闭之后，实验创建的临时文件也会移除，不会修改现有站点。

from functools import partial
from hashlib import sha256
from html import escape
from http.client import HTTPConnection
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from tempfile import TemporaryDirectory
from threading import Thread
import json
import os


class Handler(SimpleHTTPRequestHandler):
 def log_message(self, *args):
 pass


with TemporaryDirectory() as directory:
 root = Path(directory)
 public = root / 'public'
 public.mkdir()
 source = root / 'source.json'
 source.write_text(json.dumps({'title': 'Version one', 'text': 'Published content'}))

 def build():
 content = json.loads(source.read_text())
 document = f'<!doctype html><html lang="en"><head><meta charset="utf-8"><title>{escape(content["title"])}</title></head><body><h1>{escape(content["title"])}</h1><p>{escape(content["text"])}</p></body></html>'
 pending = root / 'next.html'
 pending.write_text(document)
 os.replace(pending, public / 'index.html')
 return document.encode()

 first = build()
 server = ThreadingHTTPServer(('127.0.0.1', 0), partial(Handler, directory=str(public)))
 thread = Thread(target=server.serve_forever)
 thread.start()
 try:
 def fetch(path='/'):
 connection = HTTPConnection('127.0.0.1', server.server_port, timeout=5)
 try:
 connection.request('GET', path)
 response = connection.getresponse()
 return response.status, response.read()
 finally:
 connection.close()

 source.unlink()
 assert fetch() == (200, first)
 source.write_text(json.dumps({'title': 'Version two', 'text': '<b>literal text</b>'}))
 assert fetch() == (200, first)
 second = build()
 assert fetch() == (200, second) and second != first
 assert b'&lt;b&gt;literal text&lt;/b&gt;' in second
 assert fetch('/source.json')[0] == 404
 print(json.dumps({'serves_without_source': True, 'edit_requires_rebuild': True,
 'published_sha256': [sha256(first).hexdigest(), sha256(second).hexdigest()],
 'source_not_published': True, 'text_escaped': True}))
 finally:
 server.shutdown()
 thread.join()
 server.server_close()

首先，程序删除可编辑的内容源，仍然能够读取已经发布的页面字节。随后重新创建有改动的源文件，但在再次执行 build 之前，HTTP 请求仍返回第一版。第二次构建后，页面摘要发生变化，响应变为第二版。作为普通文字的 <b>literal text</b> 被转义，而不是成为真正的加粗标签；访问 /source.json 则收到 404。预期四个行为标志都为真，同时打印两个不同的发布摘要。

这些断言已经在 Python 3.14.4 下运行通过。程序通过同一文件系统上的 os.replace 替换一个完整文件，因此没有展示整个多资源站点的原子发布，也没有验证掉电持久性、自动回滚或某家托管平台的部署机制。实验的重点是证明源码与发布产物之间存在明确边界，不能把单文件行为推广成未经验证的整站承诺。

实际发布仍需检查全部生成文件，覆盖代表性链接及不存在的路径，并把缓存策略和资源可用性放在一起验证。静态交付适合生成边界与产品需求相符的场景；采用之后，也应分别观察构建层和服务层的健康状态，确保源文件中的正确修改确实能够成为用户收到的正确文档。

来源

GitHub Docs: About GitHub Pages，从已发布的 HTML、CSS 与 JavaScript 文件提供静态托管，已核验 2026-09-13。
MDN: Introduction to the server side，静态与动态响应的生成边界，已核验 2026-09-13。

备份只有在演练过恢复之后才有用

Wed, 03 Jun 2026 00:00:00 +0000

“我们有备份"还不是一种恢复能力。一份有用的备份有已知范围、已知新鲜度、一个验证步骤，以及一份确实有人运行过的恢复流程。

恢复演练从可识别的输入，以及取回并核验的存储副本开始。在可丢弃的隔离目标中恢复，再记录文件、权限、依赖与恢复耗时。校验和或归档存在本身，都不能证明可恢复。

定义恢复单元

对静态站点，源码仓库与生成制品用途不同。仓库是权威输入；制品是恢复最近发布版本的最快方式。请把两者的区别说清楚。

至少记录：

源码提交或归档标识；
生成器与主题版本；
制品包含的文件列表；
重要下载的校验和；
保留期限与存储位置。

不要把凭据、私钥、Cookie 或访问令牌放进网站备份。它们应属于独立的机密管理流程。

存储前先验证

打不开的归档不是备份。一个最小的验证循环如下：

set -eu
tar -czf site-2026-06-03.tar.gz public/
tar -tzf site-2026-06-03.tar.gz >/dev/null
sha256sum site-2026-06-03.tar.gz > site-2026-06-03.tar.gz.sha256

生成校验和只是记录基线，并未回读实际存储的副本。先从备份存储取回归档与校验和，再在解包前核验。校验和匹配能发现意外变化，但攻击者若可同时替换两个文件，它便不能证明归档来源可信。能列出成员也不等于备份了正确的文件。

在某个可丢弃的地方恢复

使用可信归档，以非特权用户身份解包到空临时目录或隔离主机，再检查入口点与一个有代表性的资源。不可信归档需要更强的隔离，因为路径与链接会影响解包行为。不要通过覆盖唯一活动副本来测试。

set -eu
sha256sum -c site-2026-06-03.tar.gz.sha256
restore_dir=$(mktemp -d)
tar -xzf site-2026-06-03.tar.gz -C "$restore_dir"
test -s "$restore_dir/public/index.html"
test -s "$restore_dir/public/404.html"

这条命令刻意很平凡。演练应在事故到来之前，暴露出缺失文件、错误权限或未记录的依赖。

诚实地度量新鲜度

备份日程只有在相对可能丢失的工作量时才有意义。如果源码一个月才变一次，每日快照可能不必要；如果某个资源每小时更新，一次月度归档又不够。

写下目标恢复点与恢复时间，再选择能满足这些目标的存储与检查。当最后一次经过验证的恢复备份已经陈旧时，不要宣称"连续保护”。

至少保留一份位于活动主机故障与删除范围之外的可恢复副本。记录恢复耗时、恢复文件的校验和、权限与人工依赖；两个非空 HTML 文件只是冒烟测试，不是完整的恢复验收。

来源

GNU tar manual，归档创建与验证行为，已核验 2026-06-03。
静态网站发布检查清单，本地配套资源。
GNU Coreutils: SHA-2 工具，生成校验和与 --check 核验，已核验 2026-10-15。

Operations · XB 现场笔记

发布一个静态站点并证明边缘一致

1. 从已记录输入构建一份产物

2. 检查完整离线契约

3. 用清单标识产物字节

4. 暂存并选择完整发布

5. 验证实际交付字节与策略

6. 分别检查 TLS 身份和到期窗口

7. DNS 变化时纳入缓存窗口

8. 保留演练过的恢复路径

9. 精确记录结果

来源

像客户端一样读取活动边缘

1. 先确定方法可以问什么

2. 读取表示行

3. 对同一表示比较 HEAD 与 GET

4. 用范围请求精确的字节

5. 用验证器让缓存重新验证

6. 协商更小的表示

7. 跟随 URL 变化时的故事

8. 最后让爬虫读地图

所有检查一览

来源

维护定时器应让其最近结果可见

把工作定义成服务

调度该服务

启用前先验证

对服务结果告警

来源

重启策略需要一个速率限制

捕获启动失败

限制循环

来源

SSH 主机密钥是部署记录的一部分

把首次接触与轮换分开

让指纹可复核

来源

小系统的优势

可见性是一种特性

复杂性要用实力取得位置

让所有权明确

为下一次变更留出空间

来源

robots.txt 与 sitemap 回答不同的问题

robots.txt 能做什么、不能做什么

sitemap 增加了什么

来源

可靠的默认行为胜过聪明的恢复

让常见路径变得无聊

只对可限定范围的操作重试

偏好单一权威状态

恢复应回到已知状态

来源

重定向与错误码应保留故事的完整性

永久移动并不都等价

区分"缺失"与"被移除"

来源

用两条命令读取公共边缘

检查响应头

检查证书日期

在发布前后使用两者

来源

事故复盘应留下一份事实记录

检测：症状，而且要带证据

界定范围：影响多广，以及你如何知道

修复：变更及其预期效果

验证：事后运行

来源

用实际拒绝结果验证 systemd 服务边界

坏掉的样子

快速验证

让必要访问保持明确

延伸阅读

来源

DNS 变更需要一个感知缓存的回滚窗口

在事件前降低 TTL

让两侧都保持有效

观察后恢复 TTL

来源

DNS 迁移应提前降低 TTL，并保留回滚缓存窗口