我的个人博客

Linux实战：如何查看服务器进程占用，快速定位资源消耗异常

Tue, 28 Apr 2026 14:47:19 +0800

进程与系统监控

进程管理核心命令 ps - 进程快照分析

# 全格式显示所有进程

root@server:~# ps aux | head -10
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.3 167548 11504 ?        Ss    2025   1:56 /lib/systemd/systemd --system --deserialize 48 noibrs
root           2  0.0  0.0      0     0 ?        S     2025   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        I<    2025   0:00 [rcu_gp]
root           4  0.0  0.0      0     0 ?        I<    2025   0:00 [rcu_par_gp]
root           5  0.0  0.0      0     0 ?        I<    2025   0:00 [slub_flushwq]
root           6  0.0  0.0      0     0 ?        I<    2025   0:00 [netns]
root           8  0.0  0.0      0     0 ?        I<    2025   0:00 [kworker/0:0H-events_highpri]
root          10  0.0  0.0      0     0 ?        I<    2025   0:00 [mm_percpu_wq]
root          11  0.0  0.0      0     0 ?        S     2025   0:00 [rcu_tasks_rude_]

# 树状结构显示进程关系

root@server:~# ps auxf | grep -E '(nginx|apache)'
root     1952087  0.0  0.0   6480  2552 pts/0    S+   11:04   0:00      |   \_ grep --color=auto -E (nginx|apache)
root     1904076  0.0  0.3  55800 13184 ?        S    06:45   0:00 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
www-data 1904079  0.0  0.1  56552  6624 ?        S    06:45   0:00  \_ nginx: worker process
www-data 1904080  0.0  0.1  56552  6624 ?        S    06:45   0:00  \_ nginx: worker process

# 自定义输出格式（CPU和内存排序）

root@server:~# ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%cpu | head -15
    PID    PPID CMD                         %CPU %MEM
   2073       1 /usr/local/aegis/aegis_clie  2.4  1.3
   1578    1453 ./MediaServer -s default.pe  0.8  0.6
1905031  471143 sshd: root@pts/0,pts/1       0.5  0.3
   1551    1432 java -Djava.security.egd=fi  0.3 13.5
   1007       1 /usr/local/aegis/aegis_clie  0.2  0.3
   1553    1472 mysqld --character-set-serv  0.1 10.4
   1571    1446 redis-server *:6379          0.1  0.0
1905175 1905133 top                          0.1  0.1
      1       0 /lib/systemd/systemd --syst  0.0  0.3
      2       0 [kthreadd]                   0.0  0.0
      3       2 [rcu_gp]                     0.0  0.0
      4       2 [rcu_par_gp]                 0.0  0.0
      5       2 [slub_flushwq]               0.0  0.0
      6       2 [netns]                      0.0  0.0

# 实战：查找内存泄漏进程

root@server:~# ps aux --sort=-%mem | awk 'NR<=10{printf "%-8s %-6s %s\n", $1, $4, $11}'
USER     %MEM   COMMAND
root     13.5   java
lxd      10.4   mysqld
1000     3.6    8fdf65d387f2
root     2.4    /lib/systemd/systemd-journald
root     1.3    /usr/local/aegis/aegis_client/aegis_12_81/AliYunDunMonitor
root     0.7    /usr/libexec/fwupd/fwupd
root     0.7    /sbin/multipathd
root     0.6    /usr/bin/python3
root     0.6    ./MediaServer

top 与 htop - 实时性能监控

# top交互式命令

# P - 按CPU排序，M - 按内存排序，T - 按时间排序

# k - 杀死进程，r - 修改nice值

top - 11:05:46 up 127 days, 18:23,  2 users,  load average: 0.04, 0.09, 0.08
Tasks: 155 total,   1 running, 154 sleeping,   0 stopped,   0 zombie
%Cpu0  :   2.7/2.3     5[|||||                                                                                               ]
%Cpu1  :   2.0/2.0     4[||||                                                                                                ]
MiB Mem : 48.1/3576.7   [||||||||||||||||||||||||||||||||||||||||||||||||                                                    ]
MiB Swap:  0.0/0.0      [                                                                                                    ]
    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                                                                                                            
   2073 root      20   0  178224  47940      0 S   4.3   1.3   4469:11 AliYunDunMonito                                                                                                                                    
   1578 root      20   0  461004  22716   1700 S   1.0   0.6   1643:35 MediaServer                                                                                                                                        
   1599 1000      20   0 1238036 134412    172 S   0.7   3.7 146:04.33 beam.smp                                                                                                                                           
   1007 root      20   0   97632  13844   6116 S   0.3   0.4 412:48.98 AliYunDun                                                                                                                                          
   1551 root      20   0 3815708 497204    308 S   0.3  13.6 575:32.33 java                                                                                                                                               
1905031 root      20   0   17744  12040   9104 S   0.3   0.3   0:24.57 sshd                                                                                                                                               
1952935 root      20   0   10812   4580   3808 R   0.3   0.1   0:00.02 top                                                                                                                                                
      1 root      20   0  167548  11504   6720 S   0.0   0.3   1:56.51 systemd                                                                                                                                            
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.45 kthreadd                                                                                                                                           
      3 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_gp                                                                                                                                             
      4 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_par_gp                                                                                                                                         
      5 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 slub_flushwq                                                                                                                                       
      6 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 netns                                                                                                                                              
      8 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/0:0H-events_highpri                                                                                                                        
     10 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 mm_percpu_wq                                                                                                                                       
     11 root      20   0       0      0      0 S   0.0   0.0   0:00.00 rcu_tasks_rude_                                                                                                                                    
     12 root      20   0       0      0      0 S   0.0   0.0   0:00.00 rcu_tasks_trace                                                                                                                                    
     13 root      20   0       0      0      0 S   0.0   0.0   3:20.55 ksoftirqd/0                                                                                                                                        
     14 root      20   0       0      0      0 I   0.0   0.0  66:40.81 rcu_sched                                                                                                                                          
     15 root      rt   0       0      0      0 S   0.0   0.0   0:16.36 migration/0                                                                                                                                        
     16 root     -51   0       0      0      0 S   0.0   0.0   0:00.00 idle_inject/0                                                                                                                                      
     18 root      20   0       0      0      0 S   0.0   0.0   0:00.00 cpuhp/0                                                                                                                                            
     19 root      20   0       0      0      0 S   0.0   0.0   0:00.00 cpuhp/1

top -p $(pgrep -d',' nginx) # 仅监控nginx进程

top - 11:06:14 up 127 days, 18:23,  2 users,  load average: 0.10, 0.10, 0.09
Tasks:   3 total,   0 running,   3 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.0 us,  1.7 sy,  0.0 ni, 96.1 id,  0.0 wa,  0.0 hi,  0.2 si,  0.0 st
MiB Mem :   3576.7 total,    111.1 free,   1440.6 used,   2025.1 buff/cache
MiB Swap:      0.0 total,      0.0 free,      0.0 used.   1855.1 avail Mem 
    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                                                                                                            
1904076 root      20   0   55800  13184  10972 S   0.0   0.4   0:00.00 nginx                                                                                                                                              
1904079 www-data  20   0   56552   6624   4016 S   0.0   0.2   0:00.00 nginx                                                                                                                                              
1904080 www-data  20   0   56552   6624   4016 S   0.0   0.2   0:00.00 nginx

# htop高级功能（需安装）

htop -u www-data # 仅显示特定用户进程

htop -t # 显示进程树

TRAE IDE效率提升：在TRAE IDE的终端中，可以直接使用htop的彩色输出，配合智能命令补全功能，快速定位性能瓶颈进程。

2. ps — 静态快照，适合脚本化

当需要批量输出或集成到脚本中时，ps 比 top 更灵活：

bash

复制

# 查看占用 CPU 最高的 10 个进程

