1
2
3

                   生产排障黄金六步法                        
  1. 发现告警 → 2. 初步评估 → 3. 紧急止血 → 4. 定位根因      
  5. 彻底修复 → 6. 复盘预防     

1
2
3
4
5
6
7
8

                     应用层 (Application)                    
  代码逻辑 | 配置错误 | 依赖服务 | 业务异常 | 缓存失效       
                     系统层 (System)                         
  CPU过载 | 内存泄漏 | 磁盘满 | 文件句柄 | 进程崩溃         
                     网络层 (Network)                        
  DNS故障 | 路由异常 | 防火墙 | 负载均衡 | 带宽耗尽         
                     硬件层 (Hardware)                       
  磁盘损坏 | 内存故障 | 网卡异常 | 电源问题 | 机房断电       

1
2
3

1. 谁操作：明确责任人，禁止无授权变更                      
2. 何时操作：避开业务高峰，选择低峰期                      
3. 如何回滚：必须有回滚预案，15分钟内可执行                

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 找出占用CPU最高的进程
top -b -n 1 | head -20

# 2. 查看该进程的线程
top -H -p <PID>

# 3. 将线程ID转换为16进制
printf "%x\n" <TID>

# 4. 查看该线程的堆栈
jstack <PID> | grep -A 30 <16进制TID>

# 5. 如果是Java应用，查看GC情况
jstat -gc <PID> 1000 10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看整体内存使用
free -h

# 2. 查看是否有swap使用
vmstat 1 5 | grep -E "swpd|si|so"

# 3. 找出内存占用最高的进程
ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%mem | head -20

# 4. 查看进程详细内存
cat /proc/<PID>/status | grep -E "VmRSS|VmSize|VmSwap"

# 5. 检查是否有OOM Killer
dmesg | grep -i "oom\|killed"

1
2
3
4
5
6
7
8
9

# 查看OOM日志
grep -i "out of memory" /var/log/messages
grep -i "killed process" /var/log/syslog

# 查看进程OOM分数
cat /proc/<PID>/oom_score_adj

# 调整OOM优先级（分数越低越不容易被杀）
echo -500 > /proc/<PID>/oom_score_adj

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 1. 查看整体IO情况
iostat -xz 1 5

# 关键字段说明：
# %util: 磁盘利用率，>80%表示瓶颈
# await: 平均等待时间，>10ms表示慢
# svctm: 服务时间

# 2. 找出IO高的进程
iotop -o -b -n 5

# 3. 查看进程打开的文件
lsof -p <PID> | grep REG

# 4. 查看磁盘空间
df -hT

# 5. 查看inode使用
df -i

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 1. 查看系统级限制
cat /proc/sys/fs/file-max

# 2. 查看当前使用
cat /proc/sys/fs/file-nr

# 3. 查看进程级限制
ulimit -n

# 4. 找出打开文件最多的进程
for i in /proc/[0-9]*/fd; do echo $(ls $i | wc -l) $i; done | sort -rn | head -20

# 5. 临时提高限制
ulimit -n 65535

# 6. 永久修改（/etc/security/limits.conf）
echo "* soft nofile 65535" >> /etc/security/limits.conf
echo "* hard nofile 65535" >> /etc/security/limits.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 查看inode使用
df -i

