w wyl123ly 的博客
MD

后端-08-部署与运维基础

83 KB 2026.10.11 原文件

后端-08-部署与运维基础

这篇讲什么

从「本地能跑」到「线上可用」,中间隔着的不是一行部署命令,而是一整套工程实践:环境隔离、进程守护、反向代理、TLS 证书、日志、监控、备份、回滚。

本篇给出可以直接使用的 Nginx 配置、SSH 加固步骤、恢复演练脚本、健康检查设计,并把可用性、容量、发布策略这些「凭感觉」的话题量化成可计算的公式。

读完你应该能做到:① 把一台干净的 Linux 服务器加固到可以放生产服务;② 独立部署一个带 HTTPS 和反向代理的服务;③ 说出至少三个 9 的实际停机预算;④ 设计一套能真正发现故障的监控告警。

一、从「本地能跑」到「线上可用」缺什么

在本地,你是唯一的用户,网络是零延迟,磁盘不会满,进程崩了你手动再起一次。线上这些前提全部不成立。缺的正好是八件事:

缺口本地状态线上必须解决的问题本文对应章节
环境隔离你的电脑只有你的项目多服务共存、依赖不冲突、可回滚第 2、6 节
进程守护终端关了就没了崩溃自动重启、开机自启、日志留存第 3 节
反向代理直接访问 localhost:3000域名、80/443 统一入口、TLS 终止、负载均衡第 4 节
域名与证书http://localhostDNS 解析、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-waitTIME_WAIT 过多说明短连接密集
跟踪日志journalctl -u mysvc -fsystemd 管理的服务统一入口
实时看日志尾部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)

落地时的四个要点:

  1. 统一字段名:所有服务都用 ts/level/service/traceId,否则跨服务查询写不出来。
  2. 带上关联 ID:入口生成 X-Request-Id(Nginx 的 $request_id 即可),全链路透传,出问题一键捞出整条调用链。
  3. 区分保留期:错误日志存 90 天,访问日志存 7~14 天,debug 只存几小时。全量长期保存在成本上不可持续。
  4. 告警挂在错误日志上:日志的价值在于驱动动作。「最近 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%一个 936.5 天约 73 小时约 16.8 小时
99%两个 93.65 天约 7.3 小时约 1.68 小时
99.9%三个 98.76 小时约 43.8 分钟约 10.1 分钟
99.95%三个半 94.38 小时约 21.9 分钟约 5.0 分钟
99.99%四个 952.6 分钟约 4.4 分钟约 1.0 分钟
99.999%五个 95.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 提示仅供记录与趋势分析看板/日报无部署完成、容量趋势

设计可执行告警的四条规则:

  1. 告警必须对应动作。写不出「收到告警后第一步做什么」的告警,删掉或降级为看板。
  2. 用症状而不是原因告警。「CPU 高」是原因候选,「下单接口 p99 超过 2 秒」才是用户症状。优先对症状告警。
  3. 加抑制与聚合。同一根因引发的 500 条告警合并成一条;正在发布期间抑制相关告警。
  4. 定期复盘。每月统计「有多少告警是误报/无人处理」,把误报率高的规则调阈值或删掉。
# 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 ms1000010
50 ms200050
100 ms1000100
500 ms200500
1 s1001000

由这个公式得到两个关键结论

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)、面向场景、内置阈值断言,适合进 CIk6 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

指标英文定义回答的问题由什么决定
RPORecovery Point Objective恢复点目标:能接受丢失多长时间的数据灾难后,数据回到哪个时间点?备份频率、是否开启 WAL/binlog 持续归档
RTORecovery Time Objective恢复时间目标:能接受停机多久从故障到恢复服务需要多久?备用环境是否就绪、恢复流程是否演练过、是否自动化

举例说明业务含义:

场景合理 RPO合理 RTO对应方案
内部 Wiki24 小时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 通用急救原则

  1. 先止血,再找根因。用户还在受影响时,第一优先级是恢复服务(回滚、扩容、切流量),根因分析放到事后复盘。
  2. 一次只改一个变量。同时改三处,好了不知道哪处起效,坏了不知道哪处致错。
  3. 保留现场。抓一份线程栈、内存快照、ss -s 输出、日志归档再重启进程。
  4. 记录时间线。每个操作与观察都记时间戳,事后复盘靠它。
  5. 别在故障时做「顺手优化」。「既然在重启,顺便把配置也升一下」是灾难的常见起点。

十三、上线检查清单

新服务上线前必须逐项确认的 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——慢查询、连接池与事务,是容量与故障排查的核心环节

参考来源