ps aux --sort=-%cpu | head -10
root@server:~# ps aux --sort=-%cpu | head -10
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root        2073  2.4  1.3 178224 47940 ?        Ssl   2025 4469:16 /usr/local/aegis/aegis_client/aegis_12_81/AliYunDunMonitor
root        1578  0.8  0.6 461004 22716 ?        Ssl   2025 1643:36 ./MediaServer -s default.pem -c ../conf/config.ini -l 0
root     1905031  0.5  0.3  17744 12040 ?        Ss   09:54   0:25 sshd: root@pts/0,pts/1
root        1551  0.3 13.5 3815708 497204 ?      Ssl   2025 575:32 java -Djava.security.egd=file:/dev/./urandom -jar wvp-pro.jar
root        1007  0.2  0.3  97632 13844 ?        Ssl   2025 412:49 /usr/local/aegis/aegis_client/aegis_12_81/AliYunDun
lxd         1571  0.1  0.1  55388  3696 ?        Ssl   2025 191:36 redis-server *:6379
root     1905175  0.1  0.1  11856  5184 pts/1    S+   09:54   0:07 top
root           1  0.0  0.3 167548 11504 ?        Ss    2025   1:56 /lib/systemd/systemd --system --deserialize 48 noibrs

# 查看占用内存最高的 10 个进程

ps aux --sort=-%mem | head -10
root@server:~# ps aux --sort=-%mem | head -10
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root        1551  0.3 13.5 3815708 497204 ?      Ssl   2025 575:32 java -Djava.security.egd=file:/dev/./urandom -jar wvp-pro.jar
root      526775  0.0  2.4 383836 89316 ?        S<s  Mar25   2:04 /lib/systemd/systemd-journald
root        2073  2.4  1.3 178224 47940 ?        Ssl   2025 4469:16 /usr/local/aegis/aegis_client/aegis_12_81/AliYunDunMonitor
root     1929518  0.0  0.7 386544 27452 ?        Ssl  10:30   0:00 /usr/libexec/fwupd/fwupd
root         431  0.0  0.7 289312 27096 ?        SLsl  2025   8:05 /sbin/multipathd -d -s
root     1154764  0.0  0.6 261412 23220 ?        Ssl  Apr16   1:23 /usr/bin/python3 -Es /usr/sbin/tuned -l -P
root        1578  0.8  0.6 461004 22716 ?        Ssl   2025 1643:36 ./MediaServer -s default.pem -c ../conf/config.ini -l 0

# 自定义输出格式（PID、命令、CPU、内存）

ps -eo pid,cmd,%cpu,%mem --sort=-%cpu | head -15
root@server:~# ps -eo pid,cmd,%cpu,%mem --sort=-%cpu | head -15
    PID CMD                         %CPU %MEM
   2073 /usr/local/aegis/aegis_clie  2.4  1.3
   1578 ./MediaServer -s default.pe  0.8  0.6
1905031 sshd: root@pts/0,pts/1       0.5  0.3
   1551 java -Djava.security.egd=fi  0.3 13.5
   1007 /usr/local/aegis/aegis_clie  0.2  0.3
   1553 mysqld --character-set-serv  0.1 10.4
   1571 redis-server *:6379          0.1  0.1
1905175 top                          0.1  0.1
      1 /lib/systemd/systemd --syst  0.0  0.3
      2 [kthreadd]                   0.0  0.0
      3 [rcu_gp]                     0.0  0.0
      4 [rcu_par_gp]                 0.0  0.0
      5 [slub_flushwq]               0.0  0.0
      6 [netns]                      0.0  0.0

# 查看特定服务的所有进程

ps auxf | grep -E '(nginx|java|mysql)'
root@server:~# ps auxf | grep -E '(nginx|java|mysql)'
root        1551  0.3 13.5 3815708 497204 ?      Ssl   2025 575:32  \_ java -Djava.security.egd=file:/dev/./urandom -jar wvp-pro.jar
lxd         1553  0.1 10.4 1818220 382896 ?      Ssl   2025 340:14  \_ mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --default-authentication-plugin=mysql_native_password --explicit_defaults_for_timestamp=0 --sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION --explicit_defaults_for_timestamp=0
root     1954784  0.0  0.0   6612  2372 pts/0    S+   11:08   0:00      |   \_ grep --color=auto -E (nginx|java|mysql)
root     1904076  0.0  0.3  55800 13160 ?        S    06:45   0:00 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
www-data 1904079  0.0  0.1  56552  6600 ?        S    06:45   0:00  \_ nginx: worker process
www-data 1904080  0.0  0.1  56552  6600 ?        S    06:45   0:00  \_ nginx: worker process

批量查看多维度资源占用：

ps -eo pid,ppid,cmd,%cpu,%mem,nlwp --sort=-%cpu | head -10
root@server:~# ps -eo pid,ppid,cmd,%cpu,%mem,nlwp --sort=-%cpu | head -10
    PID    PPID CMD                         %CPU %MEM NLWP
   2073       1 /usr/local/aegis/aegis_clie  2.4  1.3   30
   1578    1453 ./MediaServer -s default.pe  0.8  0.6    7
1905031  471143 sshd: root@pts/0,pts/1       0.5  0.3    1
   1551    1432 java -Djava.security.egd=fi  0.3 13.5  354
   1007       1 /usr/local/aegis/aegis_clie  0.2  0.3   12
   1553    1472 mysqld --character-set-serv  0.1 10.4   44
   1571    1446 redis-server *:6379          0.1  0.0    5
1905175 1905133 top                          0.1  0.1    1
      1       0 /lib/systemd/systemd --syst  0.0  0.3    1

nlwp 列显示线程数，适合排查线程泄漏问题。

#进程PID查询，必须是唯一进程

查询进程运行时长：ps -p `pgrep -f python|awk 'NR==4'` -o etime|awk 'NR==2 {print $1}'

root@server:~# ps -p `pgrep -f python|awk 'NR==1'` -o etime|awk 'NR==2 {print $1}'
9-17:44:22

#如上：显示进程已经运行9天，17小时44分22秒

linux限制指定进程运行时间（可用于解决某些程序运行时间过长后导致的异常问题）

Thu, 16 Apr 2026 09:51:36 +0800

#!/bin/bash

#通过进程名查询进程PID，注意需要保证查询结果必须是唯一进程

process_pid=`pgrep -f java`

#提取进程运行小时数据

hour=`ps -p $process_pid -o etime|awk 'NR==2 {print $1}' |awk -F':' '{print $1}'`

#提取进程运行分钟数据

min=`ps -p $process_pid -o etime|awk 'NR==2 {print $1}' |awk -F':' '{print $2}'`

#提取进程运行秒数据

seconds=`ps -p $process_pid -o etime|awk 'NR==2 {print $1}' |awk -F':' '{print $3}'`

#打印运行时长信息

echo "运行时长为："`ps -p $process_pid -o etime|awk 'NR==2 {print $1}'`

#如果需要修改运行时长，请修改引号内的数字即可,-gt表示大于设置值则会杀进程

if [ $hour -gt '04' ] && [ ! -z $seconds ] ;then

kill -9 $process_pid

重复文件清理，python源码分享

Thu, 19 Mar 2026 15:39:43 +0800

# -*- coding: utf-8 -*-
import sys
import os
import time
import hashlib
# 扫描目录（可修改）
target_path = "./"
# 存储已存在的文件MD5，用于快速查重
exist_md5 = set()
# 统计
total_files = 0
del_files = 0
# 获取当前脚本绝对路径，避免删除自己
script_path = os.path.abspath(sys.argv[0])
def get_file_md5(file_path):
    """
    计算文件MD5（支持大文件，分块读取）
    """
    md5 = hashlib.md5()
    try:
        with open(file_path, 'rb') as f:
            # 每次读取 4MB，避免内存溢出
            while chunk := f.read(4 * 1024 * 1024):
                md5.update(chunk)
        return md5.hexdigest()
    except Exception as e:
        print(f"[无法读取] {file_path} => {str(e)}")
        return None
def scan_files(path):
    """
    递归遍历所有文件
    """
    file_list = []
    for root, dirs, files in os.walk(path):
        for file in files:
            file_path = os.path.abspath(os.path.join(root, file))
            # 跳过自身脚本
            if file_path == script_path:
                continue
            file_list.append(file_path)
    return file_list
