后端-08-部署与运维基础
这篇讲什么
从「本地能跑」到「线上可用」,中间隔着的不是一行部署命令,而是一整套工程实践:环境隔离、进程守护、反向代理、TLS 证书、日志、监控、备份、回滚。
本篇给出可以直接使用的 Nginx 配置、SSH 加固步骤、恢复演练脚本、健康检查设计,并把可用性、容量、发布策略这些「凭感觉」的话题量化成可计算的公式。
读完你应该能做到:① 把一台干净的 Linux 服务器加固到可以放生产服务;② 独立部署一个带 HTTPS 和反向代理的服务;③ 说出至少三个 9 的实际停机预算;④ 设计一套能真正发现故障的监控告警。
一、从「本地能跑」到「线上可用」缺什么
在本地,你是唯一的用户,网络是零延迟,磁盘不会满,进程崩了你手动再起一次。线上这些前提全部不成立。缺的正好是八件事:
| 缺口 | 本地状态 | 线上必须解决的问题 | 本文对应章节 |
|---|---|---|---|
| 环境隔离 | 你的电脑只有你的项目 | 多服务共存、依赖不冲突、可回滚 | 第 2、6 节 |
| 进程守护 | 终端关了就没了 | 崩溃自动重启、开机自启、日志留存 | 第 3 节 |
| 反向代理 | 直接访问 localhost:3000 | 域名、80/443 统一入口、TLS 终止、负载均衡 | 第 4 节 |
| 域名与证书 | http://localhost | DNS 解析、HTTPS 证书、自动续期 | 第 5 节 |
| 日志 | 打在终端里看一眼 | 结构化、可检索、可集中、不写满磁盘 | 第 7 节 |
| 监控 | 凭感觉 | 量化指标、告警阈值、健康检查 | 第 8 节 |
| 备份 | 代码在 Git 就够了 | 数据备份 + 验证过的恢复流程 | 第 11 节 |
| 回滚 | 改错了再改回来 | 快速回退到上一版本的能力 | 第 9 节 |
一句话判断标准
一个服务「上线了」的标志不是「能访问」,而是:它挂了会有告警,数据丢了能恢复,新版本有问题能在 5 分钟内回滚。
二、部署形态演进
| 形态 | 代表技术 | 成本 | 弹性 | 运维复杂度 | 适用场景 |
|---|---|---|---|---|---|
| 裸机(Bare Metal) | 物理服务器 + systemd | 最低(长期) | 差,扩容按周计 | 低(但单点风险高) | 数据库、高性能计算、成本敏感的长期负载 |
| 虚拟机(VM) | KVM / VMware / 云主机 | 中 | 中,扩容按分钟计 | 中 | 中小规模业务主力形态 |
| 容器 | Docker + Compose | 中低 | 中,秒级启动 | 中 | 单机多服务、CI/CD 标准化交付 |
| 容器编排 | Kubernetes | 高(控制面开销) | 强,自动扩缩容与自愈 | 高 | 多服务、多团队、需要滚动发布与自愈 |
| Serverless | 函数计算 / 托管容器 | 按用量计费,空闲近乎为零 | 极强,自动伸缩 | 低(运维转移给平台) | 流量波动大、事件驱动、定时任务 |
选型建议(避免过度设计):
- 一个服务、一台机器 → 容器 + Compose + Nginx,足够。
- 三五个服务、需要滚动发布和自愈 → 编排系统才有价值。
- 只有在「控制面本身的运维成本」能被团队规模摊薄时,编排才是划算的。
最常见的过度设计
三个人、两个服务的项目上 Kubernetes,结果一半的工程时间花在维护集群、排查网络插件和写 YAML 上。编排系统解决的是「规模带来的复杂度」,它本身也会带来复杂度。
三、服务器基础
3.1 Linux 常用运维命令速览
详细用法见 工具-02-命令行与Shell,这里列出上线排障时真正高频的那些:
| 目的 | 命令 | 关键点 | |
|---|---|---|---|
| 看谁在占 CPU/内存 | top / htop | 关注 %wa(IO 等待)与 load average | |
| 看磁盘剩余 | df -h | 根分区写满是最常见的线上故障 | |
| 看目录大小 | `du -sh /var/log/* \ | sort -h` | 定位「谁把磁盘写满了」 |
| 看内存详情 | free -h | 关注 available 而非 free | |
| 看端口监听 | ss -ltnp | 确认服务真的在监听以及监听地址 | |
| 看连接状态 | ss -s / ss -tan state time-wait | TIME_WAIT 过多说明短连接密集 | |
| 跟踪日志 | journalctl -u mysvc -f | systemd 管理的服务统一入口 | |
| 实时看日志尾部 | tail -f -n 200 app.log | 注意日志轮转后要重新 tail | |
| 查进程树 | ps auxf / pstree -p | 排查多进程与僵尸进程 | |
| 查打开的文件 | lsof -p <pid> | 排查句柄泄漏、被删但被占用的文件 | |
| 测连通性 | curl -v / nc -zv host port | 分层验证网络与应用 | |
| 看系统负载来源 | vmstat 1 / iostat -x 1 | 区分 CPU 瓶颈与 IO 瓶颈 | |
| 看内核与 OOM 记录 | `dmesg -T \ | tail -50` | 出现 Out of memory: Killed process 即被 OOM |
负载(load average)怎么读:uptime 显示的三个数字是 1/5/15 分钟的平均可运行队列长度。经验判断:load 持续大于 CPU 核数说明有排队。但注意 load 也包含 IO 等待的进程,所以磁盘慢时 load 高而 CPU 空闲——这时要看 %wa。
3.2 用户与权限最小化原则
原则:每个服务一个专用系统用户,只给完成工作所需的最小权限,不用 root 跑应用。
# 1. 创建不可登录的系统用户与用户组
sudo groupadd --system myapp
sudo useradd --system --gid myapp --home-dir /opt/myapp \
--shell /usr/sbin/nologin myapp
# 2. 代码目录归该用户所有,权限收紧
sudo mkdir -p /opt/myapp
sudo chown -R myapp:myapp /opt/myapp
sudo chmod 750 /opt/myapp
# 3. 敏感配置单独放,仅属主可读
sudo install -o myapp -g myapp -m 600 /dev/null /opt/myapp/.env
sudo -u myapp tee /opt/myapp/.env >/dev/null <<'EOF'
DB_PASSWORD=replace-me
EOF
| 权限位 | 含义 | 用在哪 |
|---|---|---|
600 | 仅属主读写 | .env、私钥、证书私钥文件 |
640 | 属主读写,同组只读 | 需要同组进程读取的配置 |
644 | 所有人可读 | 静态资源、公开证书 |
700 | 仅属主可进入/执行 | 私有目录 |
750 | 属主全权,同组可读执行 | 应用目录 |
777 | 所有人可写 | ⚠️ 永远不要用 |
# 只授予必要的能力而不是完整 root(systemd 服务示例)
sudo systemctl edit myapp
# [Service]
# User=myapp
# Group=myapp
# NoNewPrivileges=true
# ProtectSystem=strict
# ProtectHome=true
# PrivateTmp=true
# ReadWritePaths=/opt/myapp/uploads
chmod 777不是「解决权限问题」的办法它把权限问题换成了安全问题。正确做法是搞清「哪个用户需要什么权限」然后精确授权。另外注意:私钥文件权限过宽时,SSH 会直接拒绝使用它(报
UNPROTECTED PRIVATE KEY FILE),这也是为什么私钥一律600。
3.3 SSH 密钥登录并禁用密码登录
密码登录可以被暴力破解,且无法防止中间人。密钥登录是生产服务器的基线要求。
第一步:本地生成密钥(在你自己电脑上执行)
# 推荐 ed25519,比 RSA 更短更安全
ssh-keygen -t ed25519 -C "ops@example.com" -f ~/.ssh/id_ed25519_prod
# 设置 passphrase(不要留空);用 ssh-agent 避免每次输入
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519_prod
第二步:把公钥装到服务器
# 方式 A:ssh-copy-id(最省事)
ssh-copy-id -i ~/.ssh/id_ed25519_prod.pub deploy@203.0.113.10
# 方式 B:手动(当 ssh-copy-id 不可用时)
ssh deploy@203.0.113.10 'mkdir -p ~/.ssh && chmod 700 ~/.ssh && \
cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys' \
< ~/.ssh/id_ed25519_prod.pub
# 验证:必须能不输密码登进去,才继续下一步
ssh -i ~/.ssh/id_ed25519_prod deploy@203.0.113.10 'echo login-ok'
第三步:加固 sshd 配置
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak.$(date +%F)
sudo tee /etc/ssh/sshd_config.d/99-hardening.conf >/dev/null <<'EOF'
# 禁用密码与键盘交互认证,只允许密钥
PasswordAuthentication no
KbdInteractiveAuthentication no
ChallengeResponseAuthentication no
PubkeyAuthentication yes
# 禁止 root 直接登录
PermitRootLogin no
# 限制可登录用户
AllowUsers deploy
# 减少暴露面
X11Forwarding no
AllowAgentForwarding no
PermitEmptyPasswords no
MaxAuthTries 3
LoginGraceTime 20
# 空闲超时自动断开
ClientAliveInterval 300
ClientAliveCountMax 2
EOF
# 一定要先检查语法,再重启
sudo sshd -t && echo "config OK"
# 用 reload 而不是 restart,避免断开当前连接
sudo systemctl reload ssh || sudo systemctl reload sshd
改 SSH 配置会把自己锁在门外
禁用密码登录前,必须先用密钥成功登录一次并保持该会话不断开。修改后按以下顺序操作:
1.
sudo sshd -t检查语法(语法错了 sshd 根本起不来)。2. 用
reload而不是restart。3. 另开一个终端测试新连接能否成功;成功后再关闭旧会话。
4. 如果失败,还能用仍然打开的旧会话回滚:
sudo cp /etc/ssh/sshd_config.bak.<日期> /etc/ssh/sshd_config && sudo systemctl reload ssh。5. 云服务器还要确认控制台的 VNC/串口登录可用,这是最后的救生通道。
3.4 防火墙与安全组的双层关系
云上访问控制是两层串联的,两层都必须放行才能通:
| 层 | 位置 | 工具 | 特点 |
|---|---|---|---|
| 安全组 / 网络 ACL | 云平台虚拟网络层,在主机之外 | 云控制台 | 流量根本到不了服务器;改配置不重启服务 |
| 主机防火墙 | 服务器操作系统内 | ufw / firewalld / iptables | 在主机上拦;防止安全组误配时被直接打穿 |
# ---------- ufw(Ubuntu / Debian 系) ----------
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp # 先放行 SSH,否则会断连
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable # 会提示可能中断 ssh,确认前已放行 22 就没问题
sudo ufw status verbose
# ---------- firewalld(RHEL / CentOS / Rocky 系) ----------
sudo systemctl enable --now firewalld
sudo firewall-cmd --permanent --add-service=ssh
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload
sudo firewall-cmd --list-all
关键原则:数据库端口永远不要暴露到公网。
# ✅ 只允许应用服务器访问数据库端口
sudo ufw allow from 10.0.1.15 to any port 5432 proto tcp
# ❌ 千万不要
sudo ufw allow 5432/tcp
先放行 SSH 再启用防火墙
sudo ufw enable在未放行 22 端口时会立刻切断你的 SSH 连接,且重启后依然是拒绝状态。如果云控制台没有 VNC,你只能重装系统。正确顺序:allow 22→enable→ 再加其他规则。另一个高频事故:Docker 会自行写
iptables规则,ufw对 Docker 发布的端口可能不生效。docker run -p 5432:5432即使 ufw 没放行也可能被外网访问到。解决办法:① 发布端口时绑定回环-p 127.0.0.1:5432:5432;② 在daemon.json里设置"iptables": false(需自行管理规则);③ 用云安全组兜底。这也是为什么「数据库只在内部网络可见」应该用 Docker 网络而不是靠 ufw。
四、反向代理
4.1 Nginx 在架构中承担什么
反向代理(reverse proxy) 位于客户端与后端应用之间,代表后端接收请求。它一次解决六件事:
| 职责 | 说明 |
|---|---|
| TLS 终止 | 证书只配在 Nginx 一处,后端应用不接触 HTTPS,配置更简单、性能更好 |
| 静态资源服务 | Nginx 用 sendfile 直接发文件,比任何应用框架都快 |
| 负载均衡 | 一个域名分发到多个应用实例,实现水平扩容与滚动发布 |
| 限流与防刷 | 在流量进入应用前拦截异常请求,保护后端 |
| 缓冲与压缩 | 吸收慢客户端、对响应做 gzip/brotli 压缩 |
| 统一入口 | 一个 443 端口承载多个域名/服务,简化防火墙与证书管理 |
4.2 一份可用的 server 配置
# /etc/nginx/conf.d/myapp.conf
# ---------- 上游应用实例组 ----------
upstream myapp_backend {
least_conn; # 按最少连接数分发
server 127.0.0.1:3000 max_fails=3 fail_timeout=10s;
server 127.0.0.1:3001 max_fails=3 fail_timeout=10s;
keepalive 32; # 复用后端长连接,减少握手开销
}
# ---------- HTTP:全部跳转到 HTTPS ----------
server {
listen 80;
listen [::]:80;
server_name example.com www.example.com;
# 让 ACME 校验走 HTTP(证书续期需要)
location /.well-known/acme-challenge/ {
root /var/www/certbot;
}
location / {
return 301 https://$host$request_uri;
}
}
# ---------- HTTPS 主站 ----------
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
server_name example.com www.example.com;
# 证书链:服务器证书在前,中间证书在后(顺序错了 nginx 起不来)
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers off;
# 会话复用:减少 TLS 握手,1 MB 大约可存 4000 个会话
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 1h;
ssl_session_tickets off;
# 安全响应头
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-Frame-Options "SAMEORIGIN" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
# 请求体大小上限(文件上传必须显式放宽,否则报 413)
client_max_body_size 20m;
# 访问日志:结构化、带上游耗时,便于统计 p95/p99
access_log /var/log/nginx/myapp.access.log combined;
error_log /var/log/nginx/myapp.error.log warn;
# ---------- 压缩 ----------
gzip on;
gzip_comp_level 5;
gzip_min_length 1024;
gzip_proxied any;
gzip_vary on;
gzip_types
text/plain text/css text/xml
application/json application/javascript application/xml+rss
application/xml image/svg+xml;
# 注意:不要压缩已压缩格式(jpg/png/mp4/zip),纯属浪费 CPU
# ---------- 静态资源:长缓存 + 强校验 ----------
location /assets/ {
root /var/www/myapp;
expires 1y;
add_header Cache-Control "public, immutable";
access_log off;
}
location = /favicon.ico { access_log off; log_not_found off; }
# ---------- 健康检查端点:不进应用,直接返回 ----------
location = /healthz {
access_log off;
return 200 "ok\n";
add_header Content-Type text/plain;
}
# ---------- 限流后的 API ----------
location /api/ {
limit_req zone=api_perip burst=20 nodelay;
limit_req_status 429;
proxy_pass http://myapp_backend;
proxy_http_version 1.1;
# 必须转发的头(见 4.3 节)
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_set_header X-Forwarded-Host $host;
proxy_set_header X-Request-Id $request_id;
# keepalive 复用必须清空 Connection
proxy_set_header Connection "";
# 超时设置:连接建立、发送、读取分别控制
proxy_connect_timeout 5s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
# 后端返回 502/504 时尝试下一个实例
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
# ---------- WebSocket 升级 ----------
location /ws/ {
proxy_pass http://myapp_backend;
proxy_http_version 1.1; # WebSocket 要求 1.1
proxy_set_header Upgrade $http_upgrade; # 透传 Upgrade
proxy_set_header Connection "upgrade"; # 必须是 upgrade,不能是空
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_read_timeout 3600s; # 长连接不能 60s 就断
proxy_send_timeout 3600s;
proxy_buffering off; # 实时推送不要缓冲
}
location / {
proxy_pass http://myapp_backend;
proxy_http_version 1.1;
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_set_header Connection "";
}
}
限流规则定义在 http 块中(/etc/nginx/nginx.conf 或单独的 conf 文件):
# $binary_remote_addr 比 $remote_addr 省内存:IPv4 固定 4 字节
limit_req_zone $binary_remote_addr zone=api_perip:10m rate=20r/s;
limit_req_zone $binary_remote_addr zone=login_perip:10m rate=5r/m;
# 连接数限制(并发连接,防慢速攻击)
limit_conn_zone $binary_remote_addr zone=conn_perip:10m;
# 改完配置必须做的三步
sudo nginx -t # 语法检查,必须先过
sudo nginx -s reload # 平滑重载,不中断现有连接
curl -I https://example.com/healthz
4.3 proxy_set_header 必须转发的头与「应用侧要信任代理」的原因
反向代理之后,后端应用看到的 TCP 连接来自 Nginx(127.0.0.1),而不是真实用户。如果不显式转发,应用会:
- 把所有人的 IP 都记成 127.0.0.1,日志无法定位攻击者,限流会把所有用户当成同一个人;
- 以为所有请求都是 HTTP,生成
http://的回调地址、重定向地址,导致混合内容与跳转循环; - 拿到错误的
Host,多租户/多域名场景下路由到错误站点。
| 头 | 值 | 作用 |
|---|---|---|
Host | $host | 保留原始域名,用于虚拟主机路由与生成绝对 URL |
X-Real-IP | $remote_addr | 直连客户端 IP(最靠近的那一跳) |
X-Forwarded-For | $proxy_add_x_forwarded_for | 追加式代理链,格式 客户端, 代理1, 代理2 |
X-Forwarded-Proto | $scheme | 原始协议(http/https),应用判断是否该跳转 |
X-Forwarded-Host | $host | 部分框架用它生成链接 |
X-Request-Id | $request_id | 全链路追踪 ID,排查跨服务问题必备 |
直接信任
X-Forwarded-For等于给了攻击者伪造 IP 的能力
X-Forwarded-For是客户端可以自己设置的头。如果 Nginx 用的是$proxy_add_x_forwarded_for,它会把客户端传来的值追加在后面:```text
X-Forwarded-For: 1.2.3.4 (攻击者伪造), 203.0.113.7 (真实客户端, Nginx 追加)
```
应用如果读「第一个」IP 就会取到伪造值,从而绕过基于 IP 的限流与封禁。
正确做法(两件事都要做):
① Nginx 用
proxy_set_header X-Forwarded-For $remote_addr;覆盖而不是追加(适用于只有一层代理的场景);② 应用侧只信任已知代理:Nginx 在转发前先把客户端可能伪造的头清掉,应用再把
X-Forwarded-For从右往左解析,跳过所有可信代理地址,取第一个不可信地址:```nginx
# 入口处先清掉客户端伪造的可能性
proxy_set_header X-Forwarded-For remote_addr;
```
```csharp
// ASP.NET Core:只信任已知代理(按文档配置 ForwardedHeaders)
builder.Services.Configure<ForwardedHeadersOptions>(o =>
{
o.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
o.KnownProxies.Add(IPAddress.Parse("127.0.0.1"));
o.ForwardLimit = 1; // 只信任一跳
});
app.UseForwardedHeaders();
```
```javascript
// Express:显式设置可信代理层数,而不是 app.set('trust proxy', true)
app.set('trust proxy', 1); // 只信任第一层代理
```
4.4 负载均衡策略
| 策略 | 配置 | 适用 | 注意 |
|---|---|---|---|
| 轮询(默认) | 不写 | 后端能力均等、无状态 | 简单有效 |
| 加权轮询 | server a weight=5; | 机器配置不同 | 权重需按容量校准 |
| 最少连接 | least_conn; | 请求耗时差异大 | 长请求场景更均衡 |
| IP 哈希 | ip_hash; | 需要会话粘滞 | 扩缩容会导致大量重映射;不如改成无状态 + 共享会话 |
| 一致性哈希 | hash $key consistent; | 缓存分片 | 加减节点只影响少量 key |
upstream backend {
least_conn;
server 10.0.1.11:3000 weight=3 max_fails=3 fail_timeout=10s;
server 10.0.1.12:3000 weight=1 max_fails=3 fail_timeout=10s;
server 10.0.1.13:3000 backup; # 备用机,主机全挂才启用
keepalive 32;
}
优先做成无状态
会话粘滞(sticky session)是「把状态留在单机上」的妥协。改成 JWT 或共享 Session(Redis) 后,任何实例都能处理任何请求,扩容、滚动发布、故障转移都会简单一个数量级。
五、HTTPS 与证书
5.1 证书链
一次 TLS 握手需要客户端验证服务器身份,验证依赖一条信任链(certificate chain):
根证书(Root CA,预装在操作系统/浏览器信任库中,自签名)
│ 签发
中间证书(Intermediate CA,可以有多个,通常不预装在客户端)
│ 签发
服务器证书(你的 example.com 证书,含公钥与域名)
关键点:只提供服务器证书是不够的。客户端信任库里没有中间证书,必须由服务器在握手时一并下发。Nginx 的 ssl_certificate 指向的文件按 服务器证书 → 中间证书 的顺序拼接:
# 拼接顺序不能反,反了 nginx 会起不来并报
# SSL_CTX_use_PrivateKey_file() failed ... key values mismatch
cat example.com.crt intermediate.crt > example.com.chained.crt
# 验证是否下发了完整链(能看到至少 2 个证书即正常)
openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null \
| sed -n '/Certificate chain/,/---/p'
# 检查证书有效期与到期天数
echo | openssl s_client -connect example.com:443 -servername example.com 2>/dev/null \
| openssl x509 -noout -subject -issuer -dates
# 从任意 PEM 文件读取到期时间(写巡检脚本用)
openssl x509 -enddate -noout -in /etc/letsencrypt/live/example.com/fullchain.pem
5.2 Let's Encrypt 与 ACME 自动续期
Let's Encrypt 通过 ACME 协议(Automatic Certificate Management Environment)签发免费、90 天有效的证书。90 天是刻意的设计:它逼迫自动化,而自动化才是可靠的。
# ---------- 方式 A:certbot 独立模式(先停 nginx,最简单) ----------
sudo certbot certonly --standalone -d example.com -d www.example.com
# ---------- 方式 B:webroot 模式(nginx 不停,推荐生产) ----------
sudo mkdir -p /var/www/certbot
sudo certbot certonly --webroot -w /var/www/certbot \
-d example.com -d www.example.com \
--email ops@example.com --agree-tos --no-eff-email
# ---------- 方式 C:nginx 插件(自动改配置,适合新手) ----------
sudo certbot --nginx -d example.com -d www.example.com
# 演练式续期(只模拟,不真的换证书)——上线前必须做一次
sudo certbot renew --dry-run
# 查看已签发的证书与剩余天数
sudo certbot certificates
自动续期由 systemd timer 或 cron 触发(certbot 包会自动安装):
systemctl list-timers | grep certbot
# 手动测试定时任务本身是否可用
sudo systemctl start certbot.timer
sudo systemctl status certbot.timer
续期成功后需要重载 nginx 才能加载新证书,用 --deploy-hook:
sudo certbot renew --deploy-hook "systemctl reload nginx"
5.3 续期失败为什么是真实的线上事故
这不是理论风险。证书过期会导致:
- 浏览器显示「您的连接不是私密连接」全屏警告,用户流失是立即且 100% 的;
- 移动 App、小程序、第三方 API 调用方在证书校验失败时直接抛异常,接口全部不可用;
- 若服务间调用(mTLS 或 https)也依赖该证书,会引发级联故障。
常见的续期失败原因:
| 原因 | 表现 | 预防 |
|---|---|---|
| HTTP-01 校验路径被改 | /.well-known/acme-challenge/ 被 301 到 HTTPS 或返回 404 | 在该 location 上禁止跳转;配置 location ^~ /.well-known/acme-challenge/ |
| 端口 80 被关闭 | 校验无法访问 | 保留 80 端口仅用于跳转与 ACME |
| DNS 变更导致域名不解析 | NXDOMAIN 或解析到旧 IP | 变更 DNS 时检查 ACME 校验 |
| 限流(rate limit) | 同一域名短时间重复申请被拒 | 不要手工反复申请;用 --dry-run 演练 |
| 磁盘/权限问题 | certbot 无法写 /etc/letsencrypt | 定期检查磁盘与目录权限 |
| 没人发现 | 到期当天才暴露 | 必须有到期告警 |
# 巡检脚本(建议每天跑一次,到期前 30 天开始告警)
CERT=/etc/letsencrypt/live/example.com/fullchain.pem
END=$(date -d "$(openssl x509 -enddate -noout -in "$CERT" | cut -d= -f2)" +%s)
LEFT=$(( (END - $(date +%s)) / 86400 ))
echo "cert expires in ${LEFT} days"
[ "$LEFT" -lt 14 ] && echo "ALERT: certificate expires soon" && exit 1
exit 0
「自动续期」不等于「一定会续期」
自动化只在它真的在跑且成功时有效。上线检查清单里必须有一条:证书到期告警已配置,且做过一次
--dry-run演练(见第 13 节)。同时监控续期任务本身的执行结果,而不是只监控证书文件。
5.4 HSTS 的取舍
HSTS(HTTP Strict Transport Security)通过响应头告诉浏览器「以后访问这个域名一律用 HTTPS,不要再尝试 HTTP」:
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
| 收益 | 代价 |
|---|---|
| 彻底消灭 SSL 剥离(SSL stripping)攻击:首次访问之后的降级跳转不可能发生 | 浏览器把域名锁定在 HTTPS 上,max-age 内无法回退到 HTTP |
| 省掉一次 301 跳转的往返,首屏更快 | includeSubDomains 会连带锁定所有子域名,某个子域没有证书就直接不可访问 |
配合 preload 可进入浏览器内置列表 | preload 的移除流程以月计,误操作代价极高 |
渐进上线策略(强烈建议):
# 第 1 周:短 max-age,观察是否有子域被锁死或混合内容报错
add_header Strict-Transport-Security "max-age=300" always;
# 第 2-4 周:无异常后逐步加长
add_header Strict-Transport-Security "max-age=86400" always;
# 稳定后:一年 + 子域
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
# preload 只有在「所有子域都已全量 HTTPS 且承诺长期如此」时才考虑
HSTS 与 preload 的不可逆性
一旦提交 preload 列表,浏览器会把你的域名硬编码为 HTTPS-only,移除需要等浏览器发版、用户升级,周期以月甚至年计。且
includeSubDomains会让任何一个忘记配证书的子域(如内部测试域dev.example.com)对用户完全不可访问。上线策略:先短max-age、先不带includeSubDomains、绝不在没做过全面子域盘点时上preload。
六、环境与配置管理
6.1 十二要素应用简介
十二要素应用(The Twelve-Factor App) 是一套面向 SaaS 应用的工程方法论,十二条如下:
| # | 要素 | 一句话 |
|---|---|---|
| I | 基准代码 | 一份代码库,多次部署(同一份代码部署到多环境) |
| II | 依赖 | 显式声明依赖,不依赖系统中隐式存在的包 |
| III | 配置 | 在环境中存储配置,与代码严格分离 |
| IV | 后端服务 | 把数据库、缓存、队列当作可替换的附加资源 |
| V | 构建、发布、运行 | 三个阶段严格分离,构建产物不可变 |
| VI | 进程 | 以一个或多个无状态进程运行应用 |
| VII | 端口绑定 | 通过端口暴露服务,不依赖外部 Web 服务器注入 |
| VIII | 并发 | 通过进程模型水平扩展 |
| IX | 易处理 | 快速启动、优雅终止 |
| X | 开发/线上等价 | 尽可能缩小环境差异 |
| XI | 日志 | 把日志当作事件流,应用只管写到 stdout |
| XII | 管理进程 | 后台管理任务当作一次性进程运行 |
与部署最直接相关的是 III、V、VI、IX、X、XI 六条。它们在现代容器化部署里几乎是必选项。
6.2 配置与代码分离
判定标准很简单:这段内容在不同环境(开发/测试/生产)会不一样吗? 会 → 它是配置,不能进代码库。
# ✅ 配置来自环境
DATABASE_URL=postgres://app:***@db.internal:5432/appdb
LOG_LEVEL=info
FEATURE_NEW_CHECKOUT=true
# ❌ 反模式
# config/production.json 里写死密码并提交进 Git
# if (env === 'production') { host = '10.0.1.20' } 硬编码环境分支
| 配置类型 | 存放位置 | 是否进 Git |
|---|---|---|
| 环境无关的默认值 | 代码里的常量 | ✅ |
| 环境相关的非敏感配置 | 环境变量 / 配置文件模板 | ✅(模板进,具体值不进) |
| 密钥、证书私钥、令牌 | 密钥管理系统 / CI secret / 权限 600 的文件 | ❌ |
6.3 密钥管理:为什么不能进 Git
Git 的历史是不可变的。 提交一次密钥,即使下一次提交删掉它,密钥仍然存在于历史对象中,克隆仓库的任何人 git log -p 就能拿到。所以:
密钥进了 Git 就等于已泄露
必须做的三件事,顺序不能变:
1. 轮换(rotate):立刻在服务端作废该密钥并生成新的。这是唯一真正有效的补救。
2. 清理历史:用
git filter-repo或 BFG 重写历史并强推,通知所有协作者重新克隆。注意这只能减少进一步扩散,不能挽回已泄露的事实。3. 加防护:加
.gitignore规则、装 pre-commit 钩子做密钥扫描(如 gitleaks)、在 CI 里加扫描步骤、启用平台提供的密钥扫描告警。很多人只做第 2 步就以为安全了——攻击者往往在密钥提交后几分钟内就扫描到了公开仓库并利用完毕。
6.4 .env 的权限与密钥轮换
# .env 权限 600,属主为运行应用的用户
sudo install -o myapp -g myapp -m 600 /dev/null /opt/myapp/.env
# 确认权限(应该是 -rw-------)
ls -l /opt/myapp/.env
# .gitignore 必须包含
cat >> .gitignore <<'EOF'
.env
.env.*
!.env.example
*.pem
*.key
secrets/
EOF
# 提供一份不含真实值的模板给协作者
cat > .env.example <<'EOF'
DATABASE_URL=postgres://user:password@localhost:5432/dbname
REDIS_URL=redis://localhost:6379
LOG_LEVEL=debug
EOF
密钥轮换(key rotation) 的三种模式:
| 模式 | 做法 | 停机 | 适用 |
|---|---|---|---|
| 停机轮换 | 停服 → 换密钥 → 起服 | 有 | 内部系统、可接受短暂停机 |
| 双密钥并行 | 新旧密钥同时有效 → 逐步切换 → 旧的失效 | 无 | 生产 API、签名密钥(推荐) |
| 滚动轮换 | 逐实例替换 | 无 | 编排平台上的服务 |
轮换周期建议:高价值密钥(支付、数据库主账号)每 90 天;一般服务密钥每 180 天;任何人离职后立即轮换其接触过的密钥。
七、日志
7.1 结构化日志与级别
非结构化日志(2026-10-11 10:00:00 ERROR 用户 123 下单失败)只能靠正则解析,字段一多就不可维护。结构化日志(通常是 JSON)把字段显式化,日志系统可以直接按字段检索与聚合:
{"ts":"2026-10-11T10:00:00.123Z","level":"error","service":"order-api","env":"prod","traceId":"a1b2c3","userId":123,"orderId":98765,"event":"order.create.failed","err":"connection refused","dbHost":"db.internal","durationMs":5012}
| 级别 | 语义 | 使用原则 |
|---|---|---|
debug | 开发调试细节 | 生产默认关闭,可按需动态开启 |
info | 正常业务事件(启动、请求完成、状态变更) | 生产默认级别;不要每个请求都打全量 payload |
warn | 可恢复的异常(重试成功、降级生效、接近阈值) | 需要有人定期看,否则等于没打 |
error | 请求失败、依赖不可用、未预期异常 | 每一条都应有告警或明确的处理流程 |
fatal | 进程无法继续 | 打出后立即退出,由平台重启 |
日志级别的通胀
如果
error日志每天有几千条且从没人处理,那它已经退化成噪音——真正的故障会被淹没。纪律是:error级别意味着「需要人做点什么」;不需要处理的一律降到warn或info。
7.2 输出到 stdout 由平台收集
应用只往 stdout/stderr 写,不自己管理文件路径、轮转、归档:
// ✅ Node:结构化 JSON 到 stdout
function log(level, event, fields = {}) {
process.stdout.write(JSON.stringify({
ts: new Date().toISOString(), level, service: 'order-api', event, ...fields
}) + '\n');
}
log('info', 'server.started', { port: process.env.PORT });
| 好处 | 说明 |
|---|---|
| 与容器天然契合 | Docker/K8s 捕获 stdout,容器删了日志还在平台里 |
| 无需处理路径 | 不用关心「日志目录该在哪、谁有写权限」 |
| 轮转交给平台 | 不会因为应用忘了轮转而写满磁盘 |
7.3 日志轮转防止磁盘写满
即使走 stdout,系统层与 Nginx 层仍会产生文件。磁盘写满的后果是灾难性的:数据库无法写入 WAL、应用无法写临时文件、SSH 可能登录失败。
# Nginx 日志轮转(/etc/logrotate.d/nginx 通常已存在,确认关键参数)
/var/log/nginx/*.log {
daily
missingok
rotate 14 # 保留 14 天
compress
delaycompress
notifempty
create 0640 www-data adm
sharedscripts
postrotate
[ -f /var/run/nginx.pid ] && kill -USR1 $(cat /var/run/nginx.pid)
endscript
}
# 应用日志(systemd 管理时用 journald 限制总量)
sudo mkdir -p /etc/systemd/journald.conf.d
sudo tee /etc/systemd/journald.conf.d/size.conf >/dev/null <<'EOF'
[Journal]
SystemMaxUse=2G
SystemMaxFileSize=200M
MaxRetentionSec=30day
EOF
sudo systemctl restart systemd-journald
journalctl --disk-usage
# Docker 容器日志同样会涨,限制单容器日志大小
sudo tee /etc/docker/daemon.json >/dev/null <<'EOF'
{
"log-driver": "json-file",
"log-opts": { "max-size": "50m", "max-file": "5" }
}
EOF
sudo systemctl restart docker
磁盘写满的连锁反应
巡检必查项:
df -h中根分区或数据分区使用率超过 85% 必须处理。真实事故链:日志写满/var→ PostgreSQL 无法写 WAL → 数据库拒绝所有写请求 → 应用全量报错 → 磁盘满还会让日志系统本身也无法记录,故障现场被亲手销毁。应急处理时不要直接
rm正在被写入的日志文件(inode 仍被占用,空间不释放)。正确做法:truncate -s 0 /var/log/big.log或先轮转再删除。
7.4 日志中绝不能出现的内容
| 绝不能记录 | 原因 | 替代做法 |
|---|---|---|
| 密码、明文口令 | 日志通常权限较松、会被投递到第三方平台 | 只记录「认证失败」事件与用户 ID |
| 访问令牌、API Key、JWT | 拿到即可冒充用户 | 记录 token 的前 8 位哈希或 jti 用于关联 |
| 银行卡号、身份证号 | 合规红线(个人信息保护) | 掩码显示 6222****1234 |
完整 Authorization / Cookie 头 | 直接等于凭据泄露 | 记录是否存在,不记录值 |
| 会话 ID | 等同凭据 | 记录哈希前缀 |
| 大量个人数据(整个请求体) | 隐私与存储成本双输 | 只记录必要字段与字节数 |
// ✅ 敏感字段统一脱敏后再写日志
const SENSITIVE = new Set(['password','token','authorization','cookie','idCard','cardNo']);
function redact(obj) {
return JSON.parse(JSON.stringify(obj, (k, v) =>
SENSITIVE.has(k.toLowerCase()) ? '[REDACTED]' : v));
}
log('info', 'request.received', { body: redact(req.body) });
7.5 集中式日志的思路
单机 tail -f 在多实例场景下不可用。集中式日志的基本链路:
应用 stdout → 容器运行时/日志代理采集 → 传输 → 集中存储与索引 → 查询与告警
(Fluent Bit) (TLS) (Elasticsearch/Loki)
落地时的四个要点:
- 统一字段名:所有服务都用
ts/level/service/traceId,否则跨服务查询写不出来。 - 带上关联 ID:入口生成
X-Request-Id(Nginx 的$request_id即可),全链路透传,出问题一键捞出整条调用链。 - 区分保留期:错误日志存 90 天,访问日志存 7~14 天,
debug只存几小时。全量长期保存在成本上不可持续。 - 告警挂在错误日志上:日志的价值在于驱动动作。「最近 5 分钟
level=error且event=payment.failed超过 50 条」才是可执行的告警规则。
八、监控与告警
8.1 需要监控的四类指标
Google SRE 提出的四个黄金信号(Four Golden Signals):
| 信号 | 英文 | 含义 | 示例指标 |
|---|---|---|---|
| 延迟 | Latency | 请求耗时,必须区分成功与失败请求的延迟 | http_request_duration_seconds{p95} |
| 流量 | Traffic | 系统承受的负载 | QPS、并发连接数、消息数 |
| 错误 | Errors | 失败请求的比例(显式失败 + 隐式失败如错误内容返回 200) | 5xx 比例、业务失败率 |
| 饱和度 | Saturation | 资源「有多满」,重点看最紧张的那个资源 | CPU 使用率、内存使用率、连接池占用率、磁盘使用率、队列长度 |
两个补充方法论:
- USE 方法(面向资源):对每个资源看 Utilization(使用率)、Saturation(饱和度,排队长度)、Errors(错误计数)。适用于 CPU、内存、磁盘、网卡。
- RED 方法(面向服务):Rate(请求速率)、Errors(错误率)、Duration(耗时分布)。适用于每个微服务与每个对外接口。
饱和度必须监控「最紧张的那个」
平均 CPU 使用率 30% 不代表健康——如果数据库连接池已经 100%,系统实际上已经不可用。连接池、线程池、队列长度、文件句柄这类「有限资源」的占用率,比 CPU 更能提前预测故障。
8.2 健康检查端点的设计
健康检查分两种,用途完全不同,不要混用同一个端点:
| 类型 | 英文 | 回答的问题 | 失败时的动作 |
|---|---|---|---|
| 存活检查 | liveness | 进程是不是卡死了,需不需要重启? | 重启容器 |
| 就绪检查 | readiness | 现在能不能接流量? | 从负载均衡中摘除,不重启 |
// ✅ 分离两个端点
app.get('/livez', (req, res) => {
// 只反映「进程自身是否正常」,绝不检查外部依赖
// 否则数据库抖动会导致所有实例被重启,故障放大
res.status(200).send('ok');
});
app.get('/readyz', async (req, res) => {
const checks = {};
let healthy = true;
// 依赖检查要有超时,不能无限等
try {
await Promise.race([
db.query('SELECT 1'),
new Promise((_, r) => setTimeout(() => r(new Error('db timeout')), 800)),
]);
checks.db = 'ok';
} catch (e) { checks.db = 'fail'; healthy = false; }
try {
await Promise.race([
redis.ping(),
new Promise((_, r) => setTimeout(() => r(new Error('redis timeout')), 500)),
]);
checks.redis = 'ok';
} catch (e) { checks.redis = 'fail'; healthy = false; }
res.status(healthy ? 200 : 503).json({ status: healthy ? 'ok' : 'degraded', checks });
});
/healthz(给 Nginx/负载均衡的轻量版本)与 /readyz(给编排系统的详细版本)分开:前者要极快、无依赖,后者要真实。
「检查依赖是否真的可用」的正确姿势:
| 反模式 | 问题 |
|---|---|
SELECT 1 就认为数据库健康 | 能执行 SELECT 1 不代表能写、能读业务表、连接池有余量 |
| 健康检查里跑重查询 | 检查本身变成负载源,被高频轮询时拖垮数据库 |
| 健康检查无超时 | 依赖卡住时检查挂起,健康检查本身变成线程泄漏 |
| 只检查 TCP 连通 | 端口通但认证失败、逻辑库不存在时依然「健康」 |
| 就绪检查里检查所有依赖 | 一个非关键依赖抖动导致全量实例被摘除 |
健康检查引发的雪崩
典型事故:就绪检查里查询了一个从库,从库因为延迟短暂不可用 → 所有实例同时标记为不就绪 → 负载均衡摘除全部实例 → 服务完全不可用(比原来更糟)。原则是:就绪检查只检查「本实例能否正确处理请求」必需的依赖,非关键依赖降级而不是不就绪。
8.3 可用性计算与「几个 9」
可用性(availability)的经典定义:
其中:
- (Mean Time Between Failures,平均无故障时间)——两次故障之间的平均可用时长;
- (Mean Time To Repair,平均修复时间)——从故障发生到恢复的平均耗时。
这个公式最重要的推论是:提高可用性有两条路,缩短 MTTR 通常比延长 MTBF 性价比高得多。 因为把 MTBF 从 1000 小时提到 2000 小时非常难(要消除几乎所有故障源),而把 MTTR 从 60 分钟压到 10 分钟则可以通过监控、告警、回滚脚本、演练实现。
「几个 9」的对照表(按一年 365 天计算):
| 可用性 | 俗称 | 年停机时间 | 月停机时间 | 周停机时间 |
|---|---|---|---|---|
| 90% | 一个 9 | 36.5 天 | 约 73 小时 | 约 16.8 小时 |
| 99% | 两个 9 | 3.65 天 | 约 7.3 小时 | 约 1.68 小时 |
| 99.9% | 三个 9 | 8.76 小时 | 约 43.8 分钟 | 约 10.1 分钟 |
| 99.95% | 三个半 9 | 4.38 小时 | 约 21.9 分钟 | 约 5.0 分钟 |
| 99.99% | 四个 9 | 52.6 分钟 | 约 4.4 分钟 | 约 1.0 分钟 |
| 99.999% | 五个 9 | 5.26 分钟 | 约 26 秒 | 约 6 秒 |
换算方法(一年按 365 天 = 525600 分钟):
例如 : 分钟 小时。
「几个 9」是预算不是口号
四个 9 意味着全年只能停 52 分钟——这比一次「手动改配置 → 重启服务 → 发现配错 → 改回来」的时间还短。所以承诺几个 9 之前先算两笔账:
① 单点故障:一个数据库实例、一个 Nginx、一条网络链路,任何单点故障的时间都必须计入预算;
② 发布开销:如果每次发布要停 5 分钟,每月发 4 次,光发布就吃掉 240 分钟,四个 9 已经不可能达成——除非做滚动/蓝绿发布。
串联系统的可用性是相乘的:两个各自 99.9% 的组件串联,整体只有 。
8.4 告警疲劳与告警分级
告警疲劳(alert fatigue) 是指告警太多太久没人处理,导致真正重要的告警也被忽略。它比「没有告警」更危险,因为它给了团队虚假的安全感。
分级原则(按「需要多快响应」划分,而不是按「多严重」):
| 级别 | 语义 | 通知方式 | 响应时限 | 例子 |
|---|---|---|---|---|
| P1 紧急 | 用户正在受影响,需立即处理 | 电话/短信/值班呼叫 | 5 分钟内 | 支付接口错误率 > 5%、核心服务全挂 |
| P2 重要 | 即将影响用户或部分功能受损 | 即时消息 @值班人 | 30 分钟内 | 磁盘 90%、证书 14 天内到期、队列积压 |
| P3 一般 | 需要关注但不紧急 | 消息频道/工单 | 当个工作日 | 单实例 CPU 偏高、慢查询增多 |
| P4 提示 | 仅供记录与趋势分析 | 看板/日报 | 无 | 部署完成、容量趋势 |
设计可执行告警的四条规则:
- 告警必须对应动作。写不出「收到告警后第一步做什么」的告警,删掉或降级为看板。
- 用症状而不是原因告警。「CPU 高」是原因候选,「下单接口 p99 超过 2 秒」才是用户症状。优先对症状告警。
- 加抑制与聚合。同一根因引发的 500 条告警合并成一条;正在发布期间抑制相关告警。
- 定期复盘。每月统计「有多少告警是误报/无人处理」,把误报率高的规则调阈值或删掉。
# Prometheus 告警规则示例(概念通用)
groups:
- name: api-slo
rules:
# 症状告警:用户确实受影响
- alert: ApiHighErrorRate
expr: |
sum(rate(http_requests_total{job="order-api",status=~"5.."}[5m]))
/ sum(rate(http_requests_total{job="order-api"}[5m])) > 0.05
for: 3m
labels: { severity: P1 }
annotations:
summary: "下单接口 5xx 比例超过 5%(持续 3 分钟)"
runbook: "https://wiki.internal/runbook/order-api-5xx"
# 饱和度告警:提前预警
- alert: DbConnectionPoolSaturation
expr: db_pool_in_use / db_pool_max > 0.85
for: 10m
labels: { severity: P2 }
九、发布策略
9.1 四种发布策略对比
| 策略 | 做法 | 用户感知 | 资源成本 | 回滚速度 | 回滚难度 | 适用 |
|---|---|---|---|---|---|---|
| 停机发布 | 停旧版本 → 部署新版本 → 启动 | 完全中断 | 1 倍 | 快(再停再起) | 低 | 内部系统、可排期维护窗口 |
| 滚动发布 | 逐批替换实例,替换期间新旧共存 | 基本无感 | 1.x 倍(额外一个批次) | 中(再滚回去) | 中高:需保证新旧版本兼容 | 无状态服务的默认选择 |
| 蓝绿发布 | 部署一整套新环境(绿),验证后切流量 | 无感(切换瞬间) | 2 倍 | 极快(切回蓝) | 低 | 关键业务、需要秒级回滚 |
| 金丝雀发布 | 先给 1%~5% 流量,观察后逐步扩大 | 少量用户先体验 | 1.x 倍 | 快(把金丝雀摘掉) | 低-中 | 高风险变更、需要真实流量验证 |
# 金丝雀发布:按权重把少量流量分给新版本
upstream backend {
server 10.0.1.11:3000 weight=95; # 旧版本 95%
server 10.0.1.21:3000 weight=5; # 新版本 5%(金丝雀)
}
# 按请求头灰度(便于内部先验证)
split_clients "${remote_addr}${http_user_agent}" $canary {
5% new;
* old;
}
upstream backend_old { server 10.0.1.11:3000; }
upstream backend_new { server 10.0.1.21:3000; }
map $canary $backend_upstream {
new backend_new;
old backend_old;
}
server {
location /api/ { proxy_pass http://$backend_upstream; }
}
滚动发布的关键参数(以 Kubernetes Deployment 为例,概念对其他编排系统通用):
spec:
replicas: 6
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1 # 最多 1 个实例不可用 → 容量至少保持 5/6
maxSurge: 1 # 最多多起 1 个实例 → 峰值资源 7/6
minReadySeconds: 10 # 新实例就绪后观察 10 秒再继续,防止「起来了但立刻崩」
progressDeadlineSeconds: 600 # 10 分钟没进展就判定发布失败
滚动发布最容易忽略的前提:新旧版本必须能共存****
滚动期间,新旧实例同时在处理请求。这意味着:
- API 必须向后兼容:新版本不能立刻删除旧字段、不能改变已有字段语义。
- 数据库结构必须同时兼容两个版本(见 9.2 节)。
- 不能依赖「只有一个实例」的假设:内存里缓存的配置、本地定时任务、单例锁,都会因为多实例并存而失效(定时任务会在每个实例上各跑一遍)。
如果做不到兼容,就必须用蓝绿发布(切换瞬间完成)而不是滚动发布。
9.2 数据库迁移与代码发布的先后顺序
这是发布事故的头号来源。核心矛盾:代码可以在秒级回滚,数据库结构变更往往不可回滚(删掉的列、改过的类型,数据已经没了)。
三步走(Expand-Migrate-Contract,先兼容后清理):
| 步骤 | 发布内容 | 数据库状态 | 此时旧代码能跑吗 | 此时新代码能跑吗 |
|---|---|---|---|---|
| ① 扩展(Expand) | 只做数据库变更:加新列(可空或带默认值)、加新表、加索引 | 新旧结构都存在 | ✅ 能(不碰新列) | ❌ 还没发布 |
| ② 迁移(Migrate) | 发布新代码:同时写新旧两处,读优先读新的、回退读旧的 | 双写 | ✅ 能(旧代码读旧列) | ✅ 能 |
| ③ 收缩(Contract) | 数据回填校验完成后,再发布一版:改为只写新列;确认稳定后再删旧列 | 逐步收敛到新结构 | ❌ 已不支持(但此时无需回滚) | ✅ 能 |
具体例子:把 users.name 拆成 first_name / last_name
-- ① 扩展:加列,允许 NULL,不破坏旧代码
ALTER TABLE users ADD COLUMN first_name text;
ALTER TABLE users ADD COLUMN last_name text;
-- 大表加列/加索引要注意锁表时间,生产应在低峰执行或使用并发建索引
// ② 迁移:新代码双写、读新回退旧
async function saveUser(id, { name, firstName, lastName }) {
await db.query(
`UPDATE users SET
first_name = COALESCE($2, first_name),
last_name = COALESCE($3, last_name),
name = COALESCE($4, name) -- 暂时保留旧列,兼容未升级的读路径
WHERE id = $1`,
[id, firstName, lastName, name]);
}
function displayName(row) {
// 读新,缺失时回退旧 —— 保证回填未完成时也正确
if (row.first_name || row.last_name) {
return [row.first_name, row.last_name].filter(Boolean).join(' ');
}
return row.name;
}
-- ③ 收缩:确认所有行已回填且监控无异常后,才删除旧列
UPDATE users SET first_name = split_part(name, ' ', 1)
WHERE first_name IS NULL;
UPDATE users SET last_name = substr(name, length(split_part(name,' ',1)) + 2)
WHERE last_name IS NULL AND position(' ' in name) > 0;
-- 观察至少一个完整的发布周期(比如两周)后再执行
-- ALTER TABLE users DROP COLUMN name;
不可回滚的数据库操作
下面这些操作的后果是代码回滚了数据也回不来,必须单独评审、单独备份、单独安排窗口:
-
DROP TABLE/DROP COLUMN:数据物理消失。-
ALTER COLUMN ... TYPE且新类型无法无损容纳旧值(如text→integer)。- 不带
WHERE的UPDATE/DELETE。- 重命名列(
RENAME COLUMN):旧代码立刻全部报错,等价于一次强制停机。- 在大表上直接
CREATE INDEX(非并发):可能长时间持锁阻塞写入。执行任何结构变更前,先做一次可恢复备份,并在预发环境跑通完整流程。 迁移脚本必须能回答两个问题:① 失败的中间态是什么?② 如何回退(或前滚)?
十、容量与性能
10.1 QPS、响应时间与并发数的关系
三者由利特尔法则(Little's Law)联系:
其中 是系统中的平均并发请求数, 是到达速率(QPS), 是平均响应时间(秒)。
移到工程口径:
代入数字更直观:
| 平均响应时间 | 100 并发能承载的 QPS | 要达到 1000 QPS 需要多少并发 |
|---|---|---|
| 10 ms | 10000 | 10 |
| 50 ms | 2000 | 50 |
| 100 ms | 1000 | 100 |
| 500 ms | 200 | 500 |
| 1 s | 100 | 1000 |
由这个公式得到两个关键结论
1. 响应时间变长会等比放大所需并发。一条慢接口(1 s)在 1000 QPS 下需要 1000 个并发连接;同一台机器上如果有 100 个这样的接口,连接数会瞬间打满。
2. 优化响应时间是最高杠杆的容量手段。响应时间从 500 ms 降到 100 ms,同样并发下承载能力直接 ×5,比加机器便宜得多。
10.2 压测的意义与工具简介
压测要回答的问题不是「能扛多少 QPS」,而是:
- 在目标 QPS 下,p95/p99 延迟是多少?
- 系统的拐点在哪(QPS 再高一点,延迟就非线性上升)?
- 瓶颈在哪一层(CPU、数据库、连接池、网络)?
- 故障恢复能力如何(压力撤掉后延迟能回落吗)?
| 工具 | 特点 | 典型用法 |
|---|---|---|
ab(ApacheBench) | 简单、系统自带可能性高;单线程模型,压不出高并发 | ab -n 10000 -c 100 https://example.com/api/items |
wrk | 多线程 + 事件驱动,能压出真实高并发;支持 Lua 脚本定制请求 | wrk -t4 -c400 -d30s --latency https://example.com/api/items |
k6 | 脚本化(JavaScript)、面向场景、内置阈值断言,适合进 CI | k6 run --vus 200 --duration 60s script.js |
# wrk:4 线程、400 并发连接、持续 30 秒,输出延迟分布
wrk -t4 -c400 -d30s --latency -H "Authorization: Bearer $TOKEN" \
https://example.com/api/items
# 输出关注三行:Requests/sec(吞吐)、Latency 分布(平均/最大)、
# 以及 99% 分位。若 99% 远高于平均值,说明存在长尾。
// k6 脚本:带阈值断言,可直接在 CI 里做性能门禁
import http from 'k6/http';
import { check } from 'k6';
export const options = {
stages: [
{ duration: '30s', target: 50 }, // 逐步加压
{ duration: '1m', target: 200 }, // 维持目标负载
{ duration: '30s', target: 0 }, // 降压
],
thresholds: {
http_req_duration: ['p(95)<300', 'p(99)<800'], // 超阈值则失败
http_req_failed: ['rate<0.01'],
},
};
export default function () {
const res = http.get(`${__ENV.BASE_URL}/api/items`);
check(res, { 'status is 200': (r) => r.status === 200 });
}
压测的四条纪律
1. 绝不在生产环境直接压测,除非已与所有相关方确认并做好限流兜底——压测很可能把真实用户打挂。
2. 压测数据要接近真实分布,不要每次都命中同一条缓存记录,否则测出的是缓存的性能不是系统的性能。
3. 压测机不能是瓶颈。一个
wrk客户端通常压不满服务端,需要多台压测机,先在压测机上top确认它不是瓶颈。4. 在预发环境做,且配置与生产一致。用 1 台机器的预发环境测出的结论不能外推到 10 台生产。
10.3 扩容的两种方式
| 方式 | 英文 | 做法 | 优点 | 上限 | 适用 |
|---|---|---|---|---|---|
| 垂直扩容 | Scale Up | 给单机加 CPU/内存/带宽 | 无需改代码、无分布式复杂度 | 有硬上限(单机最大规格)且成本非线性上升 | 数据库主库、无法水平扩展的有状态服务 |
| 水平扩容 | Scale Out | 加更多实例,前面放负载均衡 | 理论上无上限、成本线性、具备冗余 | 要求应用无状态或状态外置 | 无状态 Web/API 服务 |
10.4 无状态服务为什么能水平扩容
有状态的服务把「上一次请求产生的数据」放在本机内存或本地磁盘。此时加实例会导致:
- 用户的第一个请求打到实例 A,第二个请求打到实例 B,B 上没有会话 → 用户被要求重新登录;
- 本地缓存不一致 → 用户看到「数据闪回」;
- 本地上传的文件在 B 上不存在 → 404。
无状态的做法是把所有状态外置:
| 状态类型 | 无状态化方案 |
|---|---|
| 会话(Session) | JWT(状态在令牌里)或共享 Session 存储(Redis) |
| 缓存 | 集中式缓存(Redis)、或可容忍不一致的本地缓存 + 版本号 |
| 上传文件 | 对象存储(S3/OSS/COS),而不是本地磁盘 |
| 定时任务 | 分布式锁选主,或独立的调度服务(避免每个实例各跑一遍) |
| 配置 | 配置中心或环境变量,变更可推送 |
| 序列号/计数器 | 数据库序列、Redis INCR、雪花算法 |
做到这些之后,任何实例都能处理任何请求,于是:
实际上因为有共享依赖(数据库、缓存),会有折扣,但扩容变成可预测的线性操作,这才是水平扩容的真正价值。
无状态服务仍需检查共享依赖
从 2 个实例扩到 20 个之后,数据库连接数会变成原来的 10 倍,往往会先把数据库连接池打满。扩容前必须同步核算:数据库最大连接数、连接池配置、下游 API 的配额的余量。
十一、备份与容灾
11.1 备份的 3-2-1 原则
| 数字 | 含义 | 防范的风险 |
|---|---|---|
| 3 | 保留 3 份数据副本(1 份生产 + 2 份备份) | 单份损坏 |
| 2 | 存放在 2 种不同介质/系统上 | 同一系统的系统性缺陷 |
| 1 | 至少 1 份在异地(off-site) | 机房级灾难、勒索软件加密同网段所有备份 |
# PostgreSQL 逻辑备份(小库、需要跨版本迁移时用)
pg_dump -Fc -h db.internal -U appuser appdb > /backup/appdb-$(date +%F).dump
# 物理备份 + 持续归档(大库、要求低 RPO)
# 使用 pg_basebackup 做基础备份,配合 WAL 归档实现时间点恢复(PITR)
pg_basebackup -h db.internal -U replicator -D /backup/base-$(date +%F) -Ft -z -P
# MySQL 逻辑备份(一致性与锁的取舍)
mysqldump --single-transaction --routines --triggers \
-h db.internal -u appuser -p appdb | gzip > /backup/appdb-$(date +%F).sql.gz
# 上传到异地对象存储(3-2-1 中的那个「1」)
aws s3 cp /backup/appdb-$(date +%F).dump s3://my-backups/appdb/ --storage-class STANDARD_IA
| 备份类型 | 优点 | 缺点 | 适用 |
|---|---|---|---|
| 全量备份 | 恢复最简单(一个文件) | 慢、占空间 | 每周一次 |
| 增量/差异备份 | 快、省空间 | 恢复要串起多个文件 | 每日 |
| 持续归档(WAL/binlog) | RPO 可到秒级 | 运维复杂 | 核心库 |
11.2 备份没有验证过等于没有备份
这是运维里最贵的一句话。未验证的备份会在最需要它的那一刻失效,而失效原因往往是低级问题:
- 备份脚本半年前就静默失败了(磁盘满、权限变了、密码过期),只有文件时间戳是旧的;
pg_dump只导了结构没导数据(漏了参数);- 备份文件加密了但密钥没人知道;
- 恢复出来的库字符集/时区不对,应用启动即报错;
- 恢复流程依赖一台已经不存在的机器。
一次真实的恢复演练步骤(建议每月或每季度执行一次,写进值班手册):
# ========== 第 0 步:准备一台干净的练习机(绝不碰生产) ==========
# 这是演练的关键:在全新的环境里恢复,才能暴露「只存在于生产机器上的隐性依赖」
# ========== 第 1 步:从远端取回最新备份 ==========
aws s3 ls s3://my-backups/appdb/ | tail -5
aws s3 cp s3://my-backups/appdb/appdb-2026-10-10.dump /tmp/restore/
# 记录时间:这决定了 RTO 的一部分
date +%s > /tmp/restore/t0
# ========== 第 2 步:校验备份文件完整性 ==========
ls -lh /tmp/restore/appdb-2026-10-10.dump
# 有校验和就必须验;没有校验和本身就是个待改进项
sha256sum /tmp/restore/appdb-2026-10-10.dump
# 自定义格式备份可以列出目录,确认文件可读、内容存在
pg_restore -l /tmp/restore/appdb-2026-10-10.dump | head -20
# ========== 第 3 步:恢复到全新数据库实例 ==========
docker run -d --name restore-test -p 55432:5432 \
-e POSTGRES_PASSWORD=restoretest postgres:16-alpine
sleep 10
createdb -h 127.0.0.1 -p 55432 -U postgres restorecheck
pg_restore -h 127.0.0.1 -p 55432 -U postgres -d restorecheck \
--no-owner --no-privileges /tmp/restore/appdb-2026-10-10.dump
# ========== 第 4 步:验证数据「真的能用于业务」 ==========
# 注意:不是「能连上」,而是校验关键业务表
psql -h 127.0.0.1 -p 55432 -U postgres -d restorecheck <<'SQL'
SELECT 'users' AS t, count(*) FROM users
UNION ALL SELECT 'orders', count(*) FROM orders
UNION ALL SELECT 'payments', count(*) FROM payments;
-- 与生产当天的行数对比(允许有少量差异,量级必须一致)
SELECT max(created_at) AS latest_order FROM orders;
-- 校验最近一笔订单的关键字段是否完整
SELECT id, user_id, amount, status FROM orders ORDER BY created_at DESC LIMIT 5;
SQL
# ========== 第 5 步:让应用真的连上去跑一遍 ==========
# 这一步最容易被跳过,也最能暴露问题
DATABASE_URL="postgres://postgres:restoretest@127.0.0.1:55432/restorecheck" \
npm run smoke-test # 或启动服务后 curl 关键接口
# ========== 第 6 步:记录实测 RTO,归档演练报告 ==========
date +%s > /tmp/restore/t1
echo "实际恢复耗时: $(( $(cat /tmp/restore/t1) - $(cat /tmp/restore/t0) )) 秒"
演练报告要回答:
| 项目 | 内容 |
|---|---|
| 恢复耗时 | 实测值,用于校准 RTO 承诺 |
| 数据丢失窗口 | 最新一条业务数据的时间戳与备份时间之差,用于校准 RPO |
| 遇到的障碍 | 权限、密钥、依赖缺失、脚本报错——每一条都要转成待办 |
| 数据校验结果 | 关键表行数、金额合计、最新记录时间 |
| 结论 | 备份是否可恢复;RTO/RPO 是否达标 |
恢复演练的两个禁区
1. 绝不在生产库实例上做恢复演练。
pg_restore到已存在的库会先删对象,等于人为制造数据丢失事故。必须用全新实例。2. 绝不用「看起来像生产数据」的备份文件随便放到测试环境。真实用户数据进入非生产环境通常违反合规要求。演练完成后立即销毁练习实例与备份文件:
docker rm -f restore-test && shred -u /tmp/restore/*.dump。
11.3 RPO 与 RTO
| 指标 | 英文 | 定义 | 回答的问题 | 由什么决定 |
|---|---|---|---|---|
| RPO | Recovery Point Objective | 恢复点目标:能接受丢失多长时间的数据 | 灾难后,数据回到哪个时间点? | 备份频率、是否开启 WAL/binlog 持续归档 |
| RTO | Recovery Time Objective | 恢复时间目标:能接受停机多久 | 从故障到恢复服务需要多久? | 备用环境是否就绪、恢复流程是否演练过、是否自动化 |
举例说明业务含义:
| 场景 | 合理 RPO | 合理 RTO | 对应方案 |
|---|---|---|---|
| 内部 Wiki | 24 小时 | 8 小时 | 每日全量备份,手工恢复 |
| 电商订单库 | 5 分钟 | 30 分钟 | binlog 持续归档 + 热备实例 + 自动化切换 |
| 支付核心 | 接近 0 | 几分钟 | 同步复制 + 多可用区 + 自动故障转移 |
RPO/RTO 是业务决策,不是技术决策
工程团队应该拿着成本曲线去和业务方对齐:RPO 从 24 小时降到 5 分钟,可能意味着要加实时归档链路和常驻备库,成本翻几倍。「我们尽力做到最好」不是答案,明确的数字与对应的成本才是。对齐结果要写下来并据此设计架构,而不是事后解释为什么没做到。
十二、故障排查流程
12.1 从告警到定位的检查清单
按顺序执行,每一步都先看数据再动手改(瞎改会破坏故障现场,让根因不可考):
┌─ 第 1 步:最近有什么变更? ───────────────────────────────┐
│ · 最近 1 小时有没有发布?(代码、配置、数据库迁移) │
│ · 有没有基础设施变更?(扩缩容、证书、DNS、防火墙规则) │
│ · 结论若为「有变更」→ 优先考虑回滚,而不是继续调试 │
└──────────────────────────────────────────────────────────┘
↓ 无变更
┌─ 第 2 步:错误率与延迟曲线 ──────────────────────────────┐
│ · 是全量失败还是部分失败?是某个接口还是所有接口? │
│ · 延迟是「均匀变慢」还是「长尾变差」(p99 飙升而 p50 正常)?│
│ · 变化是从什么时候开始的?与某个事件时间点是否吻合? │
└──────────────────────────────────────────────────────────┘
↓
┌─ 第 3 步:看依赖 ───────────────────────────────────────┐
│ · 数据库:连接数、慢查询、复制延迟、锁等待 │
│ · 缓存:命中率、连接数、是否在驱逐 key │
│ · 下游 API:错误率、超时率、配额是否用尽 │
│ · 结论若为「依赖挂了」→ 决定是降级还是熔断 │
└──────────────────────────────────────────────────────────┘
↓
┌─ 第 4 步:看资源 ───────────────────────────────────────┐
│ · CPU / 内存 / 磁盘 / 网络(df -h、free -h、top、ss) │
│ · 连接池与线程池占用率、文件句柄数、队列长度 │
│ · 有无 OOM 记录(dmesg -T | grep -i oom) │
└──────────────────────────────────────────────────────────┘
↓
┌─ 第 5 步:看日志 ───────────────────────────────────────┐
│ · 按 traceId 捞出完整调用链 │
│ · 找第一个错误(不是最后一条——最后一条往往是次生错误) │
│ · 看 `level=error` 前后的 `warn`,warn 常包含根因线索 │
└──────────────────────────────────────────────────────────┘
四类问题的快速区分:
| 症状 | 高度可疑 | 第一步验证 |
|---|---|---|
| 延迟均匀上升、吞吐下降 | 资源饱和(CPU/连接池/磁盘 IO) | top、ss -s、连接池指标 |
| 延迟长尾变差(p99 飙升,p50 正常) | GC 停顿、慢查询、单点热点、锁竞争 | 看 GC 日志、慢查询日志 |
| 部分请求 5xx | 个别实例故障、依赖部分不可用 | 按实例分组看错误率 |
| 全量 5xx、连接被拒 | 进程挂了、端口未监听、被限流 | ss -ltnp、容器状态、上游限流日志 |
12.2 通用急救原则
- 先止血,再找根因。用户还在受影响时,第一优先级是恢复服务(回滚、扩容、切流量),根因分析放到事后复盘。
- 一次只改一个变量。同时改三处,好了不知道哪处起效,坏了不知道哪处致错。
- 保留现场。抓一份线程栈、内存快照、
ss -s输出、日志归档再重启进程。 - 记录时间线。每个操作与观察都记时间戳,事后复盘靠它。
- 别在故障时做「顺手优化」。「既然在重启,顺便把配置也升一下」是灾难的常见起点。
十三、上线检查清单
新服务上线前必须逐项确认的 15 项
| # | 检查项 | 确认标准 | 类别 |
|---|---|---|---|
| 1 | 配置与代码分离 | 所有环境相关值来自环境变量;代码库中无硬编码的地址与密码 | 配置 |
| 2 | 密钥不入库 |
.gitignore覆盖.env/*.pem;CI 有密钥扫描 | 安全 || 3 | 非 root 运行 | 容器
USER非 root;文件权限最小化 | 安全 || 4 | HTTPS 与证书 | 强制跳转 HTTPS;证书链完整;续期任务已配置且做过
--dry-run| 安全 || 5 | 到期告警 | 证书 14 天前告警、域名到期告警、磁盘 85% 告警均已配置 | 监控 |
| 6 | 健康检查 |
/livez与/readyz分离;就绪检查含关键依赖且有超时 | 可用性 || 7 | 资源限制 | CPU 与内存上限已设置(容器
--memory/--cpus或编排resources.limits) | 稳定性 || 8 | 日志 | 结构化输出到 stdout;日志中无密码/令牌;轮转与总量上限已配置 | 运维 |
| 9 | 监控与告警 | 四类指标齐全;告警分级明确;每条告警都有对应的处理动作 | 监控 |
| 10 | 备份 | 备份任务运行中且有成功告警;已在干净环境完成一次恢复演练 | 容灾 |
| 11 | 回滚方案 | 回滚命令写在文档里并演练过;上一个版本的镜像/产物仍可用 | 发布 |
| 12 | 发布策略 | 滚动/蓝绿/金丝雀已选定;旧版本兼容性已确认(含数据库变更的三步走) | 发布 |
| 13 | 容量评估 | 已按目标 QPS 压测;p95/p99 达标;扩容路径明确 | 性能 |
| 14 | 端口与防火墙 | 数据库等内部服务未暴露公网;安全组与主机防火墙双层已放行 80/443/22 | 安全 |
| 15 | 值班与文档 | 有 runbook(每个告警对应处置步骤)、有联系人、有故障升级路径 | 流程 |
十四、常见坑
高频踩坑清单
1.
sudo ufw enable前没放行 22 → 直接断掉 SSH,重装系统。2. 禁用 SSH 密码登录前没验证密钥 → 自己被锁在门外。
3. 只提供服务器证书,没提供中间证书链 → 部分客户端(尤其移动端)报证书错误。
4. ACME 校验路径被 301 到 HTTPS → 续期静默失败,90 天后集体爆雷。
5. 没有证书到期告警 → 到期当天才发现,全站不可用。
6. 一上来就
preload+includeSubDomains→ 某个子域没有证书,整站被浏览器拒绝访问,且撤回要等数月。7. 应用直接信任
X-Forwarded-For的第一个值 → 攻击者可以伪造 IP 绕过限流。8. Nginx
proxy_read_timeout默认 60s → WebSocket 和长轮询每分钟断一次。9. WebSocket 没配
Connection "upgrade"→ 握手失败,返回 400 或直接断开。10.
client_max_body_size没调 → 上传大文件报 413,且在应用日志里什么都看不到(请求没到应用)。11. 应用自己写日志文件而非 stdout → 容器重建后日志丢失,且磁盘被静默写满。
12. 日志里打了完整
Authorization头 → 日志系统成了凭据泄露源。13. 磁盘写满后
rm正在写入的日志 → 空间不释放(inode 仍被占用),继续满。14. 滚动发布时新旧版本不兼容 → 发布过程中部分请求 500,且回滚也报错。
15. 发布里包含
DROP COLUMN→ 代码回滚了数据也回不来。16. 健康检查里查从库 → 从库抖动导致全量实例被摘除,故障放大。
17. 定时任务在多实例上各跑一遍 → 重复扣款、重复发券。要用分布式锁或独立调度。
18. 扩容时忘了数据库连接池 → 应用扩到 20 实例,数据库连接被打满,比扩容前更糟。
19. 备份从未验证 → 真正恢复时才发现备份脚本半年前就失败了。
20. 告警全部是 P1 → 告警疲劳,真正的事故被淹没。
十五、练习题
练习 1:可用性计算
某服务由三部分组成:Nginx(可用性 99.99%)、应用(三个实例,单实例 99.5%,任一个可用即可)、PostgreSQL 单实例(99.9%)。全部串联(应用层取「至少一个实例可用」的可用性)。请计算整体可用性,并指出最值得优先加固的组件。
参考思路:应用层「至少一个可用」,近似按 100% 计。整体 。年停机约 分钟 ≈ 9.6 小时。最值得加固的是 PostgreSQL——它是单点且可用性最低,把它做到 99.99%(主从 + 自动故障转移)可让整体提升到约 99.98%/99.99%。同时注意 Nginx 也是单点。
练习 2:并发与容量估算
某接口平均响应时间 80 ms,p99 为 900 ms。目标 QPS 为 2000。请计算所需的平均并发连接数。如果实测发现有 1% 的请求占用 900 ms,其余 99% 占用 40 ms,重新计算平均响应时间与所需并发,并说明为什么「按平均值规划」有风险。
参考思路:按 80 ms 计,。按实际分布: s,。风险在于:平均值掩盖了瞬时并发。900 ms 的请求会长期占用连接,2000 QPS 下每秒钟有 20 个这样的请求,瞬时堆积约 个长占用连接,而连接池若按 97 配置,遇到长尾请求集中出现就会排队,进而让延迟进一步上升,形成正反馈。
练习 3:Nginx 反向代理配置
为一个 Node 应用(监听 3000 端口,两个实例 3000/3001)写一份 Nginx 配置,要求:① HTTP 全部 301 跳到 HTTPS;② 保留 ACME 校验路径;③ 转发正确的客户端 IP 与协议;④
/api/路径限流 20r/s、突发 20、超限返回 429;⑤ 支持 WebSocket;⑥ 静态资源缓存一年。写出完整配置并说明每一行为什么需要。参考要点:见第 4.2 节。特别要检查:
limit_req_zone定义在http块;limit_req_status 429(默认是 503,会让客户端误以为是服务端故障);WebSocket 的proxy_read_timeout要放大;location ^~ /.well-known/acme-challenge/用^~确保不被其他正则 location 抢走,且其中的请求不跳 HTTPS。
练习 4:数据库变更的发布顺序
需要把
orders.amount(单位:元,numeric(10,2))改为以「分」为单位的整数列amount_cents,并删除旧列。请写出完整的三步走发布计划,并说明每一步之后旧代码与新代码分别能否正常工作、以及如果中途出问题如何回滚。参考要点:① Expand:加
amount_cents bigint(可空或默认 0),不删旧列。此时旧代码完全不受影响,回滚只需删新列(或直接不管)。② Migrate:发布双写版本(写amount的同时写amount_cents = round(amount100));读取优先amount_cents,为 NULL 时回退amount100。回填历史数据(分批,避免长事务);这一步可以安全回滚到旧版本,因为旧列仍在被正确维护。③ Contract:观察一个完整周期,确认amount_cents无 NULL(可加NOT NULL约束)、读数一致后,再发布只写新列的版本;最后一步单独发一次变更删掉amount。注意每个删除动作都要单独备份与窗口安排。
练习 5:备份恢复演练设计
你的团队每月做一次全量
pg_dump上传到对象存储,但从未恢复过。请设计一次完整的恢复演练方案,要求包含:干净环境、完整性校验、数据正确性验证、应用可用性验证、RTO 实测,以及 3 个「必须写进待办」的改进项识别点。参考要点:流程与命令见第 11.2 节。识别改进项的三个关键点:① 完整性校验阶段——若备份文件没有校验和,说明备份可靠性无法自证;② 应用启动验证阶段——若应用无法用恢复的数据启动(版本不匹配、缺少迁移记录),说明恢复目标不明确;③ 记录耗时阶段——若 RTO 实测远超承诺,说明需要自动化脚本或热备而非人工恢复。另外必须检查:备份任务的成功告警是否存在(没有告警等于不知道是否在成功)。
十六、FAQ
小项目有必要一开始就上 Nginx 吗?直接用 Node 监听 80 端口不行吗?
技术上可行,但代价很高:① 80/443 需要 root 权限,应用必须以 root 启动;② 证书更换要重启应用;③ 单进程应用一旦崩溃,整个服务不可用且无法灰度;④ 静态文件由应用发送效率低。Nginx 只增加很少的资源开销,却把 TLS、静态资源、限流、灰度这些横切关注点与应用解耦。建议从第一天就用,哪怕只有一个后端实例。
服务器上应该用 systemd 还是容器来跑服务?
两者不是对立的。常见组合是「宿主机上 systemd 管理 Nginx 与容器运行时,容器内跑应用」。纯 systemd 的优点是没有容器层、调试直观;纯容器的优点是环境一致、交付标准化。判断标准:如果应用已经容器化(见 后端-07-Docker与容器化),就用
docker compose+restart: unless-stopped,并在宿主机上用 systemd 拉起 compose 项目实现开机自启;如果应用依赖宿主机环境或性能敏感,直接用 systemd 更简单。
「无状态」说起来容易,但登录会话怎么办?
两种主流方案:① JWT:状态编码在令牌里,服务端不存储。优点是真正无状态、跨服务方便;缺点是无法立即失效(用户登出或被封禁后令牌在过期前仍有效),缓解手段是短有效期 + 刷新令牌 + 服务端维护一个小的吊销名单。② 共享 Session(Redis):服务端无本地状态,但依赖 Redis。优点是可以立即失效、可以主动踢人;缺点是引入一个必须高可用的依赖。多数业务系统用方案 ②,对幂等性与可控性要求高的场景更合适。
监控和日志,先做哪个?
先做日志,再做指标。理由:日志是排障时唯一能提供细节的东西,而指标只能告诉你「哪里不对」。但告警应优先基于指标,因为指标聚合后噪声低、可做趋势判断,而基于日志文本的告警极易误报。务实顺序:结构化日志 → 关键指标(四类信号)→ 健康检查 → 分级告警 → 集中式日志检索。
如何说服团队不要每次都手动改生产配置?
用数字。统计过去三个月里「手动改配置引发的故障」次数与总耗时(包括发现、定位、恢复、沟通)。这个数字通常远大于「写自动化脚本」的成本。同时给出具体替代方案:配置进版本控制 + 一条可回滚的部署命令 + 演练过的回滚流程。把讨论从「应不应该」转到「优先级排第几」。
相关笔记
- 后端-07-Docker与容器化——把应用打包成可部署的不可变镜像,是本文一切部署流程的前提
- 工具-08-CICD入门——把构建、测试、镜像推送与部署自动化,减少手工步骤带来的故障
- 后端-09-后端安全与性能——上线前的安全加固与性能压测方法
- 计算机网络——DNS、TCP、TLS 握手与反向代理依赖的网络基础
- 工具-02-命令行与Shell——本文大量运维命令的 Shell 基础
- 后端-05-数据库操作与ORM——慢查询、连接池与事务,是容量与故障排查的核心环节
参考来源
- The Twelve-Factor App(简体中文)
- Nginx 官方文档:ngx_http_proxy_module(proxy_set_header / proxy_read_timeout 等)
- Nginx 官方文档:ngx_http_upstream_module(负载均衡策略与 keepalive)
- Nginx 官方文档:Configuring HTTPS servers(证书链与 SNI)
- Nginx 官方文档:ngx_http_limit_req_module(漏桶限流)
- Kubernetes 中文文档:Deployments(滚动发布策略)
- Kubernetes 中文文档:为 Pod 和容器管理资源
- PostgreSQL 官方文档:Transaction Isolation(隔离级别与串行化失败重试)
- Redis 官方文档:Distributed locks(分布式锁)
- Redis 官方文档:Key eviction(maxmemory 与淘汰策略)
- OWASP Cheat Sheet:HTTP Strict Transport Security
- OWASP Cheat Sheet:Secrets Management
- OWASP Cheat Sheet:Logging
- RFC 9110:HTTP Semantics(方法语义、状态码、缓存与条件请求)
- 具体版本号、默认参数与云平台操作界面以各官方文档最新说明为准。