# 2. 找出inode使用最高的目录
for i in /*; do echo $(find $i 2>/dev/null | wc -l) $i; done | sort -rn | head -10

# 3. 找出小文件最多的目录
find /var -type f -size -1k | wc -l

# 4. 清理小文件（谨慎操作）
find /tmp -type f -atime +7 -delete

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 检查本地端口监听
netstat -tuln | grep 端口号

# 2. 检查连接状态
netstat -an | grep ESTABLISHED | wc -l
netstat -an | grep TIME_WAIT | wc -l

# 3. 检查防火墙规则
iptables -L -n | grep 端口号
firewall-cmd --list-ports

# 4. 抓包分析
tcpdump -i eth0 -w capture.pcap port 8080

# 5. 分析TCP状态
ss -s

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 查找僵尸进程
ps aux | grep defunct

# 2. 查找父进程
ps -o ppid= -p <僵尸进程PID>

# 3. 终止父进程（谨慎）
kill -9 <父进程PID>

# 4. 如果父进程是init，只能重启系统

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 统计错误数量
grep -c "ERROR" /var/log/app.log

# 2. 查看最近100行
tail -n 100 /var/log/app.log

# 3. 实时过滤关键字
tail -f /var/log/app.log | grep -i "exception"

# 4. 统计访问IP排行
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10

# 5. 统计状态码分布
awk '{print $9}' access.log | sort | uniq -c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 1. 查看TIME_WAIT数量
netstat -n | grep TIME_WAIT | wc -l

# 2. 查看TIME_WAIT详情
netstat -n | grep TIME_WAIT

# 3. 临时优化（立即回收）
echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse

# 4. 缩短TIME_WAIT时间
echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

# 5. 扩大本地端口范围
echo "1024 65535" > /proc/sys/net/ipv4/ip_local_port_range

# 6. 永久修改（/etc/sysctl.conf）
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.ip_local_port_range = 1024 65535

1
2
3
4
5
6
7
8

# 1. 查看SYN_RECV数量
netstat -n | grep SYN_RECV | wc -l

# 2. 查看来源IP分布
netstat -n | grep SYN_RECV | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -10

# 3. 抓包分析
tcpdump -i eth0 'tcp[tcpflags] & tcp-syn != 0' -w syn.pcap

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 开启SYN Cookie
echo 1 > /proc/sys/net/ipv4/tcp_syncookies

# 2. 增加半连接队列
echo 2048 > /proc/sys/net/ipv4/tcp_max_syn_backlog

# 3. 限制SYN速率（iptables）
iptables -A INPUT -p tcp --syn -m limit --limit 1/s --limit-burst 3 -j ACCEPT

# 4. 使用防火墙防护
iptables -A INPUT -p tcp --syn -m recent --name synflood --rcheck --seconds 60 --hitcount 20 -j DROP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 1. 测试DNS解析
nslookup 域名
dig 域名
host 域名

# 2. 查看本地DNS配置
cat /etc/resolv.conf

# 3. 测试DNS响应时间
time nslookup 域名

# 4. 查看DNS缓存
systemctl restart nscd  # 清除缓存

# 5. 测试多个DNS服务器
dig @8.8.8.8 域名
dig @114.114.114.114 域名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 修改DNS配置
echo "nameserver 8.8.8.8" > /etc/resolv.conf
echo "nameserver 114.114.114.114" >> /etc/resolv.conf

# 2. 配置本地hosts
echo "1.2.3.4 域名" >> /etc/hosts

# 3. 安装本地DNS缓存
yum install nscd -y
systemctl enable nscd
systemctl start nscd

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 查看路由表
route -n
ip route show

# 2. 追踪路由
traceroute 目标IP
mtr 目标IP

# 3. 查看网卡配置
ip addr show
ifconfig -a

# 4. 测试连通性
ping -c 4 目标IP
ping -I 网卡名 目标IP

1
2
3
4
5
6
7
8
9

# 问题1：默认网关错误
ip route del default
ip route add default via 正确网关IP

# 问题2：多网卡路由冲突
ip route add 目标网段 via 网关 dev 网卡名

# 问题3：路由表满
ip route flush cache

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 查看交换机端口流量
show interface counters

# 2. 查看MAC地址表
show mac address-table

# 3. 检查STP状态
show spanning-tree

# 4. 查看广播包数量
show interface | include broadcast

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看Docker磁盘使用
docker system df

# 2. 查看各容器大小
docker ps -s

# 3. 查看镜像大小
docker images

# 4. 查看overlay2目录
du -sh /var/lib/docker/overlay2/*

# 5. 查看悬空镜像
docker images -f "dangling=true"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 1. 清理悬空镜像
docker image prune -f

# 2. 清理未使用容器
docker container prune -f

# 3. 清理未使用卷
docker volume prune -f

# 4. 清理所有未使用资源
docker system prune -a -f

# 5. 限制容器日志大小（daemon.json）
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  }
}

# 6. 迁移Docker数据目录
systemctl stop docker
rsync -avz /var/lib/docker /新路径/
修改/etc/docker/daemon.json
systemctl start docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 查看容器退出原因
docker inspect 容器ID | grep -i "oom\|exit"

# 2. 查看系统OOM日志
dmesg | grep -i "oom\|killed"

# 3. 查看容器内存限制
docker inspect 容器ID | grep -i "memory"

# 4. 查看容器内存使用
docker stats 容器ID

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. 调整内存限制
docker run -m 512m --memory-reservation=256m 镜像名

# 2. 优化应用内存使用
# Java应用：-Xmx256m -Xms128m
# Node应用：--max-old-space-size=256

# 3. 增加Swap（不推荐生产）
docker run --memory=512m --memory-swap=1g 镜像名

# 4. 调整OOM优先级
docker run --oom-score-adj=-500 镜像名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 测试网络连通性
ping registry.docker.com

# 2. 测试DNS解析
nslookup registry.docker.com

# 3. 手动拉取测试
docker pull 镜像名:标签

# 4. 查看Docker日志
journalctl -u docker -n 100

# 5. 查看代理配置
env | grep -i proxy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 1. 配置镜像加速器（国内）
cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": [
    "https://registry.cn-hangzhou.aliyuncs.com",
    "https://mirror.ccs.tencentyun.com"
  ]
}
EOF
systemctl daemon-reload
systemctl restart docker

# 2. 配置代理
mkdir -p /etc/systemd/system/docker.service.d
cat > /etc/systemd/system/docker.service.d/http-proxy.conf << EOF
[Service]
Environment="HTTP_PROXY=http://代理IP:端口"
Environment="HTTPS_PROXY=http://代理IP:端口"
EOF
systemctl daemon-reload
systemctl restart docker

# 3. 使用私有仓库
docker login 私有仓库地址
docker pull 私有仓库/镜像名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 查看容器重启次数
docker inspect 容器ID | grep -i "restart"

# 2. 查看容器日志
docker logs --tail 200 容器ID

# 3. 查看容器资源
docker stats 容器ID

# 4. 查看容器健康检查
docker inspect 容器ID | grep -A 10 "Health"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 调整重启策略
docker update --restart=on-failure:3 容器ID

# 2. 添加健康检查
docker run --health-cmd "curl -f http://localhost:8080" \
           --health-interval 30s \
           --health-timeout 10s \
           --health-retries 3 镜像名

# 3. 添加启动等待
# 使用wait-for-it.sh等待依赖服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看网络列表
docker network ls

# 2. 查看网络详情
docker network inspect 网络名

# 3. 查看容器IP
docker inspect 容器ID | grep IPAddress

# 4. 测试容器间连通性
docker exec 容器1 ping 容器2IP

# 5. 查看iptables规则
iptables -L -n | grep docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 创建自定义网络
docker network create --driver bridge mynet

# 2. 将容器加入同一网络
docker network connect mynet 容器ID

# 3. 检查防火墙
systemctl status firewalld
firewall-cmd --list-all

# 4. 重启Docker网络
systemctl restart docker

# 5. 跨主机网络（使用overlay）
docker network create --driver overlay --attachable myoverlay

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看Pod详细状态
kubectl describe pod Pod名 -n 命名空间

# 2. 查看节点资源
kubectl describe node 节点名

# 3. 查看节点状态
kubectl get nodes -o wide

# 4. 查看调度事件
kubectl get events -n 命名空间 --sort-by='.lastTimestamp'

# 5. 查看资源配额
kubectl describe quota -n 命名空间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1. 查看调度失败原因
kubectl describe pod Pod名 | grep -A 5 "Events"

# 2. 临时调整资源
kubectl set resources deployment/服务名 \
  --requests=cpu=100m,memory=128Mi \
  --limits=cpu=500m,memory=512Mi

# 3. 查看节点可调度资源
kubectl top nodes

# 4. 驱逐低优先级Pod
kubectl drain 节点名 --ignore-daemonsets --delete-local-data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 查看Pod状态
kubectl get pods -n 命名空间

# 2. 查看Pod详情
kubectl describe pod Pod名 -n 命名空间

# 3. 查看容器日志
kubectl logs Pod名 -n 命名空间
kubectl logs Pod名 -n 命名空间 --previous  # 查看上次崩溃日志

# 4. 进入容器调试
kubectl exec -it Pod名 -n 命名空间 -- /bin/bash

# 5. 查看事件
kubectl get events -n 命名空间 --field-selector involvedObject.name=Pod名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 调整存活探针
kubectl edit deployment/服务名 -n 命名空间
# 修改：
# initialDelaySeconds: 30  # 延长初始延迟
# failureThreshold: 5      # 增加失败阈值
# periodSeconds: 10        # 延长检查间隔

# 2. 回滚到稳定版本
kubectl rollout undo deployment/服务名 -n 命名空间

# 3. 删除Pod让K8s重建
kubectl delete pod Pod名 -n 命名空间

# 4. 临时禁用探针（调试用）
kubectl edit deployment/服务名 -n 命名空间
# 注释掉livenessProbe和readinessProbe

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看CNI Pod状态
kubectl get pods -n kube-system | grep -E "flannel|calico|weave"

# 2. 查看CNI日志
kubectl logs -n kube-system CNI-Pod名

# 3. 测试Pod间连通性
kubectl exec Pod1 -- ping Pod2IP

# 4. 查看网络策略
kubectl get networkpolicy -A

# 5. 查看iptables规则
iptables -L -n | grep -E "KUBE|CALICO"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1. 重启CNI Pod
kubectl delete pod -n kube-system -l k8s-app=calico-node

# 2. 重新安装CNI
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

# 3. 检查节点网络
ip addr show
ip route show

# 4. 清理残留网络配置
# 谨慎操作，可能需要重启节点
rm -rf /var/lib/cni/*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 1. 查看etcd Pod状态
kubectl get pods -n kube-system | grep etcd

# 2. 查看etcd日志
kubectl logs -n kube-system etcd-节点名

# 3. 检查etcd健康
ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt \
  --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \
  endpoint health

# 4. 查看etcd成员
ETCDCTL_API=3 etcdctl member list

# 5. 查看etcd数据大小
ETCDCTL_API=3 etcdctl --write-out=table endpoint status

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1. 重启etcd
kubectl delete pod -n kube-system etcd-节点名

# 2. 从备份恢复
ETCDCTL_API=3 etcdctl snapshot restore 备份文件 \
  --data-dir=/var/lib/etcd-restore

# 3. 清理过期数据
ETCDCTL_API=3 etcdctl compaction --revision=修订版本
ETCDCTL_API=3 etcdctl defrag

# 4. 扩容etcd集群
# 添加新成员，确保奇数节点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 查看节点状态
kubectl get nodes
kubectl describe node 节点名

# 2. 查看kubelet状态
systemctl status kubelet

# 3. 查看kubelet日志
journalctl -u kubelet -n 200

# 4. 检查证书
ls -la /etc/kubernetes/pki/kubelet*
openssl x509 -in /etc/kubernetes/pki/kubelet.crt -text -noout

# 5. 检查配置文件
cat /etc/kubernetes/kubelet.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 重启kubelet
systemctl restart kubelet

# 2. 更新证书
# 证书过期需要重新签发
kubeadm certs renew kubelet-client-current
systemctl restart kubelet

# 3. 检查资源
free -h
df -h

# 4. 重新加入集群
kubeadm reset
kubeadm join 控制节点IP:6443 --token XXX --discovery-token-ca-cert-hash XXX

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 重启kubelet
systemctl restart kubelet

# 2. 更新证书
# 证书过期需要重新签发
kubeadm certs renew kubelet-client-current
systemctl restart kubelet

# 3. 检查资源
free -h
df -h

# 4. 重新加入集群
kubeadm reset
kubeadm join 控制节点IP:6443 --token XXX --discovery-token-ca-cert-hash XXX

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 修正标签选择器
kubectl edit svc 服务名 -n 命名空间

# 2. 重启kube-proxy
kubectl delete pod -n kube-system -l k8s-app=kube-proxy

# 3. 检查iptables规则
iptables -L -n | grep 服务IP

# 4. 使用headless Service调试
# 将clusterIP改为None，直接访问Pod IP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

-- 1. 查看锁等待
SELECT * FROM information_schema.INNODB_LOCK_WAITS;

-- 2. 查看正在运行的事务
SELECT * FROM information_schema.INNODB_TRX;

-- 3. 查看锁信息
SELECT * FROM performance_schema.data_locks;

-- 4. 查看进程列表
SHOW PROCESSLIST;

-- 5. 查看表锁
SHOW OPEN TABLES WHERE In_use > 0;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

-- 1. 终止阻塞的会话
KILL 进程ID;

-- 2. 查看并终止长时间运行的事务
SELECT CONCAT('KILL ', id, ';') 
FROM information_schema.processlist 
WHERE command = 'Sleep' AND time > 300;

-- 3. 优化锁等待超时
SET GLOBAL innodb_lock_wait_timeout = 50;

-- 4. 查看锁等待图
SELECT blocking_locks.lock_id AS blocked_lock_id,
       blocking_locks.lock_mode AS blocked_lock_mode,
       blocking_trx.trx_id AS blocked_trx_id,
       blocking_trx.trx_query AS blocked_query
FROM performance_schema.data_lock_waits
JOIN performance_schema.data_locks blocking_locks
  ON data_lock_waits.blocking_engine_lock_id = blocking_locks.engine_lock_id
JOIN performance_schema.innodb_trx blocking_trx
  ON blocking_locks.engine_transaction_id = blocking_trx.trx_id;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

-- 1. 查看主从状态
SHOW SLAVE STATUS\G

-- 关键字段：
-- Slave_IO_Running: Yes/No
-- Slave_SQL_Running: Yes/No
-- Seconds_Behind_Master: 延迟秒数
-- Last_Error: 错误信息

-- 2. 查看主库位置
SHOW MASTER STATUS\G

-- 3. 查看从库位置
SHOW SLAVE STATUS\G
-- Relay_Log_Pos, Exec_Master_Log_Pos

-- 4. 查看复制线程
SHOW PROCESSLIST;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

-- 1. 跳过错误（谨慎使用）
STOP SLAVE;
SET GLOBAL sql_slave_skip_counter = 1;
START SLAVE;

-- 2. 并行复制优化（MySQL 5.7+）
SET GLOBAL slave_parallel_workers = 4;
SET GLOBAL slave_parallel_type = 'LOGICAL_CLOCK';

-- 3. 优化从库配置
-- my.cnf
[mysqld]
slave_parallel_workers = 4
binlog_format = ROW
slave_preserve_commit_order = ON

-- 4. 重新同步（最后手段）
-- 从主库重新导数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- 1. 开启慢查询日志
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;

-- 2. 查看慢查询
SELECT * FROM mysql.slow_log;

-- 3. 查看当前运行查询
SHOW FULL PROCESSLIST;

-- 4. 查看查询执行计划
EXPLAIN SELECT * FROM 表 WHERE 条件;

-- 5. 查看索引使用情况
SELECT * FROM sys.schema_unused_indexes;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

-- 1. 终止慢查询
KILL 进程ID;

-- 2. 添加索引
ALTER TABLE 表名 ADD INDEX 索引名 (字段名);

-- 3. 优化查询
-- 避免SELECT *
-- 避免在索引列上使用函数
-- 避免LIKE '%前缀'

-- 4. 限制查询资源
SET GLOBAL max_execution_time = 30000;  -- 30秒超时

-- 5. 使用查询缓存（MySQL 5.7）
SET GLOBAL query_cache_size = 64M;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- 1. 查看当前连接数
SHOW STATUS LIKE 'Threads_connected';

-- 2. 查看最大连接数
SHOW VARIABLES LIKE 'max_connections';

-- 3. 查看各用户连接数
SELECT user, host, COUNT(*) FROM information_schema.processlist GROUP BY user, host;

-- 4. 查看连接状态
SHOW STATUS LIKE 'Connections';
SHOW STATUS LIKE 'Aborted_connects';

-- 5. 应用层查看连接池
-- 根据连接池类型查看监控

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

-- 1. 临时增加连接数
SET GLOBAL max_connections = 500;

-- 2. 终止空闲连接
SELECT CONCAT('KILL ', id, ';') 
FROM information_schema.processlist 
WHERE command = 'Sleep' AND time > 300;

-- 3. 调整应用连接池配置
# 示例（HikariCP）
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000

-- 4. 优化查询减少连接占用
-- 减少长事务
-- 及时关闭连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

-- 1. 查看binlog列表
SHOW BINARY LOGS;

-- 2. 查看binlog大小
SELECT SUM(file_size) FROM (SHOW BINARY LOGS) AS logs;

-- 3. 查看binlog配置
SHOW VARIABLES LIKE 'binlog%';

-- 4. 查看当前binlog
SHOW MASTER STATUS;

-- 5. 系统层查看
du -sh /var/lib/mysql/*.bin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

-- 1. 清理旧binlog
PURGE BINARY LOGS BEFORE '2024-01-01 00:00:00';
PURGE BINARY LOGS TO 'mysql-bin.000100';

-- 2. 调整binlog保留策略
-- my.cnf
[mysqld]
binlog_expire_logs_seconds = 604800  # 7天
max_binlog_size = 1073741824  # 1GB

-- 3. 临时关闭binlog（谨慎）
SET SESSION sql_log_bin = 0;

-- 4. 从库跳过binlog
-- 从库不需要binlog可关闭
[mysqld]
skip-log-bin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 随机过期时间
import random
expire_time = base_expire + random.randint(0, 300)  # 基础时间+随机0-5分钟

# 2. 热点数据永不过期
# 对核心数据设置较长过期时间或永不过期

# 3. 限流降级
# 使用令牌桶或信号量限制并发查询

# 4. 多级缓存
# 本地缓存 + Redis + 数据库

# 5. 缓存预热
# 系统启动时预加载热点数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 1. 互斥锁
def get_data(key):
    data = redis.get(key)
    if data is None:
        if redis.setnx(f"lock:{key}", 1):
            try:
                data = db.query(key)
                redis.set(key, data, expire=300)
            finally:
                redis.delete(f"lock:{key}")
        else:
            time.sleep(0.1)
            return get_data(key)
    return data

# 2. 逻辑过期
# 不设置物理过期，在value中存储过期时间
# 异步更新缓存

# 3. 永不过期 + 异步更新
# 热点数据永不过期，后台定时更新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 1. 缓存空值
def get_data(key):
    data = redis.get(key)
    if data == "NULL":  # 特殊标记
        return None
    if data is None:
        data = db.query(key)
        if data is None:
            redis.setex(key, 60, "NULL")  # 缓存空值60秒
            return None
        redis.setex(key, 300, data)
    return data

# 2. 布隆过滤器
from pybloom import BloomFilter
bf = BloomFilter(capacity=1000000, error_rate=0.001)

def query(key):
    if key not in bf:  # 肯定不存在
        return None
    # 可能存在，继续查询

# 3. 参数校验
# 对请求参数进行合法性校验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. 查看Redis节点状态
redis-cli -h 主节点IP INFO replication

# 2. 查看Sentinel状态
redis-cli -h SentinelIP INFO sentinel

# 3. 查看Sentinel监控
redis-cli -h SentinelIP SENTINEL masters
redis-cli -h SentinelIP SENTINEL slaves 主节点名

# 4. 测试连接
redis-cli -h 节点IP ping

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 手动提升从节点
redis-cli -h 从节点IP SLAVEOF NO ONE

# 2. 检查Sentinel配置
# sentinel.conf
sentinel monitor mymaster 主IP 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1

# 3. 重启Sentinel
systemctl restart redis-sentinel

# 4. 检查网络连通性
ping 节点IP
telnet 节点IP 26379

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 1. 查看消费组状态
kafka-consumer-groups.sh --bootstrap-server broker:9092 --describe --group 消费组名

# 关键字段：
# LAG: 积压消息数
# CURRENT-OFFSET: 当前消费位置
# LOG-END-OFFSET: 最新消息位置

# 2. 查看Topic详情
kafka-topics.sh --bootstrap-server broker:9092 --describe --topic Topic名

# 3. 查看消费者延迟
kafka-consumer-groups.sh --bootstrap-server broker:9092 \
  --describe --group 消费组名 --verbose

# 4. 查看Broker状态
kafka-broker-api-versions.sh --bootstrap-server broker:9092

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 1. 增加消费者实例
# 扩展消费者组，增加并行度

# 2. 增加Partition
kafka-topics.sh --bootstrap-server broker:9092 \
  --alter --topic Topic名 --partitions 新数量

# 3. 优化消费逻辑
# 批量处理消息
# 异步处理非关键逻辑

# 4. 临时跳过消息（谨慎）
# 重置消费位点
kafka-consumer-groups.sh --bootstrap-server broker:9092 \
  --group 消费组名 --topic Topic名 --reset-offsets --to-latest --execute

# 5. 扩容Broker
# 增加Broker节点，重新分配Partition

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 1. 查看队列状态
rabbitmqctl list_queues name messages consumers

# 2. 查看队列详情
rabbitmqctl list_queues name messages_ready messages_unacknowledged

# 3. 查看连接
rabbitmqctl list_connections

# 4. 查看通道
rabbitmqctl list_channels

# 5. 管理界面
# http://MQ_IP:15672

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 增加消费者
# 启动更多消费者实例

# 2. 调整prefetch_count
# 消费者配置：channel.basic_qos(prefetch_count=10)

# 3. 清理积压消息
# 创建临时队列，消费后丢弃
rabbitmqadmin purge queue 队列名

# 4. 扩容集群
# 增加RabbitMQ节点

# 5. 优化消息处理
# 批量确认
# 异步处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 1. 幂等性设计
def process_message(msg_id, data):
    # 检查是否已处理
    if redis.exists(f"processed:{msg_id}"):
        return
    # 处理业务
    do_something(data)
    # 标记已处理
    redis.setex(f"processed:{msg_id}", 86400, 1)

# 2. 数据库唯一约束
# 使用业务主键作为唯一索引

# 3. 状态机控制
# 订单状态：待支付->已支付，不允许重复支付

# 4. 消息去重表
CREATE TABLE message_dedup (
    msg_id VARCHAR(64) PRIMARY KEY,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1. 发现服务不可用
curl -I https://gitlab.com  # 返回500

# 2. 检查数据库状态
systemctl status postgresql  # 服务停止

# 3. 检查数据目录
ls -la /var/opt/gitlab/postgresql/data  # 目录为空

# 4. 尝试恢复备份
# 发现所有备份均不可用

1
2
3
4
5
6
7

# 检查备份状态
ls -la /backup/gitlab/
pg_restore -l 备份文件

# 检查磁盘
df -h
lsof | grep deleted

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 监控告警
S3请求错误率飙升
API响应时间超时

# 2. 日志分析
AWS CloudTrail审计日志
S3访问日志

# 3. 系统状态检查
检查S3各组件健康状态

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 外部检测
ping facebook.com  # 无法解析
traceroute facebook.com  # 路由中断

# 2. BGP检查
show ip bgp summary
show ip route facebook网段

# 3. DNS检查
nslookup facebook.com  # 无响应

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 监控发现
CPU使用率告警
请求延迟增长

# 2. 日志分析
grep "WAF" /var/log/cloudflare/
分析高CPU请求特征

# 3. 性能分析
perf top  # 查看热点函数

1
2
3
4
5
6
7
8

-- 1. 检查复制状态
SHOW SLAVE STATUS\G

-- 2. 检查延迟
SELECT TIMESTAMPDIFF(SECOND, last_executed_time, NOW());

-- 3. 检查连接
SHOW PROCESSLIST;

1
2
3
4
5
6
7
8

-- 1. 检查连接数
SHOW STATUS LIKE 'Threads_connected';

-- 2. 检查慢查询
SELECT * FROM mysql.slow_log ORDER BY start_time DESC LIMIT 10;

-- 3. 检查锁等待
SELECT * FROM information_schema.innodb_lock_waits;

1
2
3
4
5
6
7
8
9

# 1. 测试DNS解析
nslookup zoom.us
dig zoom.us

# 2. 检查DNS配置
cat /etc/resolv.conf

# 3. 检查证书
openssl s_client -connect zoom.us:443

1
2
3
4
5
6
7
8

# 1. 检查etcd状态
ETCDCTL_API=3 etcdctl endpoint health

# 2. 检查延迟
ETCDCTL_API=3 etcdctl endpoint status --write-out=table

# 3. 检查磁盘
iostat -x 1

1
2
3
4
5
6
7
8
9

# 1. 检查磁盘
df -h
du -sh /var/log/*

# 2. 检查ES集群
curl localhost:9200/_cluster/health

# 3. 检查日志量
wc -l /var/log/app/*.log

1
2
3
4
5
6
7
8
9

# 1. 检查CDN状态
curl -I https://cdn.域名/资源

# 2. 检查证书
openssl s_client -connect cdn.域名:443

# 3. 检查源站
top
netstat -an | grep ESTABLISHED | wc -l

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 1. 用户反馈后验证证书状态
openssl s_client -connect www.example.com:443 </dev/null 2>/dev/null | openssl x509 -noout -dates

# 输出显示：
# notBefore=Jan 15 00:00:00 2024 GMT
# notAfter=Jan 15 23:59:59 2025 GMT  # 已过期

# 2. 检查所有服务器证书
for server in web1 web2 web3 web4; do
    echo "=== $server ==="
    openssl s_client -connect $server:443 </dev/null 2>/dev/null | \
    openssl x509 -noout -enddate
done

# 3. 查找证书文件位置
find /etc -name "*.crt" -o -name "*.pem" 2>/dev/null
find /opt -name "*.crt" -o -name "*.pem" 2>/dev/null

# 4. 检查证书到期时间
for cert in $(find /etc/ssl -name "*.crt" 2>/dev/null); do
    echo "=== $cert ==="
    openssl x509 -in $cert -noout -enddate
done

# 5. 检查Nginx配置
grep -r "ssl_certificate" /etc/nginx/

# 6. 查看证书剩余天数
openssl x509 -in /etc/ssl/certs/server.crt -noout -checkend 86400
# 返回1表示24小时内过期，返回0表示未过期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 检查证书详细信息
openssl x509 -in certificate.crt -text -noout

# 检查证书链
openssl verify -CAfile ca-bundle.crt server.crt

# 在线检查证书
curl -vI https://www.example.com 2>&1 | grep -i "expire\|subject"

# 监控脚本示例
#!/bin/bash
CERT_FILE="/etc/ssl/certs/server.crt"
EXPIRE_DAYS=30
EXPIRE_DATE=$(openssl x509 -in $CERT_FILE -noout -enddate | cut -d= -f2)
EXPIRE_EPOCH=$(date -d "$EXPIRE_DATE" +%s)
CURRENT_EPOCH=$(date +%s)
DAYS_LEFT=$(( ($EXPIRE_EPOCH - $CURRENT_EPOCH) / 86400 ))

if [ $DAYS_LEFT -lt $EXPIRE_DAYS ]; then
    echo "WARNING: Certificate expires in $DAYS_LEFT days"
    # 发送告警
    curl -X POST -d "证书将在$DAYS_LEFT天后过期" http://alert-server/webhook
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 1. 紧急申请新证书（Let's Encrypt）
certbot certonly --webroot -w /var/www/html -d www.example.com

# 2. 替换证书文件
cp /etc/letsencrypt/live/www.example.com/fullchain.pem /etc/ssl/certs/server.crt
cp /etc/letsencrypt/live/www.example.com/privkey.pem /etc/ssl/private/server.key

# 3. 重新加载Nginx
nginx -t  # 先测试配置
systemctl reload nginx

# 4. 验证新证书
openssl s_client -connect www.example.com:443 </dev/null 2>/dev/null | \
openssl x509 -noout -dates

# 5. 清理旧证书
rm -f /etc/ssl/certs/server.crt.old

# 6. 重启相关服务
systemctl restart php-fpm
systemctl restart tomcat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 1. 配置自动续期（crontab）
0 0 1 * * /usr/bin/certbot renew --quiet && systemctl reload nginx

# 2. 添加证书监控（Prometheus）
# 使用ssl_exporter监控证书到期
# 配置告警规则（Prometheus Alertmanager）
groups:
- name: certificate
  rules:
  - alert: SSLCertificateExpiringSoon
    expr: ssl_cert_expiry_days < 30
    for: 1h
    labels:
      severity: warning
    annotations:
      summary: "SSL证书即将过期"
      description: "{{ $labels.instance }} 证书将在{{ $value }}天后过期"
      
  - alert: SSLCertificateExpired
    expr: ssl_cert_expiry_days < 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "SSL证书已过期"
      description: "{{ $labels.instance }} 证书已过期"

# 3. 证书管理台账
# 建立Excel/数据库记录所有证书信息
| 域名 | 证书类型 | 到期时间 | 负责人 | 部署位置 |
|------|----------|----------|--------|----------|
| www.example.com | DV | 2026-01-15 | 张三 | web1-4 |

# 4. 使用证书管理服务
# 如：HashiCorp Vault、AWS ACM、阿里云SSL服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 1. 查看消费组状态
kafka-consumer-groups.sh --bootstrap-server kafka-broker:9092 \
  --describe --group order-consumer-group

# 输出示例：
# TOPIC           PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
# order-topic     0          1000000         5000000         4000000
# order-topic     1          1200000         5200000         4000000
# order-topic     2          1100000         5100000         4000000

# 2. 查看消费者日志
tail -f /var/log/order-consumer/app.log | grep -i "process\|error"

# 3. 检查消费者JVM状态
jps -l | grep order-consumer
jstat -gc <PID> 1000 10  # 查看GC情况
jstack <PID> | grep -A 30 "RUNNABLE"  # 查看线程状态

# 4. 查看Kafka Broker状态
kafka-broker-api-versions.sh --bootstrap-server kafka-broker:9092

# 5. 检查Topic配置
kafka-topics.sh --bootstrap-server kafka-broker:9092 \
  --describe --topic order-topic

# 6. 查看消息生产速率
kafka-run-class.sh kafka.tools.JmxTool \
  --object-name kafka.server:type=BrokerTopicMetrics,name=MessagesInPerSec \
  --jmx-url service:jmx:rmi:///jndi/rmi://kafka-broker:9999/jmxrmi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 持续监控Lag变化
watch -n 5 'kafka-consumer-groups.sh --bootstrap-server kafka-broker:9092 \
  --describe --group order-consumer-group | grep -v "^$"'

# 查看消费者延迟趋势
kafka-consumer-groups.sh --bootstrap-server kafka-broker:9092 \
  --describe --group order-consumer-group --verbose

# 检查Kafka磁盘使用
df -h /var/lib/kafka
du -sh /var/lib/kafka/logs/*

# 查看Kafka控制器状态
echo "dump" | nc kafka-broker 9092 | grep -i "controller"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 1. 紧急扩容消费者实例
# 从3个实例扩展到10个实例
kubectl scale deployment order-consumer --replicas=10

# 2. 增加Topic Partition数量
kafka-topics.sh --bootstrap-server kafka-broker:9092 \
  --alter --topic order-topic --partitions 20

# 3. 优化消费者配置
# consumer.properties
fetch.min.bytes=1048576        # 增加拉取批量
fetch.max.wait.ms=500          # 增加等待时间
max.poll.records=1000          # 增加单次拉取数量
max.partition.fetch.bytes=10485760

# 4. 临时跳过非关键消息（谨慎使用）
kafka-consumer-groups.sh --bootstrap-server kafka-broker:9092 \
  --group order-consumer-group --topic order-topic \
  --reset-offsets --to-current --execute

# 5. 优化业务逻辑
# 将同步写入改为异步批量写入
# 原代码：每条消息单独插入数据库
# 优化后：每100条批量插入

# 6. 增加数据库连接池
spring.datasource.hikari.maximum-pool-size=50

# 7. 启用消费者并行处理
# 使用线程池处理消息
ExecutorService executor = Executors.newFixedThreadPool(10);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# 1. 配置Lag监控告警（Prometheus + Kafka Exporter）
# 告警规则
- alert: KafkaConsumerLagHigh
  expr: kafka_consumer_group_lag > 100000
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "Kafka消费延迟过高"
    description: "消费组{{ $labels.group }} 延迟{{ $value }}条"

- alert: KafkaConsumerLagCritical
  expr: kafka_consumer_group_lag > 1000000
  for: 2m
  labels:
    severity: critical
  annotations:
    summary: "Kafka消费严重延迟"
    description: "消费组{{ $labels.group }} 延迟{{ $value }}条"

# 2. 消费者自动扩缩容
# 基于Lag指标自动扩容
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: order-consumer-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order-consumer
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: External
    external:
      metric:
        name: kafka_consumer_lag
      target:
        type: AverageValue
        averageValue: 10000

# 3. 代码层面优化
# 添加处理超时限制
@KafkaListener(topics = "order-topic")
public void listen(ConsumerRecord<String, String> record) {
    try {
        processWithTimeout(record, 5, TimeUnit.SECONDS);
    } catch (TimeoutException e) {
        // 发送死信队列
        sendToDeadLetterQueue(record);
    }
}

# 4. 定期压测
# 模拟高峰流量验证消费者处理能力

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 1. 查看Nginx状态
curl http://localhost/nginx_status

# 输出：
# Active connections: 1024
# server accepts handled requests
#  100000 100000 500000 
# Reading: 100 Writing: 900 Waiting: 24

# 2. 查看Nginx错误日志
tail -f /var/log/nginx/error.log | grep -i "connect\|limit"

# 典型错误：
# 2024/01/15 10:30:00 [error] connect() failed (110: Connection timed out)
# 2024/01/15 10:30:01 [emerg] worker_connections are not enough

# 3. 检查Nginx配置
cat /etc/nginx/nginx.conf | grep -i "worker_connections\|worker_processes"

# 4. 查看系统文件句柄
ulimit -n
cat /proc/sys/fs/file-nr

# 5. 查看Nginx进程打开的文件数
ls /proc/$(cat /var/run/nginx.pid)/fd | wc -l

# 6. 查看后端服务连接
netstat -an | grep :8080 | wc -l
netstat -an | grep :8080 | grep ESTABLISHED | wc -l

# 7. 查看TIME_WAIT连接
netstat -n | grep TIME_WAIT | wc -l

# 8. 检查后端服务状态
systemctl status tomcat
top -p $(pgrep -f java)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 实时查看Nginx连接状态
watch -n 1 'curl -s http://localhost/nginx_status'

# 查看各状态连接数
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'

# 查看Nginx进程资源
ps aux | grep nginx
cat /proc/$(cat /var/run/nginx.pid)/limits

# 抓包分析连接问题
tcpdump -i any port 80 -w nginx_capture.pcap

# 分析慢请求
awk '{if($9 >= 500) print $0}' /var/log/nginx/access.log | head -20

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# 1. 紧急调整Nginx配置
# /etc/nginx/nginx.conf
worker_processes auto;
events {
    worker_connections 65535;  # 从1024增加到65535
    multi_accept on;
    use epoll;
}

http {
    # 调整连接超时
    keepalive_timeout 65;
    client_body_timeout 60;
    send_timeout 60;
    
    # 调整上游连接
    upstream backend {
        server 127.0.0.1:8080;
        keepalive 100;  # 长连接池
    }
    
    server {
        location / {
            proxy_connect_timeout 60;
            proxy_send_timeout 60;
            proxy_read_timeout 60;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
        }
    }
}

# 2. 调整系统文件句柄限制
# /etc/security/limits.conf
* soft nofile 65535
* hard nofile 65535
root soft nofile 65535
root hard nofile 65535

# /etc/sysctl.conf
fs.file-max = 2097152
fs.nr_open = 2097152

# 应用配置
sysctl -p
ulimit -n 65535

# 3. 优化TCP参数
# /etc/sysctl.conf
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.ip_local_port_range = 1024 65535
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

sysctl -p

# 4. 重启Nginx
nginx -t
systemctl reload nginx

# 5. 扩容后端服务
kubectl scale deployment backend --replicas=5

# 6. 添加限流保护
# /etc/nginx/nginx.conf
limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;
server {
    location / {
        limit_req zone=one burst=20 nodelay;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 1. 配置连接数监控
# Prometheus Nginx Exporter
# 告警规则
- alert: NginxActiveConnectionsHigh
  expr: nginx_connections_active > 5000
  for: 2m
  labels:
    severity: warning
  annotations:
    summary: "Nginx活跃连接数过高"

# 2. 压力测试
# 定期使用ab/wrk进行压测
ab -n 10000 -c 100 http://localhost/

# 3. 容量规划
# 根据业务量预估连接数，预留50%余量
# 公式：连接数 = QPS * 平均响应时间 * 1.5

# 4. 优雅降级
# 配置限流和熔断
location /api/ {
    limit_req zone=api burst=50;
    proxy_connect_timeout 5s;
    error_page 502 503 504 /50x.html;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 1. 查看TIME_WAIT数量
netstat -n | grep TIME_WAIT | wc -l
# 输出：25000（正常应<10000）

# 2. 查看TIME_WAIT详情
netstat -n | grep TIME_WAIT | head -20

# 输出示例：
# tcp 0 0 192.168.1.10:45000 10.0.0.1:80 TIME_WAIT
# tcp 0 0 192.168.1.10:45001 10.0.0.1:80 TIME_WAIT

# 3. 查看各状态连接分布
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
# 输出：
# TIME_WAIT 25000
# ESTABLISHED 500
# CLOSE_WAIT 100

# 4. 查看本地端口范围
cat /proc/sys/net/ipv4/ip_local_port_range
# 输出：32768 61000（约28000个端口）

# 5. 查看TIME_WAIT等待时间
cat /proc/sys/net/ipv4/tcp_fin_timeout
# 输出：60（秒）

# 6. 查看端口耗尽情况
netstat -n | grep 192.168.1.10 | awk '{print $4}' | \
  cut -d: -f2 | sort -n | uniq | wc -l

# 7. 检查应用连接池配置
# 查看是否有连接复用
grep -r "keepalive\|pool" /etc/application/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 持续监控TIME_WAIT变化
watch -n 5 'netstat -n | grep TIME_WAIT | wc -l'

# 查看TIME_WAIT连接的目标分布
netstat -n | grep TIME_WAIT | awk '{print $5}' | \
  cut -d: -f1 | sort | uniq -c | sort -rn | head -10

# 查看端口使用情况
ss -s
# 输出：
# TCP: 30000 (estab 500, closed 29000, orphaned 0, synrecv 0, timewait 25000)

# 检查是否有连接泄漏
lsof -i -n | grep -i wait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 1. 开启TIME_WAIT复用（立即生效）
echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse

# 2. 缩短TIME_WAIT等待时间
echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

# 3. 扩大本地端口范围
echo "1024 65535" > /proc/sys/net/ipv4/ip_local_port_range

# 4. 永久配置（/etc/sysctl.conf）
cat >> /etc/sysctl.conf << EOF
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_max_tw_buckets = 20000
EOF
sysctl -p

# 5. 应用层优化（使用长连接）
# Python示例
import requests
session = requests.Session()  # 复用连接
for i in range(1000):
    session.get('http://backend/api')

# Java示例（HttpClient）
CloseableHttpClient httpClient = HttpClients.custom()
    .setMaxConnTotal(200)
    .setMaxConnPerRoute(50)
    .setConnectionTimeToLive(30, TimeUnit.SECONDS)
    .build();

# 6. Nginx配置长连接
upstream backend {
    server 127.0.0.1:8080;
    keepalive 100;  # 保持100个长连接
}

# 7. 数据库连接池
# 避免频繁创建数据库连接
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 1. 监控TIME_WAIT数量
# Prometheus Node Exporter + 告警
- alert: TimeWaitConnectionsHigh
  expr: node_netstat_Tcp_TimeWait > 10000
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "TIME_WAIT连接数过高"

# 2. 应用连接池规范
# 所有外部调用必须使用连接池
# HTTP、数据库、Redis等

# 3. 架构优化
# 减少不必要的网络调用
# 使用本地缓存
# 批量处理减少请求次数

# 4. 定期巡检
# 每周检查连接状态
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 1. 查看系统级文件句柄
cat /proc/sys/fs/file-max
cat /proc/sys/fs/file-nr
# 输出：100000  50000  100000（已用/空闲/最大）

# 2. 查看进程级限制
ulimit -n
# 输出：1024（过低）

# 3. 查看具体进程打开的文件数
ls /proc/$(pgrep -f java)/fd | wc -l
# 输出：5000

# 4. 找出打开文件最多的进程
for pid in /proc/[0-9]*/fd; do 
    echo $(ls $pid 2>/dev/null | wc -l) $pid
done | sort -rn | head -20

# 5. 查看进程打开的具体文件
lsof -p $(pgrep -f java) | head -50

# 6. 查看已删除但仍被占用的文件
lsof | grep deleted | head -20

# 7. 查看Socket连接
lsof -i -n | grep -i listen
lsof -i -n | grep -i established | wc -l

# 8. 查看日志文件
lsof | grep "\.log" | wc -l