def main():
    global total_files, del_files
    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 开始扫描重复文件...")
    
    # 获取所有文件
    all_files = scan_files(target_path)
    
    for file in all_files:
        total_files += 1
        print(f"[{total_files}] 检查: {file}")
        
        # 计算MD5
        md5 = get_file_md5(file)
        if not md5:
            continue
        
        # 判断是否重复
        if md5 in exist_md5:
            try:
                os.remove(file)
                del_files += 1
                print(f"[重复已删除] => {file}")
            except:
                print(f"[删除失败] => {file}")
        else:
            exist_md5.add(md5)
    # 最终统计
    print("\n" + "="*50)
    print(f"扫描完成！")
    print(f"总文件数: {total_files}")
    print(f"唯一文件数: {len(exist_md5)}")
    print(f"删除重复文件: {del_files} 个")
    print("="*50)
if __name__ == "__main__":
    main()

windows端口转发配置

Mon, 16 Mar 2026 09:08:16 +0800

说明：使用管理员方式打开cmd命令窗口，另外需要注意系统防火墙开放本机监听的端口

1、添加端口转发命令

C:\WINDOWS\system32>netsh interface portproxy add v4tov4 listenport=33389 listenaddress=0.0.0.0 connectport=3389 connectaddress=172.15.2.243

说明：将本机可访问的地址172.15.2.243的远程桌面端口3389映射到

本机监听地址为0.0.0.0的33389（因本机自生3389可能被占用所以指定端口为33389）

2、删除端口转发命令

C:\WINDOWS\system32>netsh interface portproxy del v4tov4  listenport=33389 listenaddress=0.0.0.0

3、查看已存在的端口映射命令

C:\WINDOWS\system32>netsh interface portproxy show v4tov4
侦听 ipv4:                 连接到 ipv4:
地址            端口        地址            端口
--------------- ----------  --------------- ----------
0.0.0.0         33389       172.15.2.243    3389

4、可以通过命令 netstat -ano|find "33389" 查看端口是否已在监听

C:\WINDOWS\system32>netstat -ano|find "33389"
  TCP    0.0.0.0:33389          0.0.0.0:0              LISTENING       4888

如果看到上述的监听状态，其它机器即可通过访问本机的33389端口可以访问到被映射的机器3389端口

python开启http/https代理源码（带 IP 白名单 + 域名白名单，兼容 Python 3.5.2）

