Skip to content

U
ubains-module-test
提交 ead4ed00 authored 作者: 陈泽健's avatar 陈泽健
浏览文件
操作

docs(server): 添加AI服务器监测需求文档，调整桌牌部署函数增加9990端口放行 

- 新增完整的服务器健康巡检工作流程
- 包含基础信息采集和资源使用检测
- 添加进程深度分析和网络分析
- 实现Docker容器检测功能
- 集成MySQL数据库检测
- 添加Redis缓存检测
- 实现EMQX消息队列检测
- 添加Java应用JVM检测
- 包含FastDFS检测
- 新增Nginx检测
- 实现应用日志分析
- 添加系统日志分析
- 集成安全检测功能
- 包含定时任务检测
- 添加NTP时钟同步检测
- 实现SSL证书有效期检测
上级 caccdc31
隐藏空白字符变更
内嵌 并排
正在显示 包含 1521 行增加 和 0 行删除
Docs/PRD/服务自检/新需求/_PRD_AI服务器监测需求.md 0 → 100644
浏览文件 @ ead4ed00
# 角色
你是一名资深的Linux系统运维专家，专注于会议预定系统的稳定性保障，擅长通过Shell/Python脚本进行服务器深度巡检和故障诊断。
# 目标服务器配置
- **主机地址**: 192.168.5.44
- **SSH端口**: 22
- **用户名**: root
- **密码**: Ubains@123
- **操作系统**: openEuler 24.03 (LTS-SP3)
- **内核**: 6.6.0-132.0.0.111.oe2403sp3.x86_64
- **CPU**: 8核
- **内存**: 15GiB
- **磁盘**: 75GB (LVM, openeuler-data)
- **核心服务**: MySQL、Redis、EMQX、Java应用(会议预定系统)、FastDFS、Python应用(运维集控系统)、Voice(讯飞转录系统)
# Docker容器映射
| 容器名 | 镜像 | 宿主端口→容器端口 | IP地址 | 用途 |
|:--------------|:-----------------------------|:---------------------------------------------|:-----------|:----------------|
| umysql | 139.9.60.86:5000/umysql:v5.2 | 8306→3306 | 172.17.0.8 | MySQL 8.0.28 |
| uredis | 139.9.60.86:5000/redis:v3 | 6379→6379 | - | Redis 8.2.2 |
| uemqx | emqx/emqx:5.8.7 | 1883→1883, 8083→8083, 8883→8883 | 172.17.0.6 | EMQX 5.8.7 |
| ujava2 | 139.9.60.86:5000/ujava:v6 | 443→443, 8080→8080, 8997-8999→8997-8999 等 | 172.17.0.9 | Java 1.8.0_472 |
| utracker | ufastdfs:v2 | 22122→22122 (host网络) | - | FastDFS Tracker |
| ustorage | ufastdfs:v2 | 23000→23000 (host网络) | - | FastDFS Storage |
| unacos | nacos-server:v2.5.2 | 8848→8848, 9848→9848 | 172.17.0.5 | Nacos |
| unginx | nginx:1.29.3 | 443→443 | 172.17.0.3 | Nginx |
| upython | 139.9.60.86:5000/upython:v16 | 8000→8000, 8080→8082, 8002→8002 等 | 172.17.0.2 | Python应用 |
| upython_voice | 139.9.60.86:5000/upython:v13 | 8081→8082, 8080→8080, 8003→8000, 8004→8002 等 | 172.17.0.4 | Voice转录应用 |
# 密码配置
- **MySQL密码**: dNrprU&2S
- **Redis密码**: dNrprU&2S
# 你的任务
请按照下方【工作流程】执行完整的服务器健康巡检，生成结构化的Markdown健康报告，并与上次巡检结果进行对比分析。
# 报告存放
请将报告存放至：Docs/PRD/AI服务器监测/分析报告/新统一平台/负载一
---
# 工作流程
## 步骤1: SSH连接服务器
使用SSH连接到目标服务器，执行以下检测命令。
```bash
ssh root@192.168.5.44
```
## 步骤2: 基础信息采集
```bash
# 主机名
hostname -f
# 操作系统信息
cat /etc/os-release
# 内核信息
uname -a
# 运行时间
uptime -s
uptime
# 系统负载 (重点关注: 1min负载 > CPU核心数8 = 警告, >16 = 严重)
cat /proc/loadavg
# 内核启动参数
cat /proc/cmdline
# 系统资源限制
ulimit -a 2>/dev/null | grep -E 'max user processes|open files|max file size'
# 内核关键参数
sysctl -n fs.file-max fs.inotify.max_user_watches net.core.somaxconn net.ipv4.tcp_tw_reuse net.ipv4.tcp_fin_timeout vm.swappiness net.ipv4.ip_local_port_range
```
## 步骤3: 资源使用检测
### 3.1 CPU分析
```bash
# CPU核心数
nproc
# CPU使用率 (关注: us用户态 + sy系统态, >85% = 警告)
top -bn1 | grep 'Cpu(s)'
# 每核心CPU使用率
mpstat -P ALL 1 1
# 进程CPU TOP15 (按CPU降序)
ps -eo pid,comm,%cpu,%mem --no-headers | sort -k3 -rn | head -15
# CPU调度器阻塞进程数
cat /proc/stat | grep procs_blocked
# 中断统计 (硬中断)
cat /proc/interrupts | head -20
# 软中断统计
cat /proc/softirqs | tail -5
# 进程CPU亲和性 (哪些进程绑定在哪些CPU核心)
ps -eo pid,comm,psr --no-headers | sort -k3 -n | head -10
```
### 3.2 内存分析
```bash
# 内存使用情况 (关注: used/total比例, >85% = 警告)
free -h
free -b | head -2
# Swap使用情况 (任何使用都应关注)
free -h | grep Swap
swapon -s
# 内存压力
cat /proc/pressure/memory
# NUMA信息
numactl --hardware
# 虚拟内存统计
cat /proc/vmstat | head -20
# Slab缓存信息
cat /proc/slabinfo 2>/dev/null | head -15
# 大页内存
cat /proc/meminfo | grep -E 'HugePages|AnonHugePages|ShmemHugePages|FileHugePages'
# 详细内存信息
cat /proc/meminfo | head -20
```
### 3.3 磁盘分析
```bash
# 磁盘使用率 (关注: >90% = 警告)
df -h | tail -n +2 | head -20
# 磁盘IO状态 (关注: %util >80%)
iostat -x 1 2
# 磁盘延迟统计
cat /proc/diskstats | head -10
# Inode使用率
df -i | tail -n +2 | head -10
# 磁盘挂载情况 (检查NFS等远程挂载)
mount | grep -E 'nfs|tmpfs|overlay|cgroup'
# SMART健康状态
smartctl -H /dev/sda
# RAID状态
cat /proc/mdstat
# LVM状态
lvs
# 磁盘调度算法
cat /sys/block/sda/queue/scheduler
```
### 3.4 OOM和内核异常检测 (新增)
```bash
# OOM Killer记录 (内存耗尽导致进程被杀)
dmesg -T 2>/dev/null | grep -i "Out of memory" | tail -10
dmesg -T 2>/dev/null | grep -i "Killed process" | tail -10
# Core dump文件检测
find /data /tmp /root -name "core.*" -mtime -7 2>/dev/null | head -10
ulimit -c
# 文件系统只读检测
cat /proc/mounts | grep "ro,"
mount | grep " ro,"
```
## 步骤4: 进程深度分析
```bash
# 进程状态统计 (识别Zombie僵尸进程和D状态不可中断睡眠)
ps -eo stat,pid,ppid,comm --no-headers | awk '
{total++; if(/Z/) zombie++; if(/D/) uninterruptible++}
END {print "Total:", total, "Zombie:", zombie, "Uninterruptible(D):", uninterruptible}'
# 僵尸进程详情
ps -eo stat,pid,ppid,comm,user --no-headers | grep Z
# 线程统计 (关注: 总线程数 >1000 = 警告)
ps -eLf --no-headers | wc -l
# 线程TOP15 (按线程数降序，关联CPU和内存)
ps -eo pid,comm,%cpu,%mem --no-headers > /tmp/proc_info.txt
ps -eLf | awk '{print $2}' | sort | uniq -c | sort -rn | head -15 | while read count pid; do
proc=$(grep "^$pid " /tmp/proc_info.txt | awk '{print $2}')
echo "$count $pid $proc"
done
# 打开文件描述符统计 (关注: 使用率 >80%)
cat /proc/sys/fs/file-nr
# 进程打开的网络连接
lsof -i -n -P 2>/dev/null | head -20
# 进程可执行文件路径 (检查异常进程)
ls -la /proc/*/exe 2>/dev/null | head -20
# 按进程统计打开文件数
lsof 2>/dev/null | awk '{print $1}' | sort | uniq -c | sort -rn | head -10
# 按进程统计网络连接数
ss -tnp 2>/dev/null | awk '{print $6}' | sort | uniq -c | sort -rn | head -10
```
## 步骤5: 网络分析
```bash
# 网络接口状态
ip link show
# 网络连接统计
ss -s
# TCP连接状态详情 (十六进制状态码映射: 01=ESTABLISHED, 06=TIME_WAIT, 0A=LISTEN, 08=CLOSE_WAIT)
cat /proc/net/tcp | awk '{print $4}' | sort | uniq -c | sort -rn
# 关键服务端口连接数
ss -tnp | grep ':8306' | grep ESTAB | wc -l # MySQL (宿主端口8306)
ss -tnp | grep ':6379' | grep ESTAB | wc -l # Redis
ss -tnp | grep ':1883' | grep ESTAB | wc -l # EMQX-MQTT
ss -tnp | grep ':8883' | grep ESTAB | wc -l # EMQX-SSL
ss -tnp | grep ':8083' | grep ESTAB | wc -l # EMQX-WebSocket
ss -tnp | grep ':8999' | grep ESTAB | wc -l # Java-Admin
ss -tnp | grep ':8998' | grep ESTAB | wc -l # Java-Login
ss -tnp | grep ':8997' | grep ESTAB | wc -l # Java-Backend
ss -tnp | grep ':8000' | grep ESTAB | wc -l # Python
ss -tnp | grep ':8003' | grep ESTAB | wc -l # Python_voice
ss -tnp | grep ':22122' | grep ESTAB | wc -l # FastDFS-Tracker
ss -tnp | grep ':23000' | grep ESTAB | wc -l # FastDFS-Storage
# TCP参数
sysctl net.ipv4.tcp_tw_reuse net.ipv4.tcp_fin_timeout net.core.somaxconn net.ipv4.ip_local_port_range
# TCP扩展统计
cat /proc/net/snmp | grep Tcp
# ARP表
ip neigh show
# 路由表
ip route show
# DNS配置
cat /etc/resolv.conf
# Socket统计
cat /proc/net/sockstat
# 网络错误统计
ip -s link show | grep -E 'errors|dropped'
# 网络带宽统计 (累计流量)
cat /proc/net/dev | tail -10
# 监听队列积压 (Recv-Q > 0 表示有请求排队)
ss -ltn 2>/dev/null | head -20
```
### 5.1 网络连通性检测 (新增)
```bash
# 网关连通性
ping -c 2 -W 2 192.168.5.1 2>/dev/null | tail -2
# DNS解析测试
nslookup oapi.dingtalk.com 2>/dev/null | head -5
nslookup api.dingtalk.com 2>/dev/null | head -5
# 关键外部API连通性 (会议系统依赖)
curl -s -o /dev/null -w "HTTP_CODE:%{http_code} TIME:%{time_total}s" --connect-timeout 5 https://oapi.dingtalk.com 2>/dev/null
# 容器间网络连通性
docker exec ujava2 ping -c 1 -W 2 172.17.0.8 2>/dev/null | tail -1 # Java→MySQL
docker exec ujava2 ping -c 1 -W 2 172.17.0.6 2>/dev/null | tail -1 # Java→EMQX
docker exec ujava2 ping -c 1 -W 2 172.17.0.2 2>/dev/null | tail -1 # Java→Python
docker exec ujava2 ping -c 1 -W 2 172.17.0.4 2>/dev/null | tail -1 # Java→Python_voice
docker exec ujava2 ping -c 1 -W 2 172.17.0.3 2>/dev/null | tail -1 # Java→nginx
```
## 步骤6: Docker容器检测
```bash
# 容器列表和状态
docker ps -a --format '{{.Names}}\t{{.Status}}\t{{.Ports}}'
# 容器资源使用 (CPU%, 内存, 网络IO, 磁盘IO)
docker stats --no-stream --format '{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.NetIO}}\t{{.BlockIO}}'
# 容器网络
docker network ls
# 容器卷
docker volume ls
# 容器重启次数 (非0 = 异常)
docker ps -a --format '{{.Names}}\t{{.Status}}' | while read name status; do
echo -e "$name\t$(docker inspect --format='{{.RestartCount}}' $name 2>/dev/null)\t$status"
done
# 关键容器健康检查
for container in umysql uredis uemqx ujava2 utracker ustorage; do
echo "=== $container ==="
docker inspect --format='{{.State.Status}} {{.State.Running}} {{.State.StartedAt}}' $container 2>/dev/null
done
# Docker磁盘使用
docker system df -v
# Docker事件 (最近1小时)
docker events --since '1h' --no-trunc 2>/dev/null | tail -20
# 容器日志错误扫描
for container in umysql uredis uemqx ujava2; do
echo "=== $container logs ==="
docker logs $container --tail 100 --since 2h 2>&1 | grep -iE 'error|fail|exception' | tail -5
done
# 容器cgroup内存使用 (精确内存值)
for container in umysql uredis uemqx ujava2; do
echo "=== $container cgroup memory ==="
docker exec $container cat /sys/fs/cgroup/memory/memory.usage_in_bytes 2>/dev/null || \
docker exec $container cat /sys/fs/cgroup/memory.max 2>/dev/null
done
```
### 6.1 Docker容器深度检测 (新增)
```bash
# 容器日志文件大小检测 (防日志撑爆磁盘)
for container in umysql uredis uemqx ujava2 utracker ustorage; do
log_path=$(docker inspect --format='{{.LogPath}}' $container 2>/dev/null)
if [ -n "$log_path" ]; then
size=$(ls -lh "$log_path" 2>/dev/null | awk '{print $5}')
echo "$container: $size ($log_path)"
fi
done
# 容器镜像创建时间 (检测过期镜像)
docker images --format '{{.Repository}}:{{.Tag}}\t{{.CreatedSince}}\t{{.Size}}'
# 悬空镜像和未使用资源
docker images -f "dangling=true" -q | wc -l
docker system df
# 容器健康状态检查 (如果配置了healthcheck)
for container in umysql uredis uemqx ujava2; do
echo "=== $container health ==="
docker inspect --format='{{if .State.Health}}{{.State.Health.Status}}{{else}}no healthcheck{{end}}' $container 2>/dev/null
done
# 容器资源限制检测 (是否配置了limits)
for container in umysql uredis uemqx ujava2; do
echo "=== $container limits ==="
docker inspect --format='CPU: {{.HostConfig.CpuShares}}, Memory: {{.HostConfig.Memory}}, MemorySwap: {{.HostConfig.MemorySwap}}' $container 2>/dev/null
done
```
## 步骤7: MySQL数据库检测
```bash
# MySQL版本和运行状态
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT VERSION();"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Uptime';"
# 连接数统计 (关注: 当前连接, 历史最大连接, 连接使用率)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Threads_connected';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Max_used_connections';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'max_connections';"
# 连接使用率 = Threads_connected / max_connections * 100
# 连接池分析 (活跃/空闲连接数)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW PROCESSLIST;" | wc -l
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW PROCESSLIST;" | grep -c 'Sleep'
# 慢查询数量 (关注: >100 = 警告, >1000000 = 严重)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW GLOBAL STATUS LIKE 'Slow_queries';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'long_query_time';"
# 数据库列表
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW DATABASES;"
# InnoDB状态
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G"
# InnoDB缓冲池
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G" | grep -A10 'Buffer pool'
# 表统计 (ubains库TOP20)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_ROWS, DATA_LENGTH, INDEX_LENGTH FROM information_schema.TABLES WHERE TABLE_SCHEMA='ubains' ORDER BY TABLE_ROWS DESC LIMIT 20;"
# 当前活跃查询
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW PROCESSLIST;" | grep -v 'Sleep' | head -20
# MySQL变量
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'max_connections';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'wait_timeout';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'interactive_timeout';"
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'innodb_buffer_pool_size';"
# Binlog状态
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW MASTER STATUS;"
# 复制状态
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW SLAVE STATUS\G"
# 事务状态
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G" | grep -A5 'TRANSACTIONS'
# 锁信息
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G" | grep -A10 'LOCK'
```
### 7.1 MySQL深度检测 (新增)
```bash
# QPS/TPS统计 (每秒查询数/事务数)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Queries';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Com_select';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Com_insert';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Com_update';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Com_delete';" 2>/dev/null
# 死锁检测 (最近一次死锁信息)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G" | grep -A20 'LATEST DETECTED DEADLOCK'
# 表碎片检测 (DATA_FREE > 10MB的表)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT TABLE_SCHEMA, TABLE_NAME, ENGINE, TABLE_ROWS, DATA_LENGTH/1024/1024 AS DATA_MB, INDEX_LENGTH/1024/1024 AS INDEX_MB, DATA_FREE/1024/1024 AS FRAG_MB FROM information_schema.TABLES WHERE TABLE_SCHEMA='ubains' AND DATA_FREE > 10485760 ORDER BY DATA_FREE DESC LIMIT 10;"
# 临时表使用率 (过多临时表 = 查询需优化)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Created_tmp%';"
# 连接错误统计
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Connection_errors%';"
# 缓冲池命中率 (关注: <95% = 需增大缓冲池)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW STATUS LIKE 'Innodb_buffer_pool_read%';"
# Binlog大小和过期时间
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'expire_logs_days';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES LIKE 'binlog_expire_logs_seconds';" 2>/dev/null
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW BINARY LOGS;" 2>/dev/null | tail -5
# 数据库总大小
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT table_schema AS 'Database', ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Size(MB)' FROM information_schema.tables GROUP BY table_schema;"
# 缺少索引的高耗时查询 (通过performance_schema)
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT DIGEST_TEXT, COUNT_STAR, AVG_TIMER_WAIT/1000000000 AS AVG_MS FROM performance_schema.events_statements_summary_by_digest ORDER BY AVG_TIMER_WAIT DESC LIMIT 10;" 2>/dev/null
```
## 步骤8: Redis缓存检测
```bash
# 基本信息
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO 2>/dev/null | grep -E 'redis_version|uptime_in_days|connected_clients|blocked_clients'
# 内存使用
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO memory 2>/dev/null | grep -E 'used_memory_human|used_memory_peak_human|mem_fragmentation_ratio|evicted_keys|maxmemory|maxmemory_human|maxmemory_policy'
# 键数量 (关注: >1000000 = 警告)
docker exec uredis redis-cli -a "$REDIS_PASSWORD" DBSIZE 2>/dev/null
# Keyspace
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO keyspace 2>/dev/null
# 持久化信息
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO persistence 2>/dev/null | grep -E 'rdb|aof'
# 复制信息
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO replication 2>/dev/null
# 集群状态
docker exec uredis redis-cli -a "$REDIS_PASSWORD" CLUSTER INFO 2>/dev/null
# 慢日志 (TOP10)
docker exec uredis redis-cli -a "$REDIS_PASSWORD" SLOWLOG GET 10 2>/dev/null
# 命令统计 (TOP10高频命令)
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO commandstats 2>/dev/null | grep 'cmdstat_' | head -10
# 客户端列表
docker exec uredis redis-cli -a "$REDIS_PASSWORD" CLIENT LIST 2>/dev/null | head -5
```
### 8.1 Redis深度检测 (新增)
```bash
# 键过期分析 (过期键比例 = expires/keys)
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO keyspace 2>/dev/null
# 内存使用率 (如果设置了maxmemory)
# used_memory / maxmemory * 100
# 键空间扫描采样 (分析键类型分布)
docker exec uredis redis-cli -a "$REDIS_PASSWORD" --scan --count 100 2>/dev/null | head -20
# 各数据库键的类型统计
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO keyspace 2>/dev/null
# 最近过期键数量
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO stats 2>/dev/null | grep -E 'expired_keys|evicted_keys|keyspace_hits|keyspace_misses'
# 缓存命中率 = keyspace_hits / (keyspace_hits + keyspace_misses) * 100
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO stats 2>/dev/null | grep -E 'keyspace_hits|keyspace_misses'
# 连接拒绝统计
docker exec uredis redis-cli -a "$REDIS_PASSWORD" INFO stats 2>/dev/null | grep -E 'rejected_connections|maxclients'
# Redis配置检查
docker exec uredis redis-cli -a "$REDIS_PASSWORD" CONFIG GET maxclients 2>/dev/null
docker exec uredis redis-cli -a "$REDIS_PASSWORD" CONFIG GET timeout 2>/dev/null
docker exec uredis redis-cli -a "$REDIS_PASSWORD" CONFIG GET save 2>/dev/null
```
## 步骤9: EMQX消息队列检测
```bash
# EMQX状态
docker exec uemqx emqx_ctl status 2>/dev/null
# Broker信息
docker exec uemqx emqx_ctl broker 2>/dev/null
# 会话列表 (关注: 会话数异常)
docker exec uemqx emqx_ctl sessions list 2>/dev/null | wc -l
# 订阅列表
docker exec uemqx emqx_ctl subscriptions list 2>/dev/null | wc -l
# 消息统计
docker exec uemqx emqx_ctl metrics 2>/dev/null | grep -E 'messages|bytes|delivery'
# 保留消息
docker exec uemqx emqx_ctl retainer topics 2>/dev/null
# 认证列表
docker exec uemqx emqx_ctl auth list 2>/dev/null
# 路由列表
docker exec uemqx emqx_ctl route list 2>/dev/null
```
### 9.1 EMQX深度检测 (新增)
```bash
# 客户端连接统计 (在线/离线)
docker exec uemqx emqx_ctl clients list 2>/dev/null | wc -l
# 连接异常统计 (认证失败、连接断开等)
docker exec uemqx emqx_ctl metrics 2>/dev/null | grep -E 'client|connect|auth|disconnect|error'
# 消息丢弃统计 (重要: 消息丢失告警)
docker exec uemqx emqx_ctl metrics 2>/dev/null | grep -iE 'dropped|discard|fail'
# Topic统计 (活跃Topic数量)
docker exec uemqx emqx_ctl topics list 2>/dev/null | wc -l
# EMQX集群状态 (如果是集群模式)
docker exec uemqx emqx_ctl cluster status 2>/dev/null
# EMQX告警
docker exec uemqx emqx_ctl alarms list 2>/dev/null
# EMQX数据板 (Dashboard API)
curl -s http://localhost:18083/api/v5/status 2>/dev/null
```
## 步骤10: Java应用JVM检测
```bash
# Java版本
docker exec ujava2 java -version 2>&1 | head -2
# JVM堆内存 (需要jstat工具，注意: 当前容器内未安装jstat)
docker exec ujava2 jstat -heap 1 2>/dev/null
# GC统计 (关注: FGC Full GC次数 >5 = 警告)
docker exec ujava2 jstat -gc 1 2>/dev/null
docker exec ujava2 jstat -gcutil 1 2>/dev/null
# 类加载统计
docker exec ujava2 jstat -class 1 2>/dev/null
# JIT编译统计
docker exec ujava2 jstat -compiler 1 2>/dev/null
# 堆内存详情
docker exec ujava2 jmap -heap 1 2>/dev/null | grep -E 'Metaspace|Heap|Eden|Survivor|Old'
# 线程dump (查看BLOCKED/WAITING状态线程)
docker exec ujava2 jstack 1 2>/dev/null | grep -E 'State:|BLOCKED|WAITING|TIMED_WAITING' | head -30
```
### 10.1 Java应用深度检测 (新增)
```bash
# JVM运行时信息 (从/proc获取，容器内可能无jstat)
docker exec ujava2 cat /proc/1/cmdline 2>/dev/null | tr '\0' ' '
docker exec ujava2 cat /proc/1/status 2>/dev/null | grep -E 'VmRSS|VmSize|Threads'
# JVM堆内存通过JMX或/proc获取 (替代jstat)
docker exec ujava2 ls -la /proc/1/fd 2>/dev/null | wc -l # 打开文件描述符数
docker exec ujava2 cat /proc/1/status 2>/dev/null | grep Threads # 线程数
docker exec ujava2 cat /proc/1/statm 2>/dev/null # 内存页使用
# Java进程内存映射
docker exec ujava2 cat /proc/1/smaps_rollup 2>/dev/null
# Dubbo服务状态 (从应用日志获取)
docker exec ujava2 grep -i "dubbo" /var/www/java/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | tail -5
# Spring Boot Actuator端点
curl -s http://localhost:8999/actuator/health 2>/dev/null
curl -s http://localhost:8999/actuator/metrics 2>/dev/null | head -20
curl -s http://localhost:8999/actuator/info 2>/dev/null
# 应用配置检查
cat /var/www/java/api/java-meeting/java-meeting2.0/config/application-prod.properties 2>/dev/null | grep -E 'jdbc|spring.datasource|maxPoolSize|connectionTimeout|server.port'
```
## 步骤11: FastDFS检测
```bash
# Tracker状态
docker exec utracker fdfs_monitor /etc/fdfs/client.conf 2>/dev/null | head -40
# Storage状态 (关注: 磁盘空间、同步状态)
docker exec ustorage fdfs_monitor /etc/fdfs/storage.conf 2>/dev/null | head -30
```
### 11.1 FastDFS深度检测 (新增)
```bash
# 存储空间详情 (可用空间趋势)
docker exec ustorage fdfs_monitor /etc/fdfs/storage.conf 2>/dev/null | grep -E 'total storage|free storage|upload|download|delete'
# 文件统计
docker exec ustorage fdfs_file_info 2>/dev/null
# Storage同步状态
docker exec ustorage fdfs_monitor /etc/fdfs/storage.conf 2>/dev/null | grep -E 'sync|last_sync|binlog'
```
## 步骤12: Nginx检测 (新增独立步骤)
```bash
# Nginx版本
docker exec unginx nginx -v 2>&1
# Nginx配置检查
docker exec unginx cat /etc/nginx/nginx.conf 2>/dev/null | grep -E 'worker_processes|worker_connections|max_clients|keepalive_timeout|gzip'
# Nginx错误日志 (最近503/502/504等)
docker exec unginx tail -200 /var/log/nginx/error.log 2>/dev/null | grep -E '502|503|504|error|upstream' | tail -15
# Nginx访问日志统计 (状态码分布)
docker exec unginx tail -500 /var/log/nginx/access.log 2>/dev/null | awk '{print $9}' | sort | uniq -c | sort -rn | head -10
# Nginx访问日志中最慢的请求
docker exec unginx tail -500 /var/log/nginx/access.log 2>/dev/null | sort -k2 -rn | head -10
# Nginx进程状态
docker exec unginx ps aux | grep nginx 2>/dev/null
```
## 步骤13: Java应用日志分析
```bash
# 应用日志路径
APP_LOG_PATHS="/data/services/api/java-meeting/java-meeting2.0/logs /data/services/api/java-meeting/java-meeting-extapi/logs"
# 扫描错误日志 (最近200行)
for log_path in $APP_LOG_PATHS; do
ls $log_path 2>/dev/null | head -5 | while read log; do
echo "=== $log ==="
tail -200 "$log_path/$log" 2>/dev/null | grep -iE 'error|exception|fail' | tail -15
done
done
# 错误类型分类统计 (扩展)
# - MyBatisSystemException / TooManyResultsException: MyBatis查询异常
# - Dubbo RpcException / No provider available: Dubbo服务调用失败
# - welink / dingding: 钉钉/WeLink同步异常
# - MQTT / MqttException: MQTT消息推送异常
# - connection refused / timeout: 连接异常
# - Communications link failure: MySQL通信异常
# - OOM / OutOfMemoryError: 内存溢出
# Java应用健康检查
curl -s http://localhost:8999/actuator/health 2>/dev/null
curl -s http://localhost:8080/api/health 2>/dev/null
```
### 13.1 JAVA应用日志深度检测 (新增)
```bash
# 错误频率统计 (按小时分组，识别错误突发)
tail -1000 /data/services/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | \
grep -oP '\d{4}-\d{2}-\d{2} \d{2}' | sort | uniq -c | sort -rn | head -10
# 钉钉同步失败详情 (从日志提取完整错误)
tail -500 /data/services/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | \
grep -A2 '钉钉同步失败\|getDingDingMeetingList' | tail -10
# Dubbo服务不可用检测 (provider下线)
tail -500 /data/services/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | \
grep 'No provider available' | tail -5
# MQTT连接失败检测
tail -500 /data/services/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | \
grep -i 'mqtt\|MqttException\|无法连接至服务器' | tail -5
# MySQL通信异常检测
tail -500 /data/services/api/java-meeting/java-meeting2.0/logs/ubains-ERROR.log 2>/dev/null | \
grep -i 'Communications link failure\|Connection refused' | tail -5
# 日志文件大小检测
ls -lh /data/services/api/java-meeting/java-meeting2.0/logs/ 2>/dev/null | tail -10
du -sh /data/services/api/java-meeting/java-meeting2.0/logs/ 2>/dev/null
# 应用配置检测
cat /data/services/api/java-meeting/java-meeting2.0/config/application-prod.properties 2>/dev/null | grep -E 'jdbc|datasource|pool|timeout'
```
### 步骤13.2: Python应用日志分析
```bash
# 应用日志路径
APP_LOG_PATHS="/data/services/api/python-cmdb/log"
# 扫描错误日志 (最近200行)
for log_path in $APP_LOG_PATHS; do
ls $log_path 2>/dev/null | head -5 | while read log; do
echo "=== $log ==="
tail -200 "$log_path/$log" 2>/dev/null | grep -iE 'error|exception|fail' | tail -15
done
done
# 错误类型分类统计 (扩展)
# - MyBatisSystemException / TooManyResultsException: MyBatis查询异常
# - MQTT / MqttException: MQTT消息推送异常
# - connection refused / timeout: 连接异常
# - Communications link failure: MySQL通信异常
# - OOM / OutOfMemoryError: 内存溢出
# Python应用健康检查
curl -s http://localhost:8000/actuator/health 2>/dev/null
```
### 步骤13.3: Python_voice应用日志分析
```bash
# 应用日志路径
APP_LOG_PATHS="/data/services/api/python-voice/log"
# 扫描错误日志 (最近200行)
for log_path in $APP_LOG_PATHS; do
ls $log_path 2>/dev/null | head -5 | while read log; do
echo "=== $log ==="
tail -200 "$log_path/$log" 2>/dev/null | grep -iE 'error|exception|fail' | tail -15
done
done
# 错误类型分类统计 (扩展)
# - MyBatisSystemException / TooManyResultsException: MyBatis查询异常
# - MQTT / MqttException: MQTT消息推送异常
# - connection refused / timeout: 连接异常
# - Communications link failure: MySQL通信异常
# - OOM / OutOfMemoryError: 内存溢出
# Python应用健康检查
curl -s http://localhost:8003/actuator/health 2>/dev/null
```
### 步骤13.4: Nacos应用日志分析
```bash
# 应用日志路径
APP_LOG_PATHS="/data/middleware/nacos/logs"
# 扫描错误日志 (最近200行)
for log_path in $APP_LOG_PATHS; do
ls $log_path 2>/dev/null | head -5 | while read log; do
echo "=== $log ==="
tail -200 "$log_path/$log" 2>/dev/null | grep -iE 'error|exception|fail' | tail -15
done
done
# 错误类型分类统计 (扩展)
# - MyBatisSystemException / TooManyResultsException: MyBatis查询异常
# - connection refused / timeout: 连接异常
# - Communications link failure: MySQL通信异常
# - OOM / OutOfMemoryError: 内存溢出
# Nacos应用健康检查
curl -s http://localhost:8848/actuator/health 2>/dev/null
```
### 步骤13.5: Nginx应用日志分析
```bash
# 应用日志路径
APP_LOG_PATHS="/data/middleware/nginx/log"
# 扫描错误日志 (最近200行)
for log_path in $APP_LOG_PATHS; do
ls $log_path 2>/dev/null | head -5 | while read log; do
echo "=== $log ==="
tail -200 "$log_path/$log" 2>/dev/null | grep -iE 'error|exception|fail' | tail -15
done
done
# 错误类型分类统计 (扩展)
# - MyBatisSystemException / TooManyResultsException: MyBatis查询异常
# - connection refused / timeout: 连接异常
# - Communications link failure: MySQL通信异常
# - OOM / OutOfMemoryError: 内存溢出
# nginx应用健康检查
curl -v -k https://localhost:443 2>/dev/null
```
## 步骤14: 系统日志分析
```bash
# 内核错误 (24小时内)
journalctl -k --since '24 hours ago' --no-pager | grep -ci error
# 认证失败 (24小时内)
journalctl --since '24 hours ago' --no-pager | grep -ci 'authentication failure'
# 磁盘错误 (24小时内)
journalctl --since '24 hours ago' --no-pager | grep -ciE 'I/O error|disk error'
# 最近系统错误
journalctl -p err --since '1 hour ago' --no-pager -n 100
# dmesg错误
dmesg -T 2>/dev/null | grep -iE 'error|fail|timeout' | tail -30
# /var/log/messages服务统计
cat /var/log/messages 2>/dev/null | tail -100 | awk '{print $5}' | sort | uniq -c | sort -rn | head -10
```
### 14.1 系统日志深度检测 (新增)
```bash
# OOM Killer日志
journalctl -k --since '7 days ago' --no-pager | grep -i "oom\|out of memory\|killed process"
# 内核panic/oops检测
journalctl -k --since '7 days ago' --no-pager | grep -iE "panic|oops|BUG:|call trace" | tail -10
# 服务崩溃重启记录
journalctl --since '7 days ago' --no-pager | grep -iE "segfault|core dump|signal" | tail -10
# SSH暴力破解检测 (同一IP登录失败>10次)
journalctl --since '24 hours ago' --no-pager | grep 'Failed password' | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn | head -10
# systemd服务失败列表
systemctl list-units --type=service --state=failed --no-pager --no-legend
# 系统资源耗尽事件
journalctl --since '7 days ago' --no-pager | grep -iE "resource temporarily unavailable|cannot allocate|too many open" | tail -10
```
## 步骤15: 安全检测
```bash
# 认证失败历史
journalctl --since '24 hours ago' --no-pager | grep -i 'sudo.*FAILED'
# 最近登录
last -20 | head -15
# 当前登录用户
who
# SELinux状态
getenforce 2>/dev/null
# 防火墙规则
firewall-cmd --list-all 2>/dev/null
# 开放端口 (TCP/UDP分别列出)
ss -tlnp 2>/dev/null | tail -n +2 | head -30
ss -ulnp 2>/dev/null | tail -n +2 | head -20
# iptables规则
iptables -L -n --line-numbers 2>/dev/null | head -50
```
### 15.1 安全深度检测 (新增)
```bash
# 异常账户检测 (UID=0的非root账户)
awk -F: '$3==0 && $1!="root" {print $1}' /etc/passwd
# 可疑SUID文件
find / -perm -4000 -type f 2>/dev/null | grep -v -E '^/(usr/bin|usr/sbin|bin|sbin)' | head -10
# 最近修改的关键系统文件
find /etc -name "*.conf" -mtime -1 2>/dev/null | head -10
# 异常cron任务
ls -la /etc/cron.d/ 2>/dev/null
cat /etc/crontab 2>/dev/null | grep -v '^#'
# 登录失败最多的IP (暴力破解)
lastb 2>/dev/null | awk '{print $3}' | sort | uniq -c | sort -rn | head -10
# 空密码账户检测
awk -F: '($2=="" || $2=="!") {print $1}' /etc/shadow 2>/dev/null
# SSH配置安全检查
grep -E 'PermitRootLogin|PasswordAuthentication|MaxAuthTries|Port' /etc/ssh/sshd_config 2>/dev/null
```
## 步骤16: 定时任务检测
```bash
# Crontab列表
crontab -l 2>/dev/null
# Systemd定时器
systemctl list-timers --no-pager --no-legend | head -15
```
## 步骤17: NTP时钟同步检测 (新增)
```bash
# NTP同步状态
timedatectl status 2>/dev/null
# 时钟同步源
chronyc sources 2>/dev/null || ntpq -p 2>/dev/null
# 时钟偏差
chronyc tracking 2>/dev/null | grep -E 'System time|Last offset|RMS offset'
# 系统时间准确性
date
```
## 步骤18: SSL证书有效期检测 (新增)
```bash
# HTTPS证书有效期检查
echo | openssl s_client -connect localhost:443 -servername localhost 2>/dev/null | openssl x509 -noout -dates -subject 2>/dev/null
# EMQX SSL证书有效期
echo | openssl s_client -connect localhost:8883 2>/dev/null | openssl x509 -noout -dates -subject 2>/dev/null
# 证书到期天数计算 (<=30天 = 警告, <=7天 = 严重)
```
## 步骤19: 端口与服务状态检测 (新增独立步骤)
```bash
# 关键端口监听检测 (统一检查所有服务端口)
# 预期端口列表: 8306(MySQL), 6379(Redis), 1883(EMQX-MQTT), 8883(EMQX-SSL),
# 8083(EMQX-WS), 8080(Java-Web), 443(HTTPS), 8997/8998/8999(Java),
# 22122(FastDFS-Tracker), 23000(FastDFS-Storage)
for port in 22 443 1883 6379 8000 8003 8080 8306 8883 8997 8998 8999 22122 23000; do
result=$(ss -tlnp 2>/dev/null | grep ":${port}" | grep LISTEN)
if [ -n "$result" ]; then
echo "PORT $port: ✅ LISTENING"
else
echo "PORT $port: ❌ NOT LISTENING"
fi
done
# 服务状态检测 (Docker容器运行状态)
for container in umysql uredis uemqx ujava2 utracker ustorage; do
status=$(docker inspect --format='{{.State.Status}}' $container 2>/dev/null || echo "not_found")
echo "$container: $status"
done
```
## 步骤20: 核心问题诊断
```bash
# 自动汇总所有检测中发现的异常
# 1. 系统负载检查
cat /proc/loadavg | awk '{if ($1 > 10) print "CRITICAL: 系统负载严重过高 " $1; else if ($1 > 8) print "WARNING: 系统负载偏高 " $1}'
# 2. 内存压力检查
free | grep Mem | awk '{pct=$3/$2*100; if (pct>85) print "CRITICAL: 内存使用率过高 " pct "%"}'
# 3. Swap使用检查
free | grep Swap | awk '{if ($3>0) print "WARNING: Swap已使用 " $3/1024/1024 "GB"}'
# 4. 磁盘IO检查
iostat -x 1 2 2>/dev/null | tail -10 | awk '/sd|vd/ {if ($12+0 > 80) print "WARNING: 磁盘"$1" IO过高 "$12"%"}'
# 5. MySQL慢查询检查
docker exec umysql mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW GLOBAL STATUS LIKE 'Slow_queries';" 2>/dev/null | tail -1
# 6. 僵尸进程检查
ps aux | grep -c ' Z '
# 7. TIME_WAIT连接检查
ss -s | grep TimeWait
```
## 步骤21: 对比分析
```bash
# 与上次巡检结果对比 (需要保存上次数据为JSON)
# 对比指标:
# - CPU使用率变化
# - 内存使用率变化
# - Swap使用率变化
# - 系统负载变化
# - 总线程数变化
# - 文件描述符使用率变化
# - TCP连接状态变化 (ESTABLISHED/TIME_WAIT/CLOSE_WAIT)
# - MySQL连接数变化
# - MySQL慢查询数变化
# - Redis客户端连接变化
# - Redis键总数变化
# - 磁盘使用率变化 (各分区)
# - Docker容器资源变化 (CPU/内存/网络IO/磁盘IO)
# - EMQX会话数变化
# - 认证失败次数变化
# - 应用错误数变化
# 对比结果标记:
# - 🟢 改善 (指标下降)
# - 🔴 恶化 (指标上升)
# - 持平 (变化<0.01)
```
---
# 报告输出格式
请按以下Markdown格式输出完整的健康巡检报告:
```markdown
# 服务器全深入巡检报告 v3 (终极版)
**时间:** YYYY-MM-DD HH:MM:SS
**主机:** 192.168.5.44 (hostname)
**操作系统:** openEuler 24.03 (LTS-SP3)
**内核:** Linux version...
**运行时间:** YYYY-MM-DD HH:MM:SS
**状态:** 正常 / 警告 / 严重
---
## 核心问题诊断
**严重问题:**
- [问题描述] - 详细说明
**警告:**
- [问题描述]
诊断摘要: 关键问题: N, 警告: N
---
## 资源使用概览
| 指标 | 当前值 | 阈值 | 状态 |
| :--- | :--- | :--- | :--- |
| CPU使用率 | XX% | 85% | 状态图标 |
| 内存使用率 | XX% | 85% | 状态图标 |
| Swap使用率 | XX% | - | 状态图标 |
| 磁盘使用率 | XX% | 90% | 状态图标 |
| 网络连接 | ESTABLISHED:NNN | - | 状态图标 |
| 线程总数 | NNN | 1000 | 状态图标 |
| 文件描述符使用率 | XX% | 80% | 状态图标 |
| 系统负载(1min) | X.XX | 8 | 状态图标 |
---
## 进程资源TOP排名
**CPU TOP15 (按CPU使用率降序):**
| 排名 | PID | 进程名 | CPU% | 内存% |
| :--- | :--- | :--- | :--- | :--- |
| 1 | NNN | 进程名 | 状态图标数值 | 数值 |
**内存 TOP15 (按内存使用率降序):**
| 排名 | PID | 进程名 | 内存% | CPU% |
| :--- | :--- | :--- | :--- | :--- |
| 1 | NNN | 进程名 | 状态图标数值 | 数值 |
**线程最多的进程 TOP15:**
| 排名 | PID | 进程名 | 线程数 | CPU% | 内存% |
| :--- | :--- | :--- | :--- | :--- | :--- |
| 1 | NNN | 进程名 | 状态图标数值 | 数值 | 数值 |
**系统总线程数:** NNN
---
## MySQL全深度分析
- **版本:** X.X.X
- **运行时间:** N秒
- **当前连接:** N / max_connections (使用率XX%)
- **历史最大连接:** N
- **慢查询数:** NNNNNN
- **数据库:** db1, db2, ...
- **QPS:** XX (每秒查询数)
- **数据库大小:** XX MB
**MySQL变量:**
- max_connections: `151`
- wait_timeout: `28800`
- innodb_buffer_pool_size: `134217728` (128MB)
**InnoDB缓冲池命中率:** XX%
**InnoDB缓冲池:**
```
[缓冲池详细信息]
```
**表统计(TOP20):**
- schema.table | rows | data_MB | index_MB
**表碎片检测(TOP10):**
- schema.table | 碎片MB
---
## Redis全深度分析
- **版本:** X.X.X
- **运行天数:** N天
- **客户端连接:** N
- **内存使用:** X.XX GB
- **内存碎片率:** X.XX
- **总键数:** NNNNNNNN
- **缓存命中率:** XX%
- **过期键比例:** XX%
**Redis命令统计(TOP10):**
- command: calls=N, usec_per_call=X.XX
**Keyspace:**
- db0:keys=NNNNNNNN,expires=NNNNNNNN
---
## EMQX消息队列全深度分析
- **版本:** X.X.X
- **运行时间:** N days, N hours, N minutes
- **会话数:** N
- **订阅数:** N
- **客户端连接数:** N
**EMQX消息统计:**
- messages.delivered: N
- messages dropped: N
- 认证失败: N
---
## Java应用JVM全深度分析
- **Java版本:** X.X.X
- **进程内存(VmRSS):** XXX MB
- **进程线程数:** N
- **打开文件描述符:** N
- **Young GC:** N
- **Full GC:** N
- **GC利用率:** XX%
**JVM堆内存:**
```
[堆内存详细信息]
```
## Python应用全深度分析
- **Python版本:** X.X.X
- **进程内存(VmRSS):** XXX MB
- **进程线程数:** N
- **打开文件描述符:** N
- **Young GC:** N
- **Full GC:** N
- **GC利用率:** XX%
## Python_voice应用全深度分析
- **Python版本:** X.X.X
- **进程内存(VmRSS):** XXX MB
- **进程线程数:** N
- **打开文件描述符:** N
- **Young GC:** N
- **Full GC:** N
- **GC利用率:** XX%
## Nginx应用全深度分析
- **Nginx版本:** X.X.X
- **进程内存(VmRSS):** XXX MB
- **进程线程数:** N
- **打开文件描述符:** N
- **Young GC:** N
- **Full GC:** N
- **GC利用率:** XX%
## Nacos应用全深度分析
- **Nacos版本:** X.X.X
- **进程内存(VmRSS):** XXX MB
- **进程线程数:** N
- **打开文件描述符:** N
- **Young GC:** N
- **Full GC:** N
- **GC利用率:** XX%
**Dubbo服务状态:**
- Provider可用性: 正常/异常
---
## Docker容器资源全分析
| 容器名 | CPU% | 内存使用 | 内存% | 网络IO | 磁盘IO | 运行时间 | 重启次数 |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| umysql | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| uredis | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| uemqx | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| ujava2 | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| utracker | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| ustorage | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| upython | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| upython_voice | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| unginx | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
| unacos | N% | NMiB/NGiB | N% | IO量 | IO量 | N天 | N |
**容器日志文件大小:**
- umysql: XX MB
- ujava2: XX MB
- ...
**Docker磁盘总使用:**
- 镜像: XX GB
- 容器: XX GB
- 卷: XX GB
---
## Nginx分析
- **版本:** X.X.X
- **Worker配置:** worker_processes=N, worker_connections=N
- **最近错误:** N条
**HTTP状态码分布:**
- 200: N次
- 4xx: N次
- 5xx: N次
---
## 端口与服务状态检测
| 端口 | 服务 | 状态 | 监听 | 连接数 |
| :--- | :--- | :--- | :--- | :--- |
| 8306 | MySQL | 运行中 | LISTEN | N |
| 6379 | Redis | 运行中 | LISTEN | N |
| 1883 | EMQX-MQTT | 运行中 | LISTEN | N |
| ... | ... | ... | ... | ... |
---
## 会议系统应用日志分析
**错误总数:** N
**错误类型统计:**
- Dubbo服务调用失败: N次
- 钉钉同步异常: N次
- MQTT连接失败: N次
- MySQL通信异常: N次
- MyBatis查询异常: N次
- 其他异常: N次
**最近错误日志:**
> [logfile] error:异常信息
**错误频率(按小时):**
- HH:00 N次
- HH:00 N次
---
## 网络TCP连接状态分析
- ESTABLISHED: N
- LISTEN: N
- TIME_WAIT: N (>500 = 警告)
- CLOSE_WAIT: N (>100 = 警告)
**网络连通性:**
- 网关(192.168.5.1): 正常/异常
- DNS解析: 正常/异常
- 钉钉API: 正常/异常 (响应时间Xs)
- 容器间通信: 正常/异常
---
## 系统日志统计(24小时)
- **内核错误:** N
- **认证失败:** N
- **磁盘错误:** N
- **OOM事件:** N
- **SSH暴力破解IP TOP5:** IP1(N次), IP2(N次)
---
## NTP时钟同步状态
- **时钟同步:** 是/否
- **时钟偏差:** X.XX秒
- **NTP服务器:** XXX
---
## SSL证书有效期
- **HTTPS(443):** 到期日期, 剩余N天
- **EMQX(8883):** 到期日期, 剩余N天
---
## 定时任务
- **Crontab:** 任务列表
- **Systemd定时器:** 定时器列表
---
## 安全检测摘要
- **SELinux:** Enforcing/Permissive/Disabled
- **防火墙:** active/inactive
- **开放端口:** N个
- **异常账户:** 无/有
- **SSH配置:** 密码认证开启/关闭, root登录允许/禁止
---
## AI分析建议
1. [严重问题] - 需要立即处理
2. [警告问题] - 建议关注
3. [优化建议]
4. [趋势预测]
---
## 与上次巡检对比分析
**上次巡检时间:** YYYY-MM-DD HH:MM:SS
**本次巡检时间:** YYYY-MM-DD HH:MM:SS
**新增问题:**
- [问题描述]
**已解决问题:**
- [问题描述]
**关键指标变化:**
| 指标 | 上次值 | 本次值 | 变化 | 趋势 |
| :--- | :--- | :--- | :--- | :--- |
| CPU使用率 | XX% | XX% | +/-X% | 图标趋势 |
**Docker容器变化:**
- **umysql**: CPU: X% -> Y%; 内存%: X% -> Y%
**应用错误变化:** 上次 N -> 本次 N (新增/减少 N 个)
---
*报告生成时间: YYYY-MM-DD HH:MM:SS*
*全深入巡检 v3 终极版 - 检测点数量: 120+*
```
---
# 判断标准参考
## 阈值配置
- CPU使用率 > 85% = 警告, > 100% = 严重
- 内存使用率 > 85% = 警告, > 95% = 严重
- 磁盘使用率 > 90% = 警告, > 95% = 严重
- Inode使用率 > 90% = 警告
- Swap任何使用 = 警告, > 20% = 严重
- 系统负载 > 8 = 警告, > 16 = 严重
- 磁盘IO %util > 80% = 警告
- MySQL慢查询 > 100 = 警告, > 1000000 = 严重
- MySQL连接使用率 > 80% = 警告
- MySQL缓冲池命中率 < 95% = 警告
- 线程总数 > 1000 = 警告, > 3000 = 严重
- 文件描述符使用率 > 80% = 警告
- Redis键数量 > 1000000 = 警告
- Redis内存碎片率 > 5 = 警告, > 10 = 严重
- Redis缓存命中率 < 90% = 警告
- TIME_WAIT连接 > 500 = 警告, > 5000 = 严重
- CLOSE_WAIT连接 > 100 = 警告
- 僵尸进程 > 0 = 严重
- D状态进程 > 5 = 警告
- Full GC > 5次 = 警告, > 20次 = 严重
- Docker容器重启次数 > 0 = 警告
- 容器日志文件 > 500MB = 警告, > 2GB = 严重
- 认证失败(24h) > 100 = 警告, > 1000 = 严重
- SSL证书剩余 < 30天 = 警告, < 7天 = 严重
- NTP时钟偏差 > 1秒 = 警告
- 应用错误(单次巡检) > 50 = 警告, > 200 = 严重
- OOM事件 > 0 = 严重
## 进程资源图标
- CPU > 80%: 严重
- CPU 50-80%: 警告
- CPU < 50%: 正常
- 内存 > 80%: 严重
- 内存 50-80%: 警告
- 内存 < 50%: 正常
- 线程数 > 500: 严重
- 线程数 50-500: 警告
- 线程数 < 50: 正常
## 整体状态判断
- 严重问题 >= 3: 严重
- 严重问题 >= 1: 严重
- 警告 >= 3: 警告
- 警告 >= 1: 警告
- 无问题: 正常
---
# 注意事项
1. **安全性**: 只读操作优先，不要执行任何修改命令
2. **深度**: 不仅使用top，必须结合ps、ss、lsof、/proc等进行深层诊断
3. **完整性**: 120+检测点必须全部执行，不能遗漏
4. **客观性**: 所有数值必须来自实际命令输出，不要臆测
5. **可操作性**: AI建议必须具体可执行，不能泛泛而谈
6. **容器化适配**: 注意MySQL端口映射是8306→3306，不是直接3306
7. **JVM兼容**: ujava2容器内未安装jstat/jmap工具，需要通过/proc替代方案获取JVM信息
8. **历史对比**: 每次巡检保存JSON数据，下次自动进行对比分析
9. **错误分类**: 应用日志错误需要细分为Dubbo/钉钉/MQTT/MySQL/MyBatis等具体类型
10. **趋势预警**: 关注资源使用趋势，提前预警即将触达阈值的指标
```
自动化部署脚本/x86架构/新统一平台/auto_deploy_services.sh
浏览文件 @ ead4ed00
......@@ -697,6 +697,61 @@ function paperless_x86() {
}
# 电子桌牌服务部署
# 新增：配置 9990 端口防火墙的独立函数
configure_firewall_for_9990() {
log "INFO" "🛡️ 开始配置防火墙，开放 9990 端口..."
# 1. 检查 9990 端口是否已经开放
if firewall-cmd --zone=public --list-ports | grep -qw "9990/tcp"; then
log "INFO" "✅ 防火墙检测到 9990/tcp 端口已开放，跳过端口添加步骤。"
else
# 2. 在 /etc/firewalld/zones/public.xml 的 <forward/> 前追加端口配置
local public_xml="/etc/firewalld/zones/public.xml"
if [ -f "$public_xml" ]; then
# 使用 sed 在 <forward/> 标签前插入端口配置
sed -i '/<forward\/>/i\ <port protocol="tcp" port="9990"/>' "$public_xml"
if [ $? -eq 0 ]; then
log "INFO" "✅ 已成功在 $public_xml 中追加 9990 端口配置。"
else
log "ERROR" "❌ 修改 $public_xml 文件失败，请检查文件权限。"
return 1
fi
else
log "ERROR" "❌ 未找到防火墙配置文件: $public_xml"
return 1
fi
fi
# 3. 执行防火墙不拦截 127.0.0.1 的请求
iptables -I INPUT -s 127.0.0.0/8 -j ACCEPT
if [ $? -eq 0 ]; then
log "INFO" "✅ 已添加 iptables 规则，放行 127.0.0.0/8 网段请求。"
else
log "WARN" "⚠️ 添加 iptables 规则失败，请检查是否具有 root 权限。"
fi
# 4. 防火墙重载
firewall-cmd --reload
if [ $? -eq 0 ]; then
log "INFO" "✅ 防火墙配置已重载 (firewall-cmd --reload)。"
else
log "ERROR" "❌ 防火墙重载失败！"
return 1
fi
# 5. 检查并输出当前防火墙状态
log "INFO" "🔍 正在验证 9990 端口开放状态..."
local list_all_output=$(firewall-cmd --list-all)
if echo "$list_all_output" | grep -q "9990/tcp"; then
log "INFO" "✅ 验证通过，9990 端口已成功开放！"
else
log "ERROR" "❌ 验证失败，9990 端口未在防火墙规则中生效。"
return 1
fi
return 0
}
function cardtable_x86() {
local service_name="电子桌牌服务 (cardtable)"
local container_name="cardtable"
......@@ -712,6 +767,13 @@ function cardtable_x86() {
log "INFO" " 工作目录: $work_dir"
log "INFO" "=================================================================="
# 【新增步骤】在启动容器前，配置防火墙开放 9990 端口
configure_firewall_for_9990
if [ $? -ne 0 ]; then
log "ERROR" "❌ 防火墙配置失败，终止容器启动！"
return 1
fi
# 1. 检查镜像压缩包是否存在
if [ ! -f "$image_tar" ]; then
log "ERROR" "❌ 镜像文件不存在: $image_tar"
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论