rsync 文件同步与定时备份实战
rsync，一款用于文件同步的程序，可以实现本机、局域网和广域网的文件同步。方便、快捷、高效。rsync默认采用的时间同步方法，即只同步时间不同的文件，而且是增量同步，已存在的文件不会再次复制，只会同步那些不存在的文件。首先，我们要进行服务器间的文件同步，必须保证两台服务器所使用的时区相同。我这里使用的测试环境是Debian 9.4 64位，时区是中国上海时区（因为在Linux下没有中国北京时区，上海时区跟北京东八区是一样的）。
timedatectl set-timezone Asia/Shanghai使用上面这个命令即可把时区设置中国时间。然后使用timedatectl即可查看当前系统时间，可以看到当前时间已经是北京时间了
下面我们安装rsync程序（Debian系统默认已经安装了）
1 | apt install rsync -y |
rsync参数有
1 | -v, --verbose 详细模式输出 |
实际上我们常用的参数就是avzP和delete
1 | -a 参数，相当于-rlptgoD， |
rsync最常用的方式：rsync 参数列表 源目录 目标目录
例如：rsync -avzP –delete /home/a/ /home/b。把/home/a目录下的所有文件备份到/home/b下
1 | rsync -avzP --delete /home/a /home/b |
把/home/下a目录（包括a目录下所有文件）备份到/home/b下
这里要特别注意：源目录包含/和不包含/是完全不同意义的，带了/的表示目录下的所有文件，不带/的表示包含目录本身
如果同步远程服务器的文件，则使用命令：
rsync -avzP --delete -e "ssh -p ssh的端口号" 远程服务器IP:源目录 本地目录
温馨提示：
1、如果远程服务器的ssh用的是默认端口22，则可以不写 -e “ssh -p ssh的端口号”。
2、服务器IP跟源目录之间要用冒号分隔开
3、第一次连接远程服务器时可能会提示“Are you sure you want to continue connecting (yes/no)?”，输入yes确认连接，然后输入远程服务器的ssh密码即可完成文件同步。
上面的操作都是把远程服务器上的文件同步到本机，那么如果是把本机的文件推送到远程服务器呢？其实命令也是一样的，只不过是把源目录和目标目录调换过来而已。如下命令：rsync -avzP --delete 本机目录 远程服务器IP**:**目标目录
同样的，需要输入远程服务器的ssh密码
配合crontab定时任务来执行文件同步。
1、首先，我们先要知道，如果是不使用ssh密码的话，那么我们就要让rsync以daemon的方式运行，同时我们要为rsync的同步操作创建专用的账号密码。另外，我们还可以配置允许哪些IP进行连接我们的rsync服务器，拒绝哪些IP连接，以及允许同步什么目录。
2、我们先来创建rsync的配置文件，我们将rsync相关的文件全部保存在**/etc/rsync目录下，我们先创建/etc/rsync目录，然后创建rsync.conf**配置文件
1 | mkdir /etc/rsync |
然后在rsync.conf文件写入如下配置：
1 | #指定pid文件路径 |
然后在/etc/rsync下建立账号密码文件rsync.passwd，接着写入内容，格式是账号:密码
比如我们上面的配置，配的用户名是rsync，假定密码是123654，那么rsync.passwd的内容是rsync:123654接着我们给这个文件授权为600.
1 | chmod 600 /etc/rsync/rsync.passwd |
操作完上面的步骤后，我们正式启动rsync程序 –config参数指定我们要用的配置文件路径
1 | rsync --daemon --config=/etc/rsync/rsync.conf |
此时，服务器端的rsync就已经配置完成了。下面我们配置客户端，客户端就非常简单的，第一步就是apt install rysnc -y安装程序，然后创建/etc/rsync目录接着再创建账号密码文件**/etc/rsync/rsync.passwd**
注意：这里不用填写用户名，只要填写密码即可，例如上面我们指定的密码是123654，那么rsync.passwd的内容就是123654
授权为600：chmod 600 /etc/rsync/rsync.passwd
然后运行rsync，例如：rsync -avzP –delete –password-file=/etc/rsync/rsync.passwd rsync@x.x.x.x::web /home
–password-file指定了密码文件，rsync是用户名，x.x.x.x是服务器的IP，web是服务器端的自定义模块名，/home是备份到本地的home目录执行完上面的命令后，正常的话就可以看到已经开始把服务器/home/wwwroot目录下的全部文件慢慢同步到本机的/home目录下了。下面我们把这个命令加到定时任务中。定时任务我们主要用到crontab，编辑任务列表
1 | crontab -e |
然后把rsync -avzP --delete --password-file=/etc/rsync/rsync.passwd rsync@x.x.x.x::web /home加进去，变成如下格式：
1 | */5 * * * * rsync -avzP --delete --password-file=/etc/rsync/rsync.passwd rsync@x.x.x.x::web /home |
这个表示每5分钟进行同步一次，大家可以留意一下后面任务有没有正常间隔5分钟执行。
Rsync 增量备份方案：从 192.168.6.2 同步 /home 到 192.168.6.1
创建备份脚本/usr/local/bin/backup_home.sh examples
1 |
|
周期性完整备份 + 每日增量
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 每月1日做完整备份，其他时间做增量
if [ $(date +%d) -eq "01" ]; then
# 完整备份
rsync -avz --delete user@192.168.6.2:/home/ /backup/home/full.$(date +%Y%m%d)/
else
# 增量备份(基于上月完整备份)
LAST_FULL=$(find /backup/home -name "full.*" -type d | sort | tail -n 1)
rsync -avz --delete --link-dest="$LAST_FULL" user@192.168.6.2:/home/ /backup/home/incr.$(date +%Y%m%d)/
fi
# 保留策略
find /backup/home -name "full.*" -type d -mtime +365 -exec rm -rf {} \; # 保留1年完整备份
find /backup/home -name "incr.*" -type d -mtime +30 -exec rm -rf {} \; # 保留30天增量
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# ------ 配置部分 ------
SSH_PORT="2233" # SSH 端口
REMOTE_PATH="user@104.168.82.223:/mnt/docker-data/vaultwarden" # 远程路径
DEST_BASE="/backup/vaultwarden" # 本地备份目录
LOG_FILE="/var/log/backup_vaultwarden.log" # 日志文件
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天日期
PREVIOUS_BACKUP="${DEST_BASE}/daily.${PREVIOUS_DATE}" # 昨天的备份路径
TAR_FILE="${DEST_BASE}/vaultwarden_full_${DATE}.tar.gz" # 打包文件名
# ------ 检查远程路径 ------
if [ -z "$REMOTE_PATH" ]; then
echo "ERROR: Remote path is empty!" | tee -a "$LOG_FILE"
exit 1
fi
# ------ 创建目录 ------
mkdir -p "${DEST_BASE}/daily.${DATE}"
# ------ 1. 增量备份（rsync + SSH端口）------
echo "Starting rsync backup on $(date)" >> "$LOG_FILE"
if [ -d "${PREVIOUS_BACKUP}" ]; then
rsync -avz --delete --link-dest="${PREVIOUS_BACKUP}" \
-e "ssh -p $SSH_PORT" \
--log-file="$LOG_FILE" \
"$REMOTE_PATH" "${DEST_BASE}/daily.${DATE}/"
else
rsync -avz --delete \
-e "ssh -p $SSH_PORT" \
--log-file="$LOG_FILE" \
"$REMOTE_PATH" "${DEST_BASE}/daily.${DATE}/"
fi
# ------ 2. 完整打包备份（tar.gz）------
if [ ! -f "$TAR_FILE" ]; then
echo "Creating full backup archive: $TAR_FILE" >> "$LOG_FILE"
tar -czf "$TAR_FILE" -C "${DEST_BASE}/daily.${DATE}" . 2>> "$LOG_FILE"
else
echo "WARNING: $TAR_FILE already exists, skipping compression." >> "$LOG_FILE"
fi
# ------ 清理旧备份（保留7天）------
echo "Cleaning old backups..." >> "$LOG_FILE"
find "$DEST_BASE" -name "daily.*" -type d -mtime +7 -exec rm -rf {} \;
find "$DEST_BASE" -name "vaultwarden_full_*.tar.gz" -mtime +7 -delete
echo "Backup completed at $(date)" >> "$LOG_FILE"远程备份+加密
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# ------ 配置部分 ------
SSH_PORT="2233" # SSH 端口
REMOTE_PATH="user@104.168.82.223:/mnt/docker-data/vaultwarden" # 远程路径
DEST_BASE="/backup/vaultwarden" # 本地备份目录
LOG_FILE="/var/log/backup_vaultwarden.log" # 日志文件
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天日期
PREVIOUS_BACKUP="${DEST_BASE}/daily.${PREVIOUS_DATE}" # 昨天的备份路径
TAR_FILE="${DEST_BASE}/vaultwarden_full_${DATE}.tar.gz" # 打包文件名
GPG_FILE="${DEST_BASE}/vaultwarden_encrypted_${DATE}.tar.gz.gpg" # GPG 加密文件
SSH_KEY="$HOME/.ssh/id_rsa_backup" # 无密码 SSH 私钥
GPG_PASSFILE="$HOME/.backup_password" # GPG 密码文件（chmod 600）
# ------ 检查远程路径 ------
if [ -z "$REMOTE_PATH" ]; then
echo "ERROR: Remote path is empty!" | tee -a "$LOG_FILE"
exit 1
fi
# ------ 1. 检查 SSH 密钥是否存在 ------
if [ ! -f "$SSH_KEY" ]; then
echo "ERROR: SSH key $SSH_KEY not found!" | tee -a "$LOG_FILE"
exit 1
fi
# ------ 2. 检查 GPG 密码文件是否存在 ------
if [ ! -f "$GPG_PASSFILE" ]; then
echo "ERROR: GPG password file $GPG_PASSFILE not found!" | tee -a "$LOG_FILE"
exit 1
fi
# ------ 3. 创建备份目录 ------
mkdir -p "${DEST_BASE}/daily.${DATE}"
# ------ 4. 增量备份（rsync + SSH 免密）------
echo "Starting rsync backup on $(date)" >> "$LOG_FILE"
if [ -d "${PREVIOUS_BACKUP}" ]; then
rsync -avz --delete --link-dest="${PREVIOUS_BACKUP}" \
-e "ssh -i $SSH_KEY -p $SSH_PORT" \
--log-file="$LOG_FILE" \
"$REMOTE_PATH" "${DEST_BASE}/daily.${DATE}/"
else
rsync -avz --delete \
-e "ssh -i $SSH_KEY -p $SSH_PORT" \
--log-file="$LOG_FILE" \
"$REMOTE_PATH" "${DEST_BASE}/daily.${DATE}/"
fi
# ------ 5. 完整打包备份（tar.gz + GPG 加密）------
if [ ! -f "$TAR_FILE" ]; then
echo "Creating full backup archive: $TAR_FILE" >> "$LOG_FILE"
tar -czf - -C "${DEST_BASE}/daily.${DATE}" . 2>> "$LOG_FILE" | \
gpg -c --batch --passphrase-file "$GPG_PASSFILE" --cipher-algo AES256 -o "$GPG_FILE" 2>> "$LOG_FILE"
else
echo "WARNING: $TAR_FILE already exists, skipping compression." >> "$LOG_FILE"
fi
# ------ 6. 清理旧备份（保留7天增量 + 30天加密备份）------
echo "Cleaning old backups..." >> "$LOG_FILE"
find "$DEST_BASE" -name "daily.*" -type d -mtime +7 -exec rm -rf {} \;
find "$DEST_BASE" -name "vaultwarden_full_*.tar.gz" -mtime +7 -delete
find "$DEST_BASE" -name "vaultwarden_encrypted_*.tar.gz.gpg" -mtime +30 -delete
echo "Backup completed at $(date)" >> "$LOG_FILE"远程备份+加密（不创建增量文件夹，全量备份压缩）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# ------ 配置部分 ------
SSH_PORT="2233" # SSH 端口
REMOTE_PATH="/mnt/docker-data/vaultwarden" # 远程服务器上的路径
REMOTE_HOST="root@104.168.82.223" # 远程主机
DEST_BASE="/backup/vaultwarden" # 本地备份目录
LOG_FILE="/var/log/backup_vaultwarden.log" # 日志文件
DATE=$(date +%Y%m%d) # 当前日期
GPG_FILE="${DEST_BASE}/vaultwarden_encrypted_${DATE}.tar.gz.gpg" # GPG 加密文件
SSH_KEY="/home/yuki/.ssh/authorized_keys" # SSH 私钥
GPG_PASSFILE="/backup/.backup_password" # GPG 密码文件（chmod 600）
KEEP_DAYS=30 # 加密备份保留天数
# ------ 检查配置 ------
if [ -z "$REMOTE_PATH" ]; then
echo "ERROR: Remote path is empty!" | tee -a "$LOG_FILE"
exit 1
fi
if [ ! -f "$SSH_KEY" ]; then
echo "ERROR: SSH key $SSH_KEY not found!" | tee -a "$LOG_FILE"
exit 1
fi
if [ ! -f "$GPG_PASSFILE" ]; then
echo "ERROR: GPG password file $GPG_PASSFILE not found!" | tee -a "$LOG_FILE"
exit 1
fi
# ------ 创建备份目录 ------
mkdir -p "$DEST_BASE"
# ------ 通过SSH流式传输+直接加密备份 ------
echo "Starting direct encrypted backup via SSH on $(date)" >> "$LOG_FILE"
ssh -i "$SSH_KEY" -p "$SSH_PORT" "$REMOTE_HOST" \
"tar -czf - -C \"$REMOTE_PATH\" ." 2>> "$LOG_FILE" | \
gpg -c --batch --passphrase-file "$GPG_PASSFILE" \
--cipher-algo AES256 -o "$GPG_FILE" 2>> "$LOG_FILE"
# ------ 清理旧备份 ------
echo "Cleaning backups older than $KEEP_DAYS days..." >> "$LOG_FILE"
find "$DEST_BASE" -name "vaultwarden_encrypted_*.tar.gz.gpg" -mtime +$KEEP_DAYS -delete
echo "Backup completed at $(date)" >> "$LOG_FILE"
2
3
4
5
6
7
8
9
10
11
12
13
14
#[ -f "$GPG_FILE" ] && rm -f "$GPG_FILE"
if [ -f "$GPG_FILE" ]; then
echo "$GPG_FILE already exists, overwriting..." | tee -a "$LOG_FILE"
rm -f "$GPG_FILE"
fi
# 添加 --yes 参数：强制 GPG 覆盖已存在的文件
echo "Starting direct encrypted backup via SSH on $(date)" >> "$LOG_FILE"
ssh -i "$SSH_KEY" -p "$SSH_PORT" "$REMOTE_HOST" \
"tar -czf - -C \"$REMOTE_PATH\" ." 2>> "$LOG_FILE" | \
gpg --yes -c --batch --passphrase-file "$GPG_PASSFILE" \
--cipher-algo AES256 -o "$GPG_FILE" 2>> "$LOG_FILE"本地备份
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# ------ 配置部分 ------
LOCAL_PATH="/mnt/images-data" # 源路径
DEST_BASE="/mnt/images-data-backup" # 本地备份目录
LOG_FILE="/var/log/backup_cvat.log" # 日志文件
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天日期
LATEST_BACKUP="${DEST_BASE}/daily.${PREVIOUS_DATE}" # 用于增量备份的基础目录
TAR_FILE="${DEST_BASE}/cvat_full_${DATE}.tar.gz" # 打包文件名
TODAYS_BACKUP="${DEST_BASE}/daily.${DATE}" # 今天的备份目录
# ------ 检查路径 ------
[ -z "$LOCAL_PATH" ] && { echo "ERROR: Local path is empty!" | tee -a "$LOG_FILE"; exit 1; }
# ------ 创建备份目录 ------
mkdir -p "$TODAYS_BACKUP"
# ------ 增量备份 ------
echo "Starting incremental backup on $(date)" >> "$LOG_FILE"
if [ -d "$LATEST_BACKUP" ]; then
echo "Using $LATEST_BACKUP as reference for incremental backup" >> "$LOG_FILE"
rsync -av --delete --link-dest="$LATEST_BACKUP" \
--log-file="$LOG_FILE" \
"$LOCAL_PATH/" "$TODAYS_BACKUP/"
else
echo "No previous backup found, performing full initial backup" >> "$LOG_FILE"
rsync -av --delete \
--log-file="$LOG_FILE" \
"$LOCAL_PATH/" "$TODAYS_BACKUP/"
fi
# ------ 5. 完整打包备份------
echo "Creating full backup archive with pigz: $TAR_FILE" >> "$LOG_FILE"
tar -cf - -C "${DEST_BASE}/daily.${DATE}" . 2>> "$LOG_FILE" | \
pigz -9 -p 8 > "$TAR_FILE" 2>> "$LOG_FILE"
# 检查打包是否成功
if [ $? -eq 0 ]; then
echo "Successfully created pigz compressed archive: $TAR_FILE" >> "$LOG_FILE"
else
echo "Error: Failed to create backup archive with pigz" >> "$LOG_FILE"
exit 1
fi
# ------ 6. 清理旧备份（保留7天增量 + 30天备份）------
echo "Cleaning old backups..." >> "$LOG_FILE"
find "$DEST_BASE" -name "daily.*" -type d -mtime +7 -exec rm -rf {} \; 2>> "$LOG_FILE"
find "$DEST_BASE" -name "cvat_full_*.tar.gz" -mtime +30 -delete 2>> "$LOG_FILE"
if [ $? -eq 0 ]; then
echo "Old backups cleanup completed successfully" >> "$LOG_FILE"
else
echo "Warning: Some errors occurred during cleanup" >> "$LOG_FILE"
fi本地备份
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# ------ 配置部分 ------
LOCAL_PATH="/mnt/images-data" # 源路径
DEST_BASE="/mnt/images-data-backup" # 本地备份目录
LOG_FILE="/var/log/backup_cvat.log" # 日志文件
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天时间
LATEST_BACKUP="${DEST_BASE}/daily.${PREVIOUS_DATE}"
TAR_FILE="${DEST_BASE}/cvat_full_${DATE}.tar.gz"
TODAYS_BACKUP="${DEST_BASE}/daily.${DATE}"
# ------ 初始化日志 ------
{
echo "=== Backup started at $(date) ==="
echo "Source: $LOCAL_PATH"
echo "Destination: $DEST_BASE"
} >> "$LOG_FILE"
# ------ 检查路径 ------
[ -d "$LOCAL_PATH" ] || {
echo "ERROR: Source path $LOCAL_PATH not found!" | tee -a "$LOG_FILE"
exit 1
}
# ------ 创建备份目录 ------
mkdir -p "$TODAYS_BACKUP" || {
echo "ERROR: Failed to create backup directory" | tee -a "$LOG_FILE"
exit 1
}
# ------ 增量备份 ------
echo "[$(date +%H:%M:%S)] Starting rsync..." >> "$LOG_FILE"
# 检查文件是否已存在
if [ -f "$TAR_FILE" ]; then
echo "ERROR: Backup file already exists: $TAR_FILE (will not overwrite)" >> "$LOG_FILE"
exit 1
fi
RSYNC_CMD=(rsync -av --delete --checksum --log-file="$LOG_FILE")
[ -d "$LATEST_BACKUP" ] && RSYNC_CMD+=(--link-dest="$LATEST_BACKUP")
if "${RSYNC_CMD[@]}" "$LOCAL_PATH/" "$TODAYS_BACKUP/"; then
echo "[$(date +%H:%M:%S)] Rsync completed successfully" >> "$LOG_FILE"
# 校验备份完整性
echo "[$(date +%H:%M:%S)] Verifying backup..." >> "$LOG_FILE"
diff -rq "$LOCAL_PATH/" "$TODAYS_BACKUP/" >> "$LOG_FILE" 2>&1 || {
echo "WARNING: Backup verification found differences" >> "$LOG_FILE"
}
else
echo "ERROR: Rsync failed with code $?" >> "$LOG_FILE"
exit 1
fi
# ------ 完整打包备份 ------
echo "[$(date +%H:%M:%S)] Creating compressed archive..." >> "$LOG_FILE"
# 使用exclude排除常见临时文件
EXCLUDE_LIST=("*.tmp" "*.swp" "*.bak" "*~")
TAR_EXCLUDE=""
for pattern in "${EXCLUDE_LIST[@]}"; do
TAR_EXCLUDE+="--exclude='$pattern' "
done
if tar ${TAR_EXCLUDE} -cf - -C "$TODAYS_BACKUP" . 2>> "$LOG_FILE" | \
pigz -9 -p 8 > "$TAR_FILE" 2>> "$LOG_FILE"; then
# 验证压缩包完整性
if pigz -t "$TAR_FILE" &>> "$LOG_FILE"; then
echo "[$(date +%H:%M:%S)] Archive verified successfully" >> "$LOG_FILE"
else
echo "ERROR: Archive verification failed" >> "$LOG_FILE"
exit 1
fi
else
echo "ERROR: Archive creation failed" >> "$LOG_FILE"
exit 1
fi
# ------ 清理旧备份 ------
echo "[$(date +%H:%M:%S)] Cleaning old backups..." >> "$LOG_FILE"
# 保留最近7天增量备份
find "$DEST_BASE" -name "daily.*" -type d -mtime +7 -exec rm -rf {} \; 2>> "$LOG_FILE"
# 保留最近30天完整备份
find "$DEST_BASE" -name "cvat_full_*.tar.gz" -mtime +30 -delete 2>> "$LOG_FILE"
echo "[$(date +%H:%M:%S)] Cleanup completed" >> "$LOG_FILE"
echo "=== Backup finished at $(date) ===" >> "$LOG_FILE"密钥 本地+远程
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
# =============================================
# CVAT 智能双备份脚本 (本地+群晖NAS)
# 版本：2.1
# 功能：增量备份 + 跨系统一致性清理
# =============================================
# ------ 配置区（根据实际修改）------
LOCAL_PATH="/mnt/images-data" # 源数据目录
LOCAL_BACKUP="/mnt/images-data-backup" # 本地备份根目录
REMOTE_USER="rsync_user" # 群晖SSH账号
REMOTE_HOST="192.168.6.216" # 群晖IP地址
REMOTE_PORT="22" # SSH端口
REMOTE_PATH="/volume1/backup/images-data-backup" # 远程备份路径
LOG_FILE="/var/log/backup_cvat.log" # 日志路径
RETENTION_DAYS=7 # 备份保留天数
# ------ 初始化日志 ------
exec 3>&1 4>&2
trap 'exec 2>&4 1>&3' 0 1 2 3
exec 1>>"$LOG_FILE" 2>&1
log() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] \\$1"
}
header() {
echo "========================================"
echo " \\$1"
echo "========================================"
}
header "备份任务启动 $(date '+%Y-%m-%d %H:%M:%S')"
log "配置文件校验中..."
# ------ 环境检查 ------
check_env() {
# 检查源目录
[ -d "$LOCAL_PATH" ] || {
log "错误：源目录不存在 [$LOCAL_PATH]"
exit 1
}
# 检查本地备份目录
mkdir -p "$LOCAL_BACKUP" || {
log "错误：无法创建本地备份目录 [$LOCAL_BACKUP]"
exit 1
}
# 检查SSH连接
if ! ssh -p "$REMOTE_PORT" -o BatchMode=yes -o ConnectTimeout=5 "$REMOTE_USER@$REMOTE_HOST" true; then
log "错误：无法连接到远程服务器 [$REMOTE_USER@$REMOTE_HOST]"
exit 1
fi
# 检查远程目录
if ! ssh -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" "mkdir -p '$REMOTE_PATH'"; then
log "错误：远程目录创建失败 [$REMOTE_PATH]"
exit 1
fi
}
# ------ 本地备份函数 ------
local_backup() {
local DATE=$(date +%Y%m%d)
local TODAYS_BACKUP="$LOCAL_BACKUP/daily.$DATE"
local LATEST_BACKUP=$(ls -d "$LOCAL_BACKUP"/daily.* 2>/dev/null | sort | tail -n 1)
log "开始本地备份 -> $TODAYS_BACKUP"
mkdir -p "$TODAYS_BACKUP" || {
log "错误：本地备份目录创建失败"
return 1
}
local RSYNC_CMD=(rsync -av --delete --checksum)
[ -n "$LATEST_BACKUP" ] && RSYNC_CMD+=(--link-dest="$LATEST_BACKUP")
if "${RSYNC_CMD[@]}" "$LOCAL_PATH/" "$TODAYS_BACKUP/"; then
log "本地备份成功 ($(du -sh "$TODAYS_BACKUP" | cut -f1))"
else
log "错误：本地rsync失败 (代码:$?)"
return 1
fi
}
# ------ 远程备份函数 ------
remote_backup() {
local DATE=$(date +%Y%m%d)
local TODAYS_BACKUP="$REMOTE_PATH/daily.$DATE"
local LATEST_BACKUP=$(ssh -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" \
"ls -d '$REMOTE_PATH'/daily.* 2>/dev/null | sort | tail -n 1")
log "开始远程备份 -> $REMOTE_USER@$REMOTE_HOST:$TODAYS_BACKUP"
local RSYNC_CMD=(rsync -avz --delete --checksum -e "ssh -p $REMOTE_PORT")
[ -n "$LATEST_BACKUP" ] && RSYNC_CMD+=(--link-dest="$LATEST_BACKUP")
if "${RSYNC_CMD[@]}" "$LOCAL_PATH/" "$REMOTE_USER@$REMOTE_HOST:$TODAYS_BACKUP/"; then
log "远程备份成功"
else
log "错误：远程rsync失败 (代码:$?)"
return 1
fi
}
# ------ 智能清理函数 ------
clean_backups() {
header "开始智能清理 (保留${RETENTION_DAYS}天)"
# 获取备份列表
local LOCAL_LIST=$(find "$LOCAL_BACKUP" -maxdepth 1 -name 'daily.*' -type d -printf '%f\n' | sort)
local REMOTE_LIST=$(ssh -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" \
"find '$REMOTE_PATH' -maxdepth 1 -name 'daily.*' -type d -printf '%f\n' | sort")
# 计算截止日期
local CUTOFF_DATE=$(date -d "$RETENTION_DAYS days ago" +%Y%m%d)
log "将清理早于 $CUTOFF_DATE 的备份"
# 合并所有备份日期
local ALL_BACKUPS=$(echo -e "$LOCAL_LIST\n$REMOTE_LIST" | sed 's/daily\.//' | sort -u)
# 清理函数
cleanup() {
local DATE=\$1
local DATE_DIR="daily.$DATE"
# 本地清理
if echo "$LOCAL_LIST" | grep -q "$DATE_DIR"; then
log "删除本地备份: $DATE_DIR"
rm -rf "${LOCAL_BACKUP}/${DATE_DIR}" || \
log "警告：本地删除失败 [$DATE_DIR]"
fi
# 远程清理
if echo "$REMOTE_LIST" | grep -q "$DATE_DIR"; then
log "删除远程备份: $DATE_DIR"
ssh -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" \
"rm -rf '${REMOTE_PATH}/${DATE_DIR}'" || \
log "警告：远程删除失败 [$DATE_DIR]"
fi
}
# 遍历处理
while read -r date_dir; do
local backup_date=${date_dir#daily.}
# 验证日期格式
[[ "$backup_date" =~ ^[0-9]{8}$ ]] || continue
# 判断是否过期
if [[ "$backup_date" -lt "$CUTOFF_DATE" ]]; then
cleanup "$backup_date"
else
log "保留备份: daily.$backup_date"
fi
done <<< "$(echo -e "$LOCAL_LIST\n$REMOTE_LIST" | grep 'daily.' | sort -u)"
log "清理完成"
}
# ------ 主执行流程 ------
check_env
header "备份状态概览"
log "本地备份目录: $(ls -d "$LOCAL_BACKUP"/daily.* 2>/dev/null | wc -l) 个"
log "远程备份目录: $(ssh -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" "ls -d '$REMOTE_PATH'/daily.* 2>/dev/null | wc -l) 个"
if local_backup && remote_backup; then
clean_backups
header "备份成功完成 $(date '+%Y-%m-%d %H:%M:%S')"
else
header "备份失败! $(date '+%Y-%m-%d %H:%M:%S')"
exit 1
fi
exit 0密钥 本地+远程
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
# ------ 配置部分 ------
LOCAL_PATH="/mnt/images-data" # 源路径
DEST_BASE="/mnt/images-data-backup" # 本地备份目录
REMOTE_USER="sync" # 远程NAS用户名
REMOTE_HOST="192.168.6.216" # 远程NAS地址
REMOTE_PORT="22" # 远程端口
REMOTE_PATH="/home/sync/images-data-backup" # 远程备份路径
LOG_FILE="/var/log/backup_cvat.log" # 日志文件
RETENTION_DAYS=7 # 增量备份保留天数
FULL_RETENTION_DAYS=30 # 完整备份保留天数
COMPRESS_LEVEL=3 # 压缩级别(1-9)
MAX_THREADS=$(($(nproc) * 2)) # 最大线程数(CPU核心x2)
# 日期变量
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天时间
LATEST_BACKUP="daily.${PREVIOUS_DATE}"
TAR_FILE="cvat_full_${DATE}.tar.gz"
TODAYS_BACKUP="daily.${DATE}"
# rsync参数(根据线程数优化)
RSYNC_OPTS="-av --delete --checksum --partial --progress"
[ $MAX_THREADS -gt 1 ] && RSYNC_OPTS="$RSYNC_OPTS --compress --compress-level=$COMPRESS_LEVEL"
# ------ 初始化日志 ------
{
echo "=== Backup started at $(date) ==="
echo "Source: $LOCAL_PATH"
echo "Local Destination: $DEST_BASE"
echo "Remote Destination: $REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH"
echo "Performance Settings:"
echo " Retention: $RETENTION_DAYS days (incremental), $FULL_RETENTION_DAYS days (full)"
echo " Compression Level: $COMPRESS_LEVEL"
echo " Max Threads: $MAX_THREADS"
echo "--------------------------------"
} >> "$LOG_FILE"
# ------ 检查路径 ------
[ -d "$LOCAL_PATH" ] || {
echo "ERROR: Source path $LOCAL_PATH not found!" | tee -a "$LOG_FILE"
exit 1
}
# ------ 本地备份 ------
echo "[$(date +%H:%M:%S)] Starting LOCAL backup (Threads: $MAX_THREADS)..." >> "$LOG_FILE"
# 创建本地备份目录
mkdir -p "${DEST_BASE}/${TODAYS_BACKUP}" || {
echo "ERROR: Failed to create local backup directory" | tee -a "$LOG_FILE"
exit 1
}
# 本地增量备份
LOCAL_RSYNC_CMD=(rsync $RSYNC_OPTS --log-file="$LOG_FILE")
[ -d "${DEST_BASE}/${LATEST_BACKUP}" ] && LOCAL_RSYNC_CMD+=(--link-dest="${DEST_BASE}/${LATEST_BACKUP}")
if "${LOCAL_RSYNC_CMD[@]}" "$LOCAL_PATH/" "${DEST_BASE}/${TODAYS_BACKUP}/"; then
echo "[$(date +%H:%M:%S)] Local rsync completed successfully" >> "$LOG_FILE"
# 校验本地备份完整性
echo "[$(date +%H:%M:%S)] Verifying local backup..." >> "$LOG_FILE"
diff -rq "$LOCAL_PATH/" "${DEST_BASE}/${TODAYS_BACKUP}/" >> "$LOG_FILE" 2>&1 || {
echo "WARNING: Local backup verification found differences" >> "$LOG_FILE"
}
else
echo "ERROR: Local rsync failed with code $?" >> "$LOG_FILE"
exit 1
fi
# ------ 远程备份 ------
echo "[$(date +%H:%M:%S)] Starting REMOTE backup to $REMOTE_HOST (Threads: $MAX_THREADS)..." >> "$LOG_FILE"
# 检查远程连接
if ! ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "mkdir -p ${REMOTE_PATH}/${TODAYS_BACKUP}"; then
echo "ERROR: Failed to create remote backup directory" | tee -a "$LOG_FILE"
exit 1
fi
# 远程增量备份
REMOTE_RSYNC_CMD=(rsync $RSYNC_OPTS --log-file="$LOG_FILE" -e "ssh -p $REMOTE_PORT")
# 检查远程是否有昨天的备份
if ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "[ -d ${REMOTE_PATH}/${LATEST_BACKUP} ]"; then
REMOTE_RSYNC_CMD+=(--link-dest="${REMOTE_PATH}/${LATEST_BACKUP}")
fi
if "${REMOTE_RSYNC_CMD[@]}" "$LOCAL_PATH/" ${REMOTE_USER}@${REMOTE_HOST}:"${REMOTE_PATH}/${TODAYS_BACKUP}/"; then
echo "[$(date +%H:%M:%S)] Remote rsync completed successfully" >> "$LOG_FILE"
else
echo "ERROR: Remote rsync failed with code $?" >> "$LOG_FILE"
exit 1
fi
# ------ 本地完整打包备份 ------
echo "[$(date +%H:%M:%S)] Creating LOCAL compressed archive (Level: $COMPRESS_LEVEL)..." >> "$LOG_FILE"
# 使用exclude排除常见临时文件
EXCLUDE_LIST=("*.tmp" "*.swp" "*.bak" "*~")
TAR_EXCLUDE=""
for pattern in "${EXCLUDE_LIST[@]}"; do
TAR_EXCLUDE+="--exclude='$pattern' "
done
if tar ${TAR_EXCLUDE} -cf - -C "${DEST_BASE}/${TODAYS_BACKUP}" . 2>> "$LOG_FILE" | \
pigz -$COMPRESS_LEVEL -p $MAX_THREADS > "${DEST_BASE}/${TAR_FILE}" 2>> "$LOG_FILE"; then
# 验证压缩包完整性
if pigz -t "${DEST_BASE}/${TAR_FILE}" &>> "$LOG_FILE"; then
echo "[$(date +%H:%M:%S)] Local archive verified successfully" >> "$LOG_FILE"
echo "Archive Size: $(du -sh ${DEST_BASE}/${TAR_FILE} | cut -f1)" >> "$LOG_FILE"
else
echo "ERROR: Local archive verification failed" >> "$LOG_FILE"
exit 1
fi
else
echo "ERROR: Local archive creation failed" >> "$LOG_FILE"
exit 1
fi
# ------ 远程完整打包备份 ------
echo "[$(date +%H:%M:%S)] Creating REMOTE compressed archive (Level: $COMPRESS_LEVEL)..." >> "$LOG_FILE"
# 在远程服务器上创建压缩包
if ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "tar ${TAR_EXCLUDE} -cf - -C ${REMOTE_PATH}/${TODAYS_BACKUP} . 2>> ${REMOTE_PATH}/backup.log | \
pigz -$COMPRESS_LEVEL -p $MAX_THREADS > ${REMOTE_PATH}/${TAR_FILE} 2>> ${REMOTE_PATH}/backup.log"; then
# 验证远程压缩包完整性
if ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "pigz -t ${REMOTE_PATH}/${TAR_FILE}"; then
REMOTE_SIZE=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "du -sh ${REMOTE_PATH}/${TAR_FILE} | cut -f1")
echo "[$(date +%H:%M:%S)] Remote archive verified successfully" >> "$LOG_FILE"
echo "Remote Archive Size: $REMOTE_SIZE" >> "$LOG_FILE"
else
echo "ERROR: Remote archive verification failed" >> "$LOG_FILE"
exit 1
fi
else
echo "ERROR: Remote archive creation failed" >> "$LOG_FILE"
exit 1
fi
# ------ 清理旧备份 ------
echo "[$(date +%H:%M:%S)] Cleaning old backups (Retention: $RETENTION_DAYS days incremental, $FULL_RETENTION_DAYS days full)..." >> "$LOG_FILE"
# 本地清理
# 保留最近N天增量备份
find "$DEST_BASE" -name "daily.*" -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \; 2>> "$LOG_FILE"
# 保留最近M天完整备份
find "$DEST_BASE" -name "cvat_full_*.tar.gz" -mtime +$FULL_RETENTION_DAYS -delete 2>> "$LOG_FILE"
# 远程清理 - 先校验文件是否存在两边
echo "[$(date +%H:%M:%S)] Cleaning REMOTE old backups with verification..." >> "$LOG_FILE"
# 获取远程备份列表
REMOTE_BACKUPS=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "find ${REMOTE_PATH} -name 'daily.*' -type d -mtime +$RETENTION_DAYS -printf '%f\n' 2>/dev/null")
REMOTE_TARS=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "find ${REMOTE_PATH} -name 'cvat_full_*.tar.gz' -mtime +$FULL_RETENTION_DAYS -printf '%f\n' 2>/dev/null")
for backup in $REMOTE_BACKUPS; do
# 检查本地是否还有对应的备份
if [ ! -d "${DEST_BASE}/${backup}" ]; then
echo "Deleting remote ${backup} as it's older than $RETENTION_DAYS days and not present locally" >> "$LOG_FILE"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "rm -rf ${REMOTE_PATH}/${backup}" 2>> "$LOG_FILE"
else
echo "Keeping remote ${backup} as it still exists locally" >> "$LOG_FILE"
fi
done
for tarfile in $REMOTE_TARS; do
# 检查本地是否还有对应的压缩包
if [ ! -f "${DEST_BASE}/${tarfile}" ]; then
echo "Deleting remote ${tarfile} as it's older than $FULL_RETENTION_DAYS days and not present locally" >> "$LOG_FILE"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "rm -f ${REMOTE_PATH}/${tarfile}" 2>> "$LOG_FILE"
else
echo "Keeping remote ${tarfile} as it still exists locally" >> "$LOG_FILE"
fi
done
echo "[$(date +%H:%M:%S)] Cleanup completed" >> "$LOG_FILE"
echo "=== Backup finished at $(date) ===" >> "$LOG_FILE"密码本地+远程备份
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
# ------ 配置部分 ------
LOCAL_PATH="/mnt/images-data" # 源路径
DEST_BASE="/mnt/images-data-backup" # 本地备份目录
REMOTE_USER="sync" # 远程NAS用户名
REMOTE_HOST="192.168.6.216" # 远程NAS地址
REMOTE_PORT="22" # 远程SSH端口（默认22）
REMOTE_PATH="/home/sync/images-data-backup" # 远程备份路径
LOG_FILE="/var/log/backup_cvat.log" # 日志文件
REMOTE_PASS="12345678" # 远程NAS密码
# 性能参数
RETENTION_DAYS=7 # 增量备份保留天数
FULL_RETENTION_DAYS=30 # 完整备份保留天数
COMPRESS_LEVEL=3 # 压缩级别(1-9)
MAX_THREADS=$(($(nproc) * 2)) # 最大线程数(CPU核心x2)
# 安全设置：限制密码变量作用域
export SSHPASS=$REMOTE_PASS
# 日期变量
DATE=$(date +%Y%m%d) # 当前日期
PREVIOUS_DATE=$(date -d "yesterday" +%Y%m%d) # 昨天时间
LATEST_BACKUP="daily.${PREVIOUS_DATE}"
TAR_FILE="cvat_full_${DATE}.tar.gz"
TODAYS_BACKUP="daily.${DATE}"
# rsync参数(根据线程数优化)
RSYNC_OPTS="-av --delete --checksum --partial --progress"
[ $MAX_THREADS -gt 1 ] && RSYNC_OPTS="$RSYNC_OPTS --compress --compress-level=$COMPRESS_LEVEL"
# ------ 初始化日志 ------
{
echo "=== Backup started at $(date) ==="
echo "Source: $LOCAL_PATH"
echo "Local Destination: $DEST_BASE"
echo "Remote Destination: $REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH (Port: $REMOTE_PORT)"
echo "Performance Settings:"
echo " Retention: $RETENTION_DAYS days (incremental), $FULL_RETENTION_DAYS days (full)"
echo " Compression Level: $COMPRESS_LEVEL"
echo " Max Threads: $MAX_THREADS"
echo "--------------------------------"
} >> "$LOG_FILE"
# ------ 检查路径 ------
[ -d "$LOCAL_PATH" ] || {
echo "ERROR: Source path $LOCAL_PATH not found!" | tee -a "$LOG_FILE"
exit 1
}
# ------ 本地备份 ------
echo "[$(date +%H:%M:%S)] Starting LOCAL backup (Threads: $MAX_THREADS)..." >> "$LOG_FILE"
# 创建本地备份目录
mkdir -p "${DEST_BASE}/${TODAYS_BACKUP}" || {
echo "ERROR: Failed to create local backup directory" | tee -a "$LOG_FILE"
exit 1
}
# 本地增量备份
LOCAL_RSYNC_CMD=(rsync $RSYNC_OPTS --log-file="$LOG_FILE")
[ -d "${DEST_BASE}/${LATEST_BACKUP}" ] && LOCAL_RSYNC_CMD+=(--link-dest="${DEST_BASE}/${LATEST_BACKUP}")
if "${LOCAL_RSYNC_CMD[@]}" "$LOCAL_PATH/" "${DEST_BASE}/${TODAYS_BACKUP}/"; then
echo "[$(date +%H:%M:%S)] Local rsync completed successfully" >> "$LOG_FILE"
# 校验本地备份完整性
echo "[$(date +%H:%M:%S)] Verifying local backup..." >> "$LOG_FILE"
diff -rq "$LOCAL_PATH/" "${DEST_BASE}/${TODAYS_BACKUP}/" >> "$LOG_FILE" 2>&1 || {
echo "WARNING: Local backup verification found differences" >> "$LOG_FILE"
}
else
echo "ERROR: Local rsync failed with code $?" >> "$LOG_FILE"
exit 1
fi
# ------ 远程备份 ------
echo "[$(date +%H:%M:%S)] Starting REMOTE backup to $REMOTE_HOST:$REMOTE_PORT (Threads: $MAX_THREADS)..." >> "$LOG_FILE"
# 检查远程连接
if ! sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "mkdir -p ${REMOTE_PATH}/${TODAYS_BACKUP}"; then
echo "ERROR: Failed to create remote backup directory" | tee -a "$LOG_FILE"
exit 1
fi
# 远程增量备份
REMOTE_RSYNC_CMD=(rsync $RSYNC_OPTS --log-file="$LOG_FILE")
# 检查远程是否有昨天的备份
if sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "[ -d ${REMOTE_PATH}/${LATEST_BACKUP} ]"; then
REMOTE_RSYNC_CMD+=(--link-dest="${REMOTE_PATH}/${LATEST_BACKUP}")
fi
# 使用sshpass传递密码给rsync（添加端口参数）
REMOTE_RSYNC_CMD+=(--rsh="sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT")
if rsync "${REMOTE_RSYNC_CMD[@]}" "$LOCAL_PATH/" ${REMOTE_USER}@${REMOTE_HOST}:"${REMOTE_PATH}/${TODAYS_BACKUP}/"; then
echo "[$(date +%H:%M:%S)] Remote rsync completed successfully" >> "$LOG_FILE"
else
echo "ERROR: Remote rsync failed with code $?" >> "$LOG_FILE"
exit 1
fi
# ------ 本地完整打包备份 ------
echo "[$(date +%H:%M:%S)] Creating LOCAL compressed archive (Level: $COMPRESS_LEVEL)..." >> "$LOG_FILE"
# 使用exclude排除常见临时文件
EXCLUDE_LIST=("*.tmp" "*.swp" "*.bak" "*~")
TAR_EXCLUDE=""
for pattern in "${EXCLUDE_LIST[@]}"; do
TAR_EXCLUDE+="--exclude='$pattern' "
done
if tar ${TAR_EXCLUDE} -cf - -C "${DEST_BASE}/${TODAYS_BACKUP}" . 2>> "$LOG_FILE" | \
pigz -$COMPRESS_LEVEL -p $MAX_THREADS > "${DEST_BASE}/${TAR_FILE}" 2>> "$LOG_FILE"; then
# 验证压缩包完整性
if pigz -t "${DEST_BASE}/${TAR_FILE}" &>> "$LOG_FILE"; then
echo "[$(date +%H:%M:%S)] Local archive verified successfully" >> "$LOG_FILE"
echo "Archive Size: $(du -sh ${DEST_BASE}/${TAR_FILE} | cut -f1)" >> "$LOG_FILE"
else
echo "ERROR: Local archive verification failed" >> "$LOG_FILE"
exit 1
fi
else
echo "ERROR: Local archive creation failed" >> "$LOG_FILE"
exit 1
fi
# ------ 远程完整打包备份 ------
echo "[$(date +%H:%M:%S)] Creating REMOTE compressed archive (Level: $COMPRESS_LEVEL)..." >> "$LOG_FILE"
# 在远程服务器上创建压缩包
if sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "tar ${TAR_EXCLUDE} -cf - -C ${REMOTE_PATH}/${TODAYS_BACKUP} . 2>> ${REMOTE_PATH}/backup.log | \
pigz -$COMPRESS_LEVEL -p $MAX_THREADS > ${REMOTE_PATH}/${TAR_FILE} 2>> ${REMOTE_PATH}/backup.log"; then
# 验证远程压缩包完整性
if sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "pigz -t ${REMOTE_PATH}/${TAR_FILE}"; then
REMOTE_SIZE=$(sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "du -sh ${REMOTE_PATH}/${TAR_FILE} | cut -f1")
echo "[$(date +%H:%M:%S)] Remote archive verified successfully" >> "$LOG_FILE"
echo "Remote Archive Size: $REMOTE_SIZE" >> "$LOG_FILE"
else
echo "ERROR: Remote archive verification failed" >> "$LOG_FILE"
exit 1
fi
else
echo "ERROR: Remote archive creation failed" >> "$LOG_FILE"
exit 1
fi
# ------ 清理旧备份 ------
echo "[$(date +%H:%M:%S)] Cleaning old backups (Retention: $RETENTION_DAYS days incremental, $FULL_RETENTION_DAYS days full)..." >> "$LOG_FILE"
# 本地清理
# 保留最近N天增量备份
find "$DEST_BASE" -name "daily.*" -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \; 2>> "$LOG_FILE"
# 保留最近M天完整备份
find "$DEST_BASE" -name "cvat_full_*.tar.gz" -mtime +$FULL_RETENTION_DAYS -delete 2>> "$LOG_FILE"
# 远程清理 - 先校验文件是否存在两边
echo "[$(date +%H:%M:%S)] Cleaning REMOTE old backups with verification..." >> "$LOG_FILE"
# 获取远程备份列表
REMOTE_BACKUPS=$(sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "find ${REMOTE_PATH} -name 'daily.*' -type d -mtime +$RETENTION_DAYS -printf '%f\n' 2>/dev/null")
REMOTE_TARS=$(sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "find ${REMOTE_PATH} -name 'cvat_full_*.tar.gz' -mtime +$FULL_RETENTION_DAYS -printf '%f\n' 2>/dev/null")
for backup in $REMOTE_BACKUPS; do
# 检查本地是否还有对应的备份
if [ ! -d "${DEST_BASE}/${backup}" ]; then
echo "Deleting remote ${backup} as it's older than $RETENTION_DAYS days and not present locally" >> "$LOG_FILE"
sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "rm -rf ${REMOTE_PATH}/${backup}" 2>> "$LOG_FILE"
else
echo "Keeping remote ${backup} as it still exists locally" >> "$LOG_FILE"
fi
done
for tarfile in $REMOTE_TARS; do
# 检查本地是否还有对应的压缩包
if [ ! -f "${DEST_BASE}/${tarfile}" ]; then
echo "Deleting remote ${tarfile} as it's older than $FULL_RETENTION_DAYS days and not present locally" >> "$LOG_FILE"
sshpass -e ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} "rm -f ${REMOTE_PATH}/${tarfile}" 2>> "$LOG_FILE"
else
echo "Keeping remote ${tarfile} as it still exists locally" >> "$LOG_FILE"
fi
done
# 清除密码变量
unset REMOTE_PASS
unset SSHPASS
echo "[$(date +%H:%M:%S)] Cleanup completed" >> "$LOG_FILE"
echo "=== Backup finished at $(date) ===" >> "$LOG_FILE"生成无密码 SSH 密钥
2
ssh-copy-id -i ~/.ssh/id_rsa_backup -p 2233 user@104.168.82.2232. 创建 GPG 密码文件
2
chmod 600 ~/.backup_password # 仅限当前用户可读GPG 加密（避免手动输入密码）
方法 1：使用
--passphrase直接传入密码（不安全）
2
3
4
5
gpg -c --batch --passphrase "你的密码" -o backup.gpg backup.tar.gz
# 解密
gpg -d --batch --passphrase "你的密码" -o backup.tar.gz backup.gpg❌ 缺点：密码会暴露在脚本或命令行历史中，容易被窃取。
方法 2：使用
gpg-agent（推荐）
2
3
4
5
echo "你的密码" | gpg --batch --passphrase-fd 0 -c -o backup.gpg backup.tar.gz
# 后续脚本可自动使用缓存的密码（无需手动输入）
gpg --batch -c -o backup.gpg backup.tar.gz✅ 优点：比硬编码密码更安全，但仍依赖
gpg-agent会话。
方法 3：使用密钥文件（更安全）
2
3
4
5
6
7
8
9
echo "你的密码" > ~/.backup_password
chmod 600 ~/.backup_password
# 加密时读取密码文件
gpg -c --batch --passphrase-file ~/.backup_password -o backup.gpg backup.tar.gz
# 解密同理
gpg -d --batch --passphrase-file ~/.backup_password -o backup.tar.gz backup.gpg✅ 优点：密码不直接暴露在脚本中。
⚠ 注意：确保~/.backup_password仅限当前用户可读（chmod 600）。生成无密码 SSH 密钥（如果还没生成）
-N ""表示不设密码（确保脚本能自动运行）。- 生成的密钥：
- 私钥:
~/.ssh/id_rsa_backup（本地使用，绝不能泄露！）- 公钥:
~/.ssh/id_rsa_backup.pub（上传到远程服务器）
2. 上传公钥到远程服务器
- 作用：自动把你的公钥（
id_rsa_backup.pub）添加到远程服务器的~/.ssh/authorized_keys文件。- 执行后，下次 SSH 登录（或
rsync）时，远程服务器会信任你的本地机器，不再要求密码。
3. 测试免密登录
- 如果直接进入远程服务器终端（不提示输入密码），说明配置成功！
- 你的
rsync命令现在也能免密运行了。
设置脚本权限
1 | chmod +x /usr/local/bin/backup_home.sh |
配置每日定时任务(每天凌晨2点运行)
1 | crontab -e # sudo select-editor 可以设置默认编辑器 |
增量备份：使用 –link-dest 参数创建硬链接到前一天的备份，只复制变化的文件
保留策略：脚本会自动删除7天前的备份
日志记录：所有操作记录到 /var/log/backup_home.log
安全删除：–delete 参数确保目标删除源已删除的文件
- –link-dest 的真正工作原理
这个方案使用的是”硬链接式增量备份”，不是简单的文件复制。关键点在于：每次备份都是完整的：每个 daily.日期 目录看起来都包含完整的 /home 数据
实际存储的是差异：通过硬链接，未修改的文件只占用一个物理存储空间
不删除基础数据：7天前的备份被删除时，只有真正独有的文件会被删除
2. 存储空间如何工作
举例说明7天的备份情况：/backup/home/
├── daily.20231001 (完整备份)
├── daily.20231002 (链接到20231001的未修改文件 + 新修改的文件)
├── …
└── daily.20231007 (链接到前一天的未修改文件 + 新修改的文件)
当删除 daily.20231001 时：只有 20231001 独有的文件(后来被修改过的)会被真正删除
其他文件仍被后续备份引用，不会删除
3. 为什么这不是您担心的”删除全量只剩增量”
因为：每个备份目录看起来都是完整的
物理存储上，多个备份共享相同的未修改文件(通过硬链接)
删除旧备份时，系统会自动维护引用计数，只有真正不被任何备份引用的文件才会被删除
恢复数据
要恢复某天的备份，只需复制相应日期的备份目录即可：
1 | cp -a /backup/home/daily.20231001/* /home/ |
crontab
2
sudo systemctl restart crond # CentOS/RHEL在
cron中，时间调度是通过 5 个时间字段来控制的，格式如下：
你可以通过调整这些字段来精确控制任务的执行时间，比如 每小时、每天、每周、每月、每年，甚至是 特定日期 或 间隔时间。
📌 1. 基本时间设置
(1) 每小时运行一次
- 示例：
0 * * * * /usr/local/bin/backup.sh- 效果：00:00, 01:00, 02:00, …, 23:00 各运行一次
(2) 每天固定时间运行
- 示例：
30 3 * * * /usr/local/bin/cleanup.sh- 效果：每天 3:30 运行
(3) 每周固定时间运行
星期字段
：
0或7= 周日1= 周一2= 周二- …
6= 周六示例：
0 20 * * 1 /usr/local/bin/weekly_report.sh效果：每周一晚上 8 点运行
(4) 每月 1 号运行
- 示例：
0 0 1 * * /usr/local/bin/monthly_backup.sh- 效果：每月 1 号凌晨运行
(5) 每年 1 月 1 日运行
- 示例：
0 0 1 1 * /usr/local/bin/yearly_reset.sh- 效果：每年元旦凌晨运行
📌 2. 高级时间设置
(6) 每隔 N 分钟/小时运行
2
0 */2 * * * /path/to/command # 每 2 小时运行一次
示例
：
*/5 * * * * /usr/local/bin/monitor.sh（每 5 分钟运行）0 */6 * * * /usr/local/bin/check_logs.sh（每 6 小时运行）
(7) 特定时间范围运行
- 示例：
0 9-17 * * 1-5 /usr/local/bin/office_hours_task.sh- 效果：工作日 9:00, 10:00, …, 17:00 各运行一次
(8) 特定日期和时间运行
- 示例：
30 16 15 * * /usr/local/bin/payroll.sh- 效果：每月 15 号下午 4:30 运行
📌 3. 特殊用法
(9) 多个时间点
- 示例：
0 8,12,18 * * * /usr/local/bin/notify.sh- 效果：每天 3 个固定时间运行
(10) 随机延迟（避免任务堆积）
- 示例：
$(($RANDOM \% 10)) * * * * /usr/local/bin/random_task.sh- 效果：每小时随机时间运行，避免服务器负载高峰
📌 4. 如何编辑 Cron 任务？
(1) 查看当前用户的 Cron 任务
(2) 编辑 Cron 任务
- 按格式添加任务，保存退出即可生效。
(3) 删除所有 Cron 任务
📌 5. 注意事项
环境变量问题
Cron 默认不加载~/.bashrc或/etc/profile，如果脚本依赖PATH等变量，建议在脚本开头设置：
2
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin日志记录
建议在脚本中记录运行状态：
权限问题
确保脚本有执行权限：
🎯 总结
需求 Cron 表达式 示例 每小时 0 * * * *0 * * * * /usr/local/bin/hourly_task.sh每天 30 3 * * *30 3 * * * /usr/local/bin/daily_backup.sh每周 0 20 * * 10 20 * * 1 /usr/local/bin/weekly_report.sh每月 0 0 1 * *0 0 1 * * /usr/local/bin/monthly_cleanup.sh每年 0 0 1 1 *0 0 1 1 * /usr/local/bin/yearly_reset.sh每 15 分钟 */15 * * * **/15 * * * * /usr/local/bin/monitor.sh工作日 9-17 点每小时 0 9-17 * * 1-50 9-17 * * 1-5 /usr/local/bin/office_task.sh每月 15 号 16:30 30 16 15 * *30 16 15 * * /usr/local/bin/payroll.sh
如果文件数量很多（几万甚至更多），使用
rsync默认的单线程传输可能会比较慢。可以采用 多线程加速 的方法来提高传输效率：
方案 1：使用
rsync+parallel多线程传输
parallel是一个强大的并行工具，可以配合rsync实现多线程传输。安装
parallel（如果未安装）
2
sudo yum install parallel # CentOS/RHEL多线程同步命令
2
find . -type f | parallel -j 8 rsync -azP {} root@192.168.6.3:/mnt/docker-data/alist/local-storage/pixiv/{}参数说明
-j 8：使用 8 个并行任务（可根据 CPU 和网络调整）{}：parallel会自动替换为文件名rsync -azP：保持权限、压缩传输、显示进度优化
- 如果文件很大，可以改用
-J（按行分割任务）：
- 如果文件名包含特殊字符（空格、中文等），改用
-0（NULL 分隔）：
方案 2：使用
fpart+rsync分块并行
fpart可以按文件大小或数量分块，再并行传输。安装
fpart
2
sudo yum install fpart # CentOS/RHEL分块并行传输
2
3
4
5
6
7
8
9
# 1. 生成文件列表
find . -type f > filelist.txt
# 2. 分块（每块最多 1000 个文件）
fpart -f 1000 -o chunks filelist.txt
# 3. 并行传输（8线程）
find chunks.* | parallel -j 8 rsync -azP --files-from={} . root@192.168.6.3:/mnt/docker-data/alist/local-storage/pixiv/
方案 3：使用
rsync+--bwlimit限速（避免带宽占满）如果网络带宽有限，可以限制
rsync的传输速度：
--bwlimit=10M：限制最大带宽为 10MB/s（可调整）
方案 4：使用
lftp（支持多线程 FTP/SFTP）如果
rsync仍然较慢，可以改用lftp，它原生支持多线程传输：
-P 8：使用 8 个线程-R：递归上传（mirror默认是下载，-R改为上传）
总结
方法 适用场景 优点 缺点 rsync + parallel大量小文件 灵活控制线程数 文件名需处理 fpart + rsync超大文件集 自动分块 依赖 fpartrsync --bwlimit限速传输 防止带宽占满 单线程 lftpSFTP/FTP 传输 原生多线程 非增量同步 如果你的文件数量极多（>10万），推荐
fpart + rsync或lftp。
如果是普通几万文件，rsync + parallel足够高效。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来源 YuKiFuHaNeの博客！
相关推荐
2026-05-28
SSH 隧道完全指南
目录 SSH 隧道基础概念什么是 SSH 隧道？SSH 隧道（SSH Tunnel）是一种通过 SSH 协议建立的安全网络连接通道。它允许你通过一个安全的 SSH 连接来传输其他协议的数据，就像建立了一条”地下通道”。 12你的电脑 ←→ [SSH 隧道] ←→ 目标服务器 安全加密连接 各种服务（数据库、Web等） 为什么需要 SSH 隧道？ 安全性：所有数据都通过 SSH 加密传输 访问受限资源：绕过防火墙或网络限制 跳板机访问：通过中间服务器访问最终目标 本地化远程服务：让远程服务看起来像本地服务 工作原理123应用程序 → 本地端口 → SSH 隧道 → 远程端口 → 目标服务 ↓ ↓ ↓ ↓ ↓ 数据库客户端 → 3306 → SSH加密传输 → 22 → 远程数据库:3306 SSH 隧道类型详解1. 本地端口转发（Local Port Forwarding）概念：将本地端口的流量转发到远程服务器的指定端口。 流量走法:本地–>远程（端口本地监听，流量...
2025-05-16
多线程快速解压缩、删除与监视大型文件
使用pigz加速gzip压缩和解压pigz是一个用于加速gzip压缩和解压的工具，它可以利用多核心来并行处理数据。它与标准的gzip命令完全兼容，只是更快。以下是如何使用pigz来加速.tar.gz文件的解压过程的步骤： 安装pigz： 如果还没有安装pigz，可以使用包管理器来安装。例如在Ubuntu上： 12sudo apt-get updatesudo apt-get install pigz 多线程压缩：使用tar命令结合pigz开压缩文件，-p保持所有者权限 1tar --use-compress-program=pigz -cvpf youfile.tar.gz yourfile 多线程解压： 使用tar命令结合pigz来解压.tar.gz文件。为了解压rk_android13.0_sdk.tar.gz，可以使用以下命令： 1tar xf rk_android13.0_sdk.tar.gz --use-compress-program=pigz 这个命令会使用所有可用的CPU核心来解压文件。如果想限制使用的核心数，可以使用-p选项。例如，使用24个...
2023-08-19
Git使用与配置
Git配置 /etc/gitconfig 文件：系统中对所有用户都普遍适用的配置。若使用 git config 时用 --system 选项，读写的就是这个文件。 ~/.gitconfig 文件：用户目录下的配置文件只适用于该用户。若使用 git config 时用 --global 选项，读写的就是这个文件。 当前项目的 Git 目录中的配置文件（也就是工作目录中的 .git/config 文件）：这里的配置仅仅针对当前项目有效。每一个级别的配置都会覆盖上层的相同配置，所以 .git/config 里的配置会覆盖 /etc/gitconfig 中的同名变量。 配置用户信息12$ git config --global user.name "your_name"$ git config --global user.email your_email 如果用了 –global 选项，那么更改的配置文件就是位于你用户主目录下的那个，以后你所有的项目都会默认使用这里配置的用户信息。 如果要在某个特定的项目中使用其他名字或者电邮，只要去掉 –global 选项重新...
2024-01-28
GNU Screen 终端会话管理详解
一、背景 系统管理员经常需要SSH 或者telent 远程登录到Linux 服务器，经常运行一些需要很长时间才能完成的任务，比如系统备份、ftp 传输等等。通常情况下我们都是为每一个这样的任务开一个远程终端窗口，因为它们执行的时间太长了。必须等待它们执行完毕，在此期间不能关掉窗口或者断开连接，否则这个任务就会被杀掉，一切半途而废了。 二、简介 GNU Screen是一款由GNU计划开发的用于命令行终端切换的自由软件。用户可以通过该软件同时连接多个本地或远程的命令行会话，并在其间自由切换。 GNU Screen可以看作是窗口管理器的命令行界面版本。它提供了统一的管理多个会话的界面和相应的功能。 会话恢复 多窗口 会话共享 GNU’s Screen 官方站点：http://www.gnu.org/software/screen/ 三、语法 # screen [-AmRvx -ls -wipe][-d <作业名称>][-h <行数>][-r <作业名称>][-s ][-S <作业名称>] 参数说明 -A 将所有的视窗都调整为目...
2023-07-14
Hydra 概述
Hydra概述Hydra是一款由著名的黑客组织THC开发的开源暴力破解工具，支持大部分协议的在线密码破解，是网络安全·渗透测试必备的一款工具。安装方法：Kali中自带hydra,直接搜索关键字即可。 参数详解在Kali的命令行中输入hydra -h即可查看hydra 的所有参数 具体的参数含义见下表： 参数名 参数含义 -l ： 指定破解的用户，对特定用户破解 -L 指定用户名字典 -p 小写，指定密码破解，少用，一般是采用密码字典 -P 大写，指定密码字典 -R 继续从上一次进度接着破解 -S 大写，采用SSL链接 -s 小写，可通过这个参数指定非默认端口 -e 可选选项，n：空密码试探，s：使用指定用户和密码试探 -t 同时运行的线程数，默认为16 -C 使用冒号分割格式，例如“登录名:密码”来代替 -L/-P 参数 -M 指定目标列表文件一行一条 -o 指定结果输出文件 -f 在使用-M参数以后，找到第一对登录名或者密码的时候中止破解 -w 设置最大超时的时间，单位秒，默认是30s -v ...
2024-03-18
python-crontab 定时任务
安装1pip install python-crontab 注意：如果在使用CronTab的时候报错，报错信息为 got an unexpected keyword argument ‘user’ 可能是库安装错了，应该安装python-crontab而不是crontab。 使用案例 增加crontab任务，一般有两种方式 123456789101112131415161718192021222324from crontab import CronTab# 方法一# 创建cron访问cron = CronTab(user='root')# 增加新作业job = cron.new(command='echo hello_world')# 每一分钟执行一次job.minute.every(1)# 写入作业cron.write()# 方法二with CronTab(user='root') as cron: job = cron.new(command='echo hello_world') ...