Fri, 13 Mar 2026 09:26:37 +0800

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
多线程版 HTTP/HTTPS 代理（带 IP 白名单 + 域名白名单，兼容 Python 3.5.2）
监听 0.0.0.0:10225，仅允许白名单内 IP 客户端连接，仅允许访问白名单内域名
"""
import socket
import select
import signal
import sys
import time
import threading
import ipaddress
import re
# ==================== IP 白名单配置（可自定义修改） ====================
# 支持两种格式：
# 1. 单个 IP 地址（如 "127.0.0.1"、"192.168.1.100"）
# 2. C 段/网段（如 "192.168.1.0/24"、"10.0.0.0/8"）
IP_WHITELIST = [
    "127.0.0.1",          # 本机回环地址（必选，用于本机测试）
    #"0.0.0.0/0",          # 允许所有 IP（生产环境请修改为具体网段）
    "20.20.20.0/24",     # 内网 C 段（可根据你的内网网段修改）
    "10.10.0.0/16"
    # "119.6.57.173",      # 可添加指定的外部公网 IP
    # "220.181.0.0/16",    # 可添加指定的公网网段
]
# ==================================================================
# ==================== 域名白名单配置（新增） ====================
# 支持两种格式：
# 1. 精确域名匹配（如 "www.baidu.com"、"api.github.com"）
# 2. 通配符匹配（如 "*.baidu.com" 匹配所有 baidu.com 子域名）
#    - 注意：通配符只匹配一级子域名，如 "*.example.com" 匹配 "www.example.com" 但不匹配 "sub.www.example.com"
#    - 如需匹配多级子域名，请使用多个规则或使用 "*." 开头的规则组合
DOMAIN_WHITELIST = [
    # 百度系
    "*",
    "*.baidu.com",        # 匹配所有 baidu.com 子域名    
    # GitHub
    "github.com",
    "*.github.com",
        # GitHub
    "api.loadteam.com",
    "*.loadteam.com"
    
    # 示例：允许所有域名（测试用，生产环境请删除）
    #"*",                 # 通配符 * 表示允许所有域名（慎用）
]
# ==================================================================
# 代理基础配置项
LISTEN_IP, LISTEN_PORT = '0.0.0.0', 8080  #指定代理端口
BUFFER_SIZE = 16384
TIMEOUT_SECONDS = 60
MAX_HEADER_SIZE = 65536
MAX_THREADS = 100  # 最大线程数限制
THREAD_POOL = []  # 线程池
# 全局变量 + 线程锁
ACTIVE_CONNECTIONS = 0
CONN_LOCK = threading.Lock()
THREAD_LOCK = threading.Lock()
def is_allowed_domain(target_host):
    """
    校验目标域名是否在白名单内（新增函数）
    :param target_host: 目标域名（字符串格式，如 "www.baidu.com"）
    :return: True（允许访问）/ False（拒绝访问）
    """
    if not target_host:
        return False
    
    # 转换为小写进行不区分大小写的匹配
    host = target_host.lower().strip()
    
    for pattern in DOMAIN_WHITELIST:
        pattern = pattern.lower().strip()
        
        # 完全通配符：允许所有域名
        if pattern == "*":
            return True
            
        # 通配符匹配：*.example.com
        if pattern.startswith("*."):
            # 去掉通配符后的域名后缀
            suffix = pattern[1:]  # 如 ".baidu.com"
            # 检查是否以该后缀结尾，或者完全等于去掉通配符后的部分（如 "baidu.com" 匹配 "*.baidu.com"）
            if host.endswith(suffix) or host == suffix[1:]:
                return True
                
        # 精确匹配
        if host == pattern:
            return True
            
    return False
def is_allowed_ip(client_ip):
    """
    校验客户端 IP 是否在白名单内（兼容 Python 3.5.2）
    :param client_ip: 客户端 IP 地址（字符串格式）
    :return: True（允许连接）/ False（拒绝连接）
    """
    if not client_ip:
        return False
    try:
        # 将客户端 IP 转为 ip_address 对象
        client_ip_obj = ipaddress.ip_address(client_ip)
        # 遍历白名单，逐一校验
        for allowed_item in IP_WHITELIST:
            try:
                # Python 3.5.2 ip_network 不支持 strict=False，直接尝试网段匹配
                allowed_network = ipaddress.ip_network(allowed_item)
                if client_ip_obj in allowed_network:
                    return True
            except ValueError:
                # 网段匹配失败，按单个 IP 精确匹配
                try:
                    allowed_ip_obj = ipaddress.ip_address(allowed_item)
                    if client_ip_obj == allowed_ip_obj:
                        return True
                except:
                    # 非法 IP 格式，跳过该白名单项
                    continue
        # 未匹配到白名单
        return False
    except Exception as e:
        log("IP 校验异常 | 客户端 IP: {} | 错误: {}".format(client_ip, e))
        return False
def log(msg):
    """带时间戳、连接数的线程安全日志（使用 format 兼容 Python 3.5）"""
    global ACTIVE_CONNECTIONS
    timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
    with CONN_LOCK:
        print("[{}] [CONNS:{}] {}".format(timestamp, ACTIVE_CONNECTIONS, msg), flush=True)
def set_socket_opt(sock):
    """优化套接字参数"""
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
        if hasattr(socket, 'TCP_KEEPIDLE'):
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 10)
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 5)
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 3)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, BUFFER_SIZE * 4)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, BUFFER_SIZE * 4)
        sock.settimeout(TIMEOUT_SECONDS)
    except Exception as e:
        log("套接字参数优化失败: {}".format(e))
def relay_bidirectional(client_sock, remote_sock, desc=""):
    """鲁棒的双向数据转发（兼容 Python 3.5.2）"""
    global ACTIVE_CONNECTIONS
    bytes_sent = 0
    bytes_recv = 0
    try:
        set_socket_opt(client_sock)
        set_socket_opt(remote_sock)
        read_list = [client_sock, remote_sock]
        log("{}: 开始双向转发 (缓冲区:{} 超时:{}s)".format(desc, BUFFER_SIZE, TIMEOUT_SECONDS))
        while read_list:
            rlist, _, xlist = select.select(read_list, [], read_list, TIMEOUT_SECONDS)
            if xlist:
                log("{}: 套接字异常 {}".format(desc, xlist))
                break
            if not rlist:
                if bytes_sent + bytes_recv > 0:
                    log("{}: 超时但已转发数据，继续等待 (已发:{} 已收:{})".format(desc, bytes_sent, bytes_recv))
                    continue
                log("{}: 无数据转发超时退出".format(desc))
                break
            for sock in rlist:
                try:
                    data = sock.recv(BUFFER_SIZE)
                    if not data:
                        try:
                            test_data = sock.recv(1, socket.MSG_PEEK)
                            if not test_data:
                                log("{}: 确认对方关闭连接 (已转发: {} 字节)".format(desc, bytes_sent+bytes_recv))
                                return
                        except:
                            pass
                        continue
                    if sock is client_sock:
                        target = remote_sock
                        bytes_sent += len(data)
                        log("{}: 客户端→目标 [{} 字节] (累计:{})".format(desc, len(data), bytes_sent))
                    else:
                        target = client_sock
                        bytes_recv += len(data)
                        log("{}: 目标→客户端 [{} 字节] (累计:{})".format(desc, len(data), bytes_recv))
                    target.sendall(data)
                except BlockingIOError:
                    continue
                except socket.timeout:
                    log("{}: 单方向数据读取超时，继续等待".format(desc))
                    continue
                except Exception as e:
                    log("{}: 转发错误 {}: {}".format(desc, type(e).__name__, e))
                    return
    except Exception as e:
        log("{}: 转发异常 {}: {}".format(desc, type(e).__name__, e))
    finally:
        with CONN_LOCK:
            ACTIVE_CONNECTIONS -= 1
        # 优雅关闭套接字
        for s in [client_sock, remote_sock]:
            try:
                s.shutdown(socket.SHUT_RDWR)
            except:
                pass
            try:
                s.close()
            except:
                pass
        log("{}: 转发结束 (总计转发: {} 字节)".format(desc, bytes_sent+bytes_recv))
def parse_target(request_line):
    """解析目标地址（兼容 Python 3.5.2）"""
    try:
        if request_line.startswith('CONNECT'):
            target = request_line.split()[1]
            if ':' in target:
                host, port = target.split(':', 1)
                port = int(port)
            else:
                host = target
                port = 443
            return host, port
        else:
            from urllib.parse import urlparse
            url = request_line.split()[1]
            parsed = urlparse(url)
            host = parsed.hostname
            port = parsed.port or (80 if parsed.scheme == 'http' else 443)
            return host, port
    except Exception as e:
        log("解析目标失败: {} | 请求行: {}".format(e, request_line[:100]))
        return None, None
def handle_connect(client_sock, request_line, client_addr):
    """处理 HTTPS CONNECT 隧道（增加域名白名单校验）"""
    host, port = parse_target(request_line)
    if not host or not port:
        client_sock.sendall(b'HTTP/1.1 400 Bad Request\r\n\r\nInvalid target')
        return
    # ==================== 域名白名单校验（新增） ====================
    if not is_allowed_domain(host):
        log("❌ 拒绝访问非白名单域名 | 客户端: {} | 目标: {}:{}".format(client_addr, host, port))
        error_response = (
            b"HTTP/1.1 403 Forbidden\r\n"
            b"Content-Type: text/plain; charset=utf-8\r\n"
            b"Connection: close\r\n"
            b"\r\n"
            b"403 Forbidden: Domain not in whitelist\r\n"
        )
        try:
            client_sock.sendall(error_response)
        except:
            pass
        return
    # ==================================================================
    try:
        remote_sock = None
        for retry in range(2):
            try:
                remote_sock = socket.create_connection((host, port), timeout=10)
                break
            except:
                time.sleep(0.1)
        if not remote_sock:
            raise Exception("连接目标失败（2次重试）")
        response = (
            b"HTTP/1.1 200 Connection Established\r\n"
            b"Date: " + time.strftime("%a, %d %b %Y %H:%M:%S GMT").encode() + b"\r\n"
            b"Server: SimpleProxy/1.0\r\n"
            b"Connection: keep-alive\r\n"
            b"Proxy-Connection: keep-alive\r\n"
            b"\r\n"
        )
        client_sock.sendall(response)
        relay_bidirectional(
            client_sock, remote_sock,
            "{} <-> {}:{} (HTTPS)".format(client_addr, host, port)
        )
    except Exception as e:
        error_msg = "HTTP/1.1 502 Bad Gateway\r\nContent-Type: text/plain\r\n\r\n{}".format(str(e))
        try:
            client_sock.sendall(error_msg.encode('utf-8', errors='replace'))
        except:
            pass
        log("{}: CONNECT 失败 {}:{} | {}".format(client_addr, host, port, e))
def handle_http(client_sock, request_data, client_addr):
    """处理 HTTP 请求（增加域名白名单校验）"""
    try:
        header_end = request_data.find(b'\r\n\r\n')
        if header_end == -1:
            client_sock.sendall(b'HTTP/1.1 400 Bad Request\r\n\r\nMissing header end')
            return
        request_line = request_data[:header_end].split(b'\r\n')[0].decode('utf-8', errors='ignore')
        host, port = parse_target(request_line)
        if not host or not port:
            client_sock.sendall(b'HTTP/1.1 400 Bad Request\r\n\r\nInvalid URL')
            return
        # ==================== 域名白名单校验（新增） ====================
        if not is_allowed_domain(host):
            log("❌ 拒绝访问非白名单域名 | 客户端: {} | 目标: {}:{}".format(client_addr, host, port))
            error_response = (
                b"HTTP/1.1 403 Forbidden\r\n"
                b"Content-Type: text/plain; charset=utf-8\r\n"
                b"Connection: close\r\n"
                b"\r\n"
                b"403 Forbidden: Domain not in whitelist\r\n"
            )
            try:
                client_sock.sendall(error_response)
            except:
                pass
            return
        # ==================================================================
        header_lines = request_data[:header_end].split(b'\r\n')
        new_headers = []
        has_host = False
        for line in header_lines:
            lower_line = line.lower()
            if any(p in lower_line for p in [b'proxy-', b'connection: keep-alive']):
                continue
            if lower_line.startswith(b'host:'):
                has_host = True
            new_headers.append(line)
        if not has_host:
            new_headers.insert(1, "Host: {}".format(host).encode())
        new_headers.append(b"Connection: keep-alive")
        new_headers.append(b"Accept-Encoding: gzip, deflate")
        new_header = b'\r\n'.join(new_headers)
        body = request_data[header_end+4:]
        forward_data = new_header + b'\r\n\r\n' + body
        remote_sock = socket.create_connection((host, port), timeout=10)
        set_socket_opt(remote_sock)
        remote_sock.sendall(forward_data)
        relay_bidirectional(
            client_sock, remote_sock,
            "{} <-> {}:{} (HTTP)".format(client_addr, host, port)
        )
    except Exception as e:
        error_msg = "HTTP/1.1 500 Internal Server Error\r\n\r\n{}".format(str(e))
        try:
            client_sock.sendall(error_msg.encode())
        except:
            pass
        log("{}: HTTP 处理失败 | {}".format(client_addr, e))
def handle_client(client_sock, client_addr):
    """处理单个客户端连接（工作线程执行函数，兼容 Python 3.5.2）"""
    global ACTIVE_CONNECTIONS
    with CONN_LOCK:
        ACTIVE_CONNECTIONS += 1
    try:
        client_sock.settimeout(TIMEOUT_SECONDS)
        set_socket_opt(client_sock)
        request_data = b''
        while len(request_data) < MAX_HEADER_SIZE:
            chunk = client_sock.recv(BUFFER_SIZE)
            if not chunk:
                return
            request_data += chunk
            if b'\r\n\r\n' in request_data:
                break
        if not request_data:
            log("{}: 空请求，关闭连接".format(client_addr))
            return
        first_line = request_data.split(b'\r\n')[0].decode('utf-8', errors='ignore').strip()
        log("{}: 收到请求 | {}".format(client_addr, first_line[:100]))
        if first_line.upper().startswith('CONNECT'):
            handle_connect(client_sock, first_line, client_addr)
        else:
            handle_http(client_sock, request_data, client_addr)
    except socket.timeout:
        log("{}: 客户端超时（{}s）".format(client_addr, TIMEOUT_SECONDS))
    except Exception as e:
        log("{}: 处理异常 {}: {}".format(client_addr, type(e).__name__, e))
    finally:
        try:
            client_sock.close()
        except:
            pass
        # 清理线程池中的无效线程（兼容 Python 3.5 列表操作）
        with THREAD_LOCK:
            # 先创建新列表，再赋值给 THREAD_POOL，避免迭代时修改列表
            valid_threads = []
            for thread in THREAD_POOL:
                if thread.is_alive():
                    valid_threads.append(thread)
            THREAD_POOL[:] = valid_threads
def main():
    """主服务入口（IP 过滤 + 线程分配，兼容 Python 3.5.2）"""
    def signal_handler(_sig, _frame):
        log("收到退出信号，正在关闭所有线程...")
        with THREAD_LOCK:
            for thread in THREAD_POOL:
                thread.join(timeout=2)
        log("所有线程已关闭，代理退出")
        sys.exit(0)
    signal.signal(signal.SIGINT, signal_handler)
    signal.signal(signal.SIGTERM, signal_handler)
    try:
        server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
        server_sock.bind((LISTEN_IP, LISTEN_PORT))
        server_sock.listen(512)
        server_sock.settimeout(1.0)
        log("多线程代理服务器启动成功 ✅ | {}:{}".format(LISTEN_IP, LISTEN_PORT))
        log("IP 白名单: {}".format(IP_WHITELIST))
        log("域名白名单: {}".format(DOMAIN_WHITELIST))  # 新增日志输出
        log("最大并发线程数: {}".format(MAX_THREADS))
        log("测试命令: curl -x http://127.0.0.1:{} https://www.baidu.com".format(LISTEN_PORT))
        while True:
            try:
                # 接受新客户端连接
                client_sock, client_addr = server_sock.accept()
                client_ip = client_addr[0]  # 提取客户端 IP 地址（如 192.168.1.100）
                # ==================== IP 白名单过滤（核心拦截点） ====================
                if not is_allowed_ip(client_ip):
                    # 非白名单 IP，直接关闭连接并记录日志
                    log("❌ 拒绝非白名单 IP 连接 | 客户端 IP: {} | 地址: {}".format(client_ip, client_addr))
                    client_sock.close()
                    continue
                # ==================================================================
                # 控制线程数，避免资源耗尽
                with THREAD_LOCK:
                    # 清理已结束的线程
                    valid_threads = []
                    for thread in THREAD_POOL:
                        if thread.is_alive():
                            valid_threads.append(thread)
                    THREAD_POOL[:] = valid_threads
                    # 若线程数达到上限，等待一段时间
                    if len(THREAD_POOL) >= MAX_THREADS:
                        log("线程数达到上限 {}，等待空闲线程...".format(MAX_THREADS))
                        time.sleep(1)
                        continue
                # 创建新线程处理客户端连接
                client_thread = threading.Thread(
                    target=handle_client,
                    args=(client_sock, client_addr),
                    daemon=True  # 守护线程，主程序退出时自动销毁
                )
                # 将线程加入线程池
                with THREAD_LOCK:
                    THREAD_POOL.append(client_thread)
                # 启动线程
                client_thread.start()
                log("✅ {}: 已分配工作线程（当前线程数: {}）".format(client_addr, len(THREAD_POOL)))
            except socket.timeout:
                continue
            except Exception as e:
                log("主循环异常: {}".format(e))
    except PermissionError:
        log("权限不足 ❌ | 无法绑定 {}（需 sudo 或端口>1024）".format(LISTEN_PORT))
        sys.exit(1)
    except Exception as e:
        log("启动失败 ❌ | {}".format(e))
        sys.exit(1)
    finally:
        try:
            server_sock.close()
        except:
            pass
if __name__ == '__main__':
    main()

网站自动续签SSL证书

Thu, 12 Mar 2026 15:57:28 +0800

1.安装运行环境

主流Linux软件源都收录了certbot，Ubuntu/Debian操作系统，用以下命令安装：

apt install certbot python3-certbot python3-certbot-nginx

安装 python3-certbot-nginx 可以帮我们自动配置到nginx。

certbot是从 Let's Encrypt 签名的证书，以下是常用命令：

2.申请证书，并自动配置到nginx

# 如果有多个域名，可以指定多个 -d 参数

certbot --nginx -d www.test.com -d aaa.test.com -d bbb.test.com

# 多个域名也可以用英文逗号隔开

certbot --nginx -d www.test.com,aaa.test.com,bbb.test.com

--nginx 申请证书后自动配置到nginx

-d 申请证书的域名，支持 *.test.com 匹配任意域名

证书存储在 /etc/letsencrypt/live 目录下

查看证书

certbot certificates

返回所有申请的证书

已有证书增加域名

certbot --nginx -d www.test.com,ccc.test.com

如果www.test.com证书已存在。certbot会在该证书中加上ccc.test.com域名

删除证书

certbot delete -d 域名列表

3.自动续签

查看certbot服务运行状态

systemctl status certbot

注意保证服务在启用中才会自动续签。

注意：

申请通配符域名，如：*.test.com 。带 * 的域名需要做DNS解析

官方网站:https://console.letsencrypt.top/#/index

ssh方式实现文件增量同步备份到本地python源码（从远程机器备份文件到本地，本地支持windows和linux）

Fri, 06 Mar 2026 09:55:55 +0800

#coding=utf-8
#################################################
#脚本功能：ssh方式实现自动备份，需要在sync_config.ini配置文件中配置参数
#[Paths]
# local_dir = d:/BaiduSyncdisk/data   #本地备份目录，注意路径格式只能使用/
# remote_dir = /data/data             #远程目录
#
# [Connection]
# remote_host = 127.0.0.1               #远程连接IP
# remote_user =data
# ssh_port = 33322
# ssh_key = ~/.ssh/id_ed25519
#
# [Scan]
# days = 30                             #文件扫描天数，只扫描近30有修改过的文件，避免文件数量过多之后出现太长耗时，第一次运行手动修改此时间
# skip_today = True                     #是否跳过当天的文件，默认跳过，可以避免出现文件还在拷贝或者写入过程就执行文件拷贝了
#
#
#脚本编写人与日期： zsm 20250630
##################################################
import os
import subprocess
import configparser
import logging
from datetime import datetime, timedelta
import sqlite3
from contextlib import contextmanager
import time
# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='sync.log'
)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
# 检查日志文件大小，超过1GB则清空
LOG_MAX_SIZE = 1 * 1024 * 1024 * 1024  # 1GB
if os.path.exists('sync.log'):
    log_size = os.path.getsize('sync.log')
    if log_size > LOG_MAX_SIZE:
        logging.info(f"日志文件大小超过1GB，正在清空...")
        with open('sync.log', 'w') as f:
            f.write("日志文件因大小超过1GB被清空\n")
class RemoteFileSync:
    def __init__(self):
        self.start_time = time.time()  # 记录开始时间
        self.config = self._load_config()
        self.local_dir = self.config.get('Paths', 'local_dir')
        self.remote_dir = self.config.get('Paths', 'remote_dir')
        self.remote_host = self.config.get('Connection', 'remote_host')
        self.remote_user = self.config.get('Connection', 'remote_user')
        self.ssh_port = self.config.getint('Connection', 'ssh_port', fallback=22)
        self.ssh_key = self.config.get('Connection', 'ssh_key', fallback=None)
        self.scan_days = self.config.getint('Scan', 'days', fallback=30)
        self.skip_today = self.config.getboolean('Scan', 'skip_today', fallback=True)  # 新增配置项
        # 数据库路径
        self.db_path = os.path.join(self.local_dir, 'file_info.db')
        # 确保本地目录存在
        os.makedirs(self.local_dir, exist_ok=True)
        # 初始化数据库
        self._init_db()
    def _load_config(self):
        """加载配置文件"""
        config = configparser.ConfigParser()
        config_path = 'sync_config.ini'
        if not os.path.exists(config_path):
            # 创建默认配置文件
            config['Paths'] = {
                'local_dir': 'd:/BaiduSyncdisk/data',
                'remote_dir': '/data/data'
            }
            config['Connection'] = {
                'remote_host': 'your_server_ip',
                'remote_user': 'your_username',
                'ssh_port': 22,
                'ssh_key': '/path/to/your/private_key'
            }
            config['Scan'] = {
                'days': 30,  # 默认扫描30天内的文件
                'skip_today': 'True'  # 新增：是否跳过当日修改的文件
            }
            with open(config_path, 'w') as f:
                config.write(f)
            logging.info(f"已创建配置文件: {config_path}，请编辑配置")
            exit(1)
        config.read(config_path)
        return config
    def _init_db(self):
        """初始化SQLite数据库"""
        with self._get_db_connection() as conn:
            cursor = conn.cursor()
            # 创建文件信息表（确保表名和字段名不包含特殊字符）
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS file_info (
                    path TEXT PRIMARY KEY,
                    mtime INTEGER NOT NULL,
                    last_checked INTEGER NOT NULL,
                    is_today INTEGER DEFAULT 0
                )
            ''')
            # 创建索引以加速查询（确保索引名不包含特殊字符）
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_mtime ON file_info (mtime)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_last_checked ON file_info (last_checked)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_is_today ON file_info (is_today)')
            conn.commit()
    @contextmanager
    def _get_db_connection(self):
        """获取数据库连接，使用上下文管理器确保资源正确关闭"""
        conn = sqlite3.connect(self.db_path)
        # 启用外键约束（如果需要）
        conn.execute("PRAGMA foreign_keys = ON")
        # 设置文本编码为UTF-8
        conn.text_factory = str
        try:
            yield conn
        finally:
            conn.close()
    def _run_ssh_command(self, command):
        """执行SSH命令"""
        base_cmd = ['ssh']
        # 添加SSH端口
        base_cmd.extend(['-p', str(self.ssh_port)])
        # 添加SSH密钥（如果有）
        if self.ssh_key:
            base_cmd.extend(['-i', self.ssh_key])
        # 添加远程用户和主机
        base_cmd.append(f"{self.remote_user}@{self.remote_host}")
        # 添加要执行的命令
        base_cmd.append(command)
        try:
            # 执行命令并捕获二进制输出
            result = subprocess.run(
                base_cmd,
                capture_output=True,
                check=True
            )
            # 手动使用UTF-8解码输出
            stdout = result.stdout.decode('utf-8', errors='replace')
            return stdout.strip()
        except subprocess.CalledProcessError as e:
            # 手动解码错误输出
            stderr = e.stderr.decode('utf-8', errors='replace')
            logging.error(f"SSH命令执行失败: {stderr}")
            raise
        except UnicodeDecodeError as e:
            logging.error(f"解码SSH输出失败: {e}")
            return ""
    def _run_scp_command(self, source, destination):
        """执行SCP命令"""
        base_cmd = ['scp']
        # 添加SSH端口
        base_cmd.extend(['-P', str(self.ssh_port)])
        # 添加SSH密钥（如果有）
        if self.ssh_key:
            base_cmd.extend(['-i', self.ssh_key])
        # 添加源和目标
        base_cmd.extend([source.replace("\"", "").replace("\'", ""), destination])
        try:
            # 执行命令并捕获二进制输出
            result = subprocess.run(
                base_cmd,
                capture_output=True,
                check=True
            )
            # 手动使用UTF-8解码输出
            stdout = result.stdout.decode('utf-8', errors='replace')
            logging.info(f"SCP命令输出: {stdout}")
            logging.info(f"文件传输成功: {source} -> {destination}")
            return True
        except subprocess.CalledProcessError as e:
            # 手动解码错误输出
            stderr = e.stderr.decode('utf-8', errors='replace')
            logging.error(f"SCP命令执行失败: {stderr}")
            return False
    def get_remote_file_info(self):
        """获取远程服务器文件信息并保存到数据库"""
        logging.info(f"正在获取远程服务器文件信息...")
        # 计算时间范围
        today_start = int(datetime.combine(datetime.today(), datetime.min.time()).timestamp())
        today_end = int(datetime.combine(datetime.today(), datetime.max.time()).timestamp())
        cutoff_time = int((datetime.now() - timedelta(days=self.scan_days)).timestamp())
        # 构建获取文件信息的命令
        find_filters = []
        # 添加时间范围过滤
        find_filters.append(f'-newermt "$(date -d @{cutoff_time} +\'%Y-%m-%d %H:%M:%S\')"')
        # 添加跳过当日文件的过滤
        if self.skip_today:
            find_filters.append(f'-not -newermt "$(date -d @{today_start} +\'%Y-%m-%d %H:%M:%S\')"')
            find_filters.append(f'-not -newerct "$(date -d @{today_end} +\'%Y-%m-%d %H:%M:%S\')"')
        find_filters_str = ' '.join(find_filters)
        find_cmd = (f'find "{self.remote_dir}" -type f {find_filters_str} '
                    f'-exec sh -c \'for file; do printf "%s #|# %s\n" "$file" "$(stat -c %Y "$file")"; done\' sh {{}} +')
        try:
            # 执行命令获取文件信息
            file_info_text = self._run_ssh_command(find_cmd)
            # 解析文件信息并更新数据库
            self._update_db_with_file_info(file_info_text, today_start, today_end)
            # 从数据库获取所有文件信息，根据skip_today决定是否包含当日文件
            with self._get_db_connection() as conn:
                cursor = conn.cursor()
                if self.skip_today:
                    cursor.execute("SELECT path, mtime FROM file_info WHERE is_today = 0")
                else:
                    cursor.execute("SELECT path, mtime FROM file_info")
                return {row[0]: row[1] for row in cursor.fetchall()}
        except Exception as e:
            logging.error(f"获取远程文件信息失败: {e}")
            return {}
    def _update_db_with_file_info(self, file_info_text, today_start, today_end):
        """将文件信息更新到数据库"""
        current_time = int(datetime.now().timestamp())
        with self._get_db_connection() as conn:
            cursor = conn.cursor()
            # 开始事务以提高性能
            conn.execute("BEGIN TRANSACTION")
            for line in file_info_text.strip().split('\n'):
                if not line:
                    continue
                try:
                    parts = line.rsplit(' #|# ', 1)
                    if len(parts) != 2:
                        continue
                    file_path, mtime = parts
                    mtime = int(mtime)
                    # 转义文件路径中的特殊字符，特别是#号
                    file_path = file_path.replace('#', '\\#')
                    # 判断是否为当日修改的文件
                    is_today = 1 if today_start <= mtime <= today_end else 0
                    # 插入或更新文件信息（使用参数化查询避免SQL注入）
                    cursor.execute(
                        """
                        INSERT OR REPLACE INTO file_info (path, mtime, last_checked, is_today)
                        VALUES (?, ?, ?, ?)
                        """,
                        (file_path, mtime, current_time, is_today)
                    )
                except Exception as e:
                    logging.warning(f"处理文件信息失败: {line}, 错误: {e}")
            # 提交事务
            conn.commit()
            # 清理超过扫描期限且未更新的文件（使用参数化查询）
            cutoff_time = int((datetime.now() - timedelta(days=self.scan_days)).timestamp())
            cursor.execute(
                """
                DELETE FROM file_info 
                WHERE mtime < ? AND last_checked < ?
                """,
                (cutoff_time, current_time)
            )
            logging.info(f"已更新数据库中的文件信息，跳过当日修改文件: {self.skip_today}")
    def get_local_file_info(self):
        """获取本地文件信息"""
        logging.info("正在获取本地文件信息...")
        file_info = {}
        for root, _, files in os.walk(self.local_dir):
            for file in files:
                # 跳过数据库文件本身
                if file == os.path.basename(self.db_path):
                    continue
                file_path = os.path.join(root, file)
                # 计算相对路径
                rel_path = os.path.relpath(file_path, self.local_dir)
                # 构建对应的远程路径（转义#号）
                remote_file_path = os.path.join(
                    self.remote_dir,
                    rel_path.replace('\\', '/')  # 确保远程路径使用正斜杠
                ).replace('\\', '/').replace('#', '\\#')
                # 获取文件修改时间
                try:
                    mtime = int(os.path.getmtime(file_path))
                    file_info[remote_file_path] = mtime
                except Exception as e:
                    logging.warning(f"获取本地文件信息失败: {file_path}, 错误: {e}")
        return file_info
    def sync_files(self):
        """同步文件（仅从远程到本地）"""
        logging.info("开始同步文件...")
        # 获取远程和本地文件信息
        remote_files = self.get_remote_file_info()
        local_files = self.get_local_file_info()
        # 用于跟踪需要更新的文件信息
        updated_files = {}
        # 同步远程有但本地没有的文件
        for remote_path in list(remote_files.keys()):
            if remote_path not in local_files:
                logging.info(f"检测到新文件: {remote_path}")
                success = self._sync_from_remote(remote_path)
                if success:
                    # 更新本地文件信息
                    local_mtime = int(os.path.getmtime(
                        os.path.join(self.local_dir, os.path.relpath(remote_path, self.remote_dir))
                    ))
                    local_files[remote_path] = local_mtime
                    updated_files[remote_path] = local_mtime
                else:
                    remote_files.pop(remote_path, None)
        # 比较修改时间，同步更新的文件
        for remote_path in set(remote_files.keys()) & set(local_files.keys()):
            remote_mtime = remote_files[remote_path]
            local_mtime = local_files[remote_path]
            # 增加调试日志
            logging.debug(f"比较文件: {remote_path}")
            logging.debug(f"  远程时间戳: {remote_mtime} ({datetime.fromtimestamp(remote_mtime)})")
            logging.debug(f"  本地时间戳: {local_mtime} ({datetime.fromtimestamp(local_mtime)})")
            # 使用容差值比较时间戳，解决精度差异问题
            time_diff = remote_mtime - local_mtime
            TIME_TOLERANCE = 2  # 允许2秒的误差，可根据需要调整
            if time_diff > TIME_TOLERANCE:
                logging.info(f"远程文件更新: {remote_path} (差异: {time_diff}秒)")
                success = self._sync_from_remote(remote_path)
                if success:
                    # 更新本地文件信息
                    local_mtime = int(os.path.getmtime(
                        os.path.join(self.local_dir, os.path.relpath(remote_path, self.remote_dir))
                    ))
                    local_files[remote_path] = local_mtime
                    updated_files[remote_path] = local_mtime
                    logging.info(f"更新本地时间戳: {local_mtime}")
                else:
                    remote_files.pop(remote_path, None)
            else:
                logging.debug(f"文件时间戳一致: {remote_path} (差异: {time_diff}秒)")
        # 验证同步结果
        self._verify_sync_results(local_files, remote_files)
        # 计算并记录运行时长
        run_time = time.time() - self.start_time
        hours, remainder = divmod(run_time, 3600)
        minutes, seconds = divmod(remainder, 60)
        logging.info(f"脚本运行完成，总耗时: {int(hours)}小时{int(minutes)}分钟{seconds:.2f}秒")
    def _sync_from_remote(self, remote_path):
        """从远程同步文件到本地"""
        # 构建本地路径（反转义#号）
        local_remote_path = remote_path.replace('\\#', '#')
        rel_path = os.path.relpath(local_remote_path, self.remote_dir)
        local_path = os.path.join(self.local_dir, rel_path)
        # 确保本地目录存在
        local_dir = os.path.dirname(local_path)
        os.makedirs(local_dir, exist_ok=True)
        logging.info(f"从远程同步: {local_remote_path} -> {local_path}")
        # 使用更健壮的路径转义方法
        escaped_remote_path = self._escape_path(local_remote_path)
        # 使用双引号包裹整个路径，内部使用单引号保护
        source = f"{self.remote_user}@{self.remote_host}:\"'{escaped_remote_path}'\""
        destination = local_path
        logging.info(f"执行SCP命令: {' '.join(['scp', '-P', str(self.ssh_port), source, destination])}")
        # 执行SCP命令并获取结果
        success = self._run_scp_command(source, destination)
        # 如果失败，记录详细的调试信息
        if not success:
            logging.error(f"同步失败: {local_remote_path}")
            logging.error(f"转义后的远程路径: {escaped_remote_path}")
            logging.error(f"SCP源路径: {source}")
            return False
        # 验证下载后的文件时间戳
        try:
            downloaded_mtime = int(os.path.getmtime(local_path))
            logging.info(f"下载后文件时间戳: {downloaded_mtime} ({datetime.fromtimestamp(downloaded_mtime)})")
        except Exception as e:
            logging.error(f"获取下载后文件时间戳失败: {e}")
            return False
        return True
    def _escape_path(self, path):
        """更健壮的路径转义方法，处理所有特殊字符"""
        # 转义单引号 - 这是最关键的特殊字符
        escaped = path.replace("'", "'\\''")
        # 转义#号
        escaped = escaped.replace('#', '\\#')
        # 对于包含空格的路径，额外添加保护
        if ' ' in escaped:
            # 在路径两边添加单引号，并用双引号包裹整个路径
            escaped = f"'{escaped}'"
        return escaped
    def _verify_sync_results(self, local_files, remote_files):
        """验证同步结果"""
        logging.info("验证同步结果...")
        with self._get_db_connection() as conn:
            cursor = conn.cursor()
            cursor.execute("SELECT path, mtime, is_today FROM file_info")
            db_files = {row[0]: (row[1], row[2]) for row in cursor.fetchall()}
        for remote_path in set(local_files.keys()) | set(remote_files.keys()):
            local_time = local_files.get(remote_path, None)
            remote_time = remote_files.get(remote_path, None)
            if remote_path in db_files:
                db_time, is_today = db_files[remote_path]
            else:
                db_time, is_today = None, None
            # 反转义路径以便显示
            display_path = remote_path.replace('\\#', '#')
            if local_time is not None and remote_time is not None:
                time_diff = local_time - remote_time
                if abs(time_diff) > 100:  # 允许2秒的误差
                    logging.warning(f"时间戳冲突，本地文件日期更新: {display_path}")
                    logging.warning(f"  本地: {local_time} ({datetime.fromtimestamp(local_time)})")
                    logging.warning(f"  远程: {remote_time} ({datetime.fromtimestamp(remote_time)})")
                    logging.warning(f"  差异: {time_diff}秒")
            elif local_time is None and remote_time is not None:
                if is_today == 1:
                    if self.skip_today:
                        logging.info(f"跳过当日修改文件: {display_path}")
                    else:
                        logging.warning(f"本地缺少当日修改文件: {display_path}")
                else:
                    logging.warning(f"本地缺少文件: {display_path}")
            elif local_time is not None and remote_time is None:
                if db_time is not None:
                    if is_today == 1:
                        if self.skip_today:
                            logging.info(f"远程文件为当日修改，未扫描: {display_path}")
                        else:
                            logging.warning(f"远程当日修改文件未同步: {display_path}")
                    else:
                        logging.info(f"文件已超过扫描期限: {display_path}")
if __name__ == "__main__":
    start_time = time.time()
    try:
        sync_tool = RemoteFileSync()
        sync_tool.sync_files()
    except Exception as e:
        logging.error(f"同步过程中发生错误: {e}")
        import traceback
        logging.error(traceback.format_exc())
    finally:
        # 无论是否出错，都记录总运行时间
        total_run_time = time.time() - start_time
        hours, remainder = divmod(total_run_time, 3600)
        minutes, seconds = divmod(remainder, 60)
        logging.info(f"脚本总运行时间: {int(hours)}小时{int(minutes)}分钟{seconds:.2f}秒")

2台机器配置ssh证书免密登陆（互信）

Thu, 05 Mar 2026 17:22:08 +0800

一、免密登录需求

平时在工作中，可能需要从一台服务器上将文件分发到其他多台服务器，如果每次都需要输入密码就

显得太麻烦了，这种情况就可以通过免密登录来实现。如ansible,kubernetes等服务在部署时都有

这样的需求。

二、配置SSH免密登录概述

1、ssh免密登录原理

SSH（Secure Shell）是一种加密的网络协议，用于在不安全的网络上安全地进行远程登录和其他

安全网络服务。免密认证的核心思想是利用公钥和私钥进行认证，而不是每次都输入密码。只要在

客户端和服务器之间正确配置了公钥和私钥，用户可以直接登录而无需输入密码。

2、相关的文件

在每台服务的~/.ssh目录下会有以下四个文件： authorized_keys: 存放远程免密登录的公钥,主要

通过这个文件记录多台机器的公钥。 id_rsa: 私钥文件 id_rsa.pub: 公钥文件 known_hosts: 已知

的主机公钥清单

如果将我们生成的公钥放到相应主机的对应用户的authorized_keys文件下，就可以实现免密登录。

在生成密钥时，默认会在~/.ssh目录下生成密钥（id_rsa和id_rsa.pub），如果.ssh目录不存在

,则会自动创建。

三、实现免密操作

1、生成密钥

ssh-keygen -t rsa （三次回车，不输入其他信息）

-t 选项指定要使用的加密算法，“rsa”表示使用RSA算法

默认会在~/.ssh目录下生成密钥（id_rsa和id_rsa.pub），如果.ssh目录不存在,则会自动创建。

[root@linux ~]# ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):   # 密钥放置的路径
Enter passphrase (empty for no passphrase): # 配置密码保护密钥，回车为不配置
Enter same passphrase again:  # 确认第二步的密码
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:A/kj+6dddddoKheAo6Kx932341VYLN2J/wmBHn0XFw root@linux
The key's randomart image is:
+---[RSA 2048]----+
|            .o*+E|
|       .   ..=.=o|
|      o.  . o.* =|
|.   . oo . . o +.|
|oo   o..S     . o|
|= o . o+ o     o |
|oo.o.oo          |
|=  =o. .         |
|o++......        |
+----[SHA256]-----+

2、复制本机公钥到其它机器(可以使用命令方式传输也可以复制拷贝密钥内容到另外一台机器)

#如下是命令方式拷贝公钥id_rsa.pub到172.168.22.35
[root@linux ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@172.168.22.35
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
The authenticity of host '172.168.22.35 (172.168.22.35)' can't be established.
ECDSA key fingerprint is SHA256:BpTKrxztroqHQiyBmInb7Y9R/rKyNgtyqvBp3TZiToU.
ECDSA key fingerprint is MD5:08:6c:1d:18:4c:a7:6f:7c:09:86:47:ea:07:a2:55:e0.
Are you sure you want to continue connecting (yes/no)? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
root@172.168.22.35's password:   # 输入服务器密码
 
Number of key(s) added: 1
 
Now try logging into the machine, with:   "ssh 'root@172.168.22.35'"
and check to make sure that only the key(s) you wanted were added.
#另外一种方式就是使用命令cat ~/.ssh/id_rsa.pub本机密钥内容，然后复制内容行（注意这个文件只有一行内容，且内容较长复制后要检查是否只有一行）
#拷贝后粘贴到172.168.22.35的机器~/.ssh/authorized_keys 文件末尾行（没有文件就新增这个文件，但权限需要chmod 600 authorized_keys）

注意：比如上边的操作是将本机root用户下的公钥id_rsa.pub放置到机器172.168.22.35的root用户下，

那么则表示172.168.22.35机器的root用户可以使用root直接访问本机,如不希望对方免密使用root用户

访问本机，则本机生成密钥请使用其它用户例如user,则设置后在172.168.22.35的机器免密访问就需要

使用ssh带user用户访问才能成功。

如果以上设置后还不正常，需要检查 SSH 服务配置：

• 确保 PubkeyAuthentication 选项被设置为 yes 。

• 确保 AuthorizedKeysFile 选项被设置为 .ssh/authorized_keys 。

• 修改配置后，重启 SSH 服务：sudo systemctl restart sshd

•确保 /etc/ssh/sshd_config 文件中的 PasswordAuthentication 选项被设置为 no 。

•确保确保.ssh文件夹权限为700，AuthorizedKeysFile权限为600

Linux 系统添加 / 扩容 swap 交换分区（文件方式）

Thu, 05 Mar 2026 17:12:58 +0800

在 Linux 系统中，当物理内存不足时，swap 交换空间可以作为临时内存使用。

以下是通过创建 swapfile 的方式配置 20G 交换空间的完整步骤：

1. 前置检查与准备

首先关闭当前所有交换分区，查看当前内存和交换空间使用情况：

# 关闭所有已启用的swap分区
swapoff -a
# 以MB为单位查看内存和swap使用情况（确认swap已关闭）
free -m

2. 创建并配置 20G 交换文件

依次执行以下命令创建 swap 文件、设置权限、格式化并启用：

# 创建20G大小的swap文件（fallocate是快速创建预分配文件的工具）
fallocate -l 20G /swapfile
# 设置swap文件权限为仅root可读写（安全要求，必须配置）
chmod 600 /swapfile 
# 将文件格式化为swap格式
mkswap /swapfile 
# 启用该swap文件
swapon /swapfile

3. 设置开机自动挂载 swap 文件

为了避免重启后 swap 文件失效，需要将其写入/etc/fstab配置文件：

# 将swap文件挂载信息追加到fstab中
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
# 验证fstab配置是否添加成功
cat /etc/fstab
# 以GB为单位查看内存和swap最终配置结果
free -G
# 以MB为单位查看更精确的内存和swap使用情况
free -m

补充说明:

fallocate -l 20G /swapfile：如果系统不支持fallocate（如部分老旧系统），

可替换为dd if=/dev/zero of=/swapfile bs=1G count=20（速度稍慢，但兼容性更好）。

chmod 600 /swapfile：必须设置此权限，否则系统可能拒绝使用该 swap 文件，存在安全风险。

/etc/fstab中0 0的含义：第一个 0 表示不备份，第二个 0 表示开机不检查该文件系统。

ubuntu安装samba(共享文件夹)

Wed, 04 Mar 2026 16:50:26 +0800

1.首先安装samba服务：

sudo apt-get install samba
sudo apt-get install smbclient
sudo apt-get install cifs-utils

如果安装samba出问题了，执行卸载命令即可：

sudo apt-get remove samba
sudo apt-get remove smbclient
sudo apt-get remove cifs-utils

2.修改配置文件

sudo gedit /etc/samba/smb.conf

在global下的workgroup=WORKGROUP下面添加一句：

security = user

然后在文件末尾添加：

[workspace]
   comment = sharefolder
   path = /home/mario/workspace
   valid users = mario
   browseable = yes
   read only = yes
   create mask = 0777
   directory mask = 0777
   public = yes
   writable = yes
   available = yes

注意：

path：/home/mario/workspace表示你想共享的文件夹名称，首先你要

在ubuntu下创建这个文件夹workspace，并执行chmod添加权限：

sudo chmod 777 /home/mario/workspace

valid users：表示你允许访问该共享的用户

保存后重新启动samba

sudo /etc/init.d/samba restart

或者 sudo /etc/init.d/smbd restart

可以cd到 /etc/init.d/下查看是哪个（samba或者smbd）

3.设置用户和密码

sudo smbpasswd -a mario

输入两次密码后就可以了。

smbpasswd的用法：

smbpasswd -a users：增加用户users

smbpasswd -d users：冻结用户users，这个用户不能再登录

smbpasswd -e users：恢复冻结的用户users，让冻结的用户可以再使用

smbpasswd -x users：删除用户users