实现自动备份宝塔项目及数据库到本地

需求说明

• 服务器：Ubuntu 24；管理面板：宝塔面板；本地系统：Windows 11
• 宝塔面板上部署了多个项目（php/node等），也有多个数据库。我现在需要将宝塔面板上的项目文件和数据库进行备份并同步至我本地进行保存

实现方案

第一步：宝塔设置自动备份

操作路径：宝塔面板 - 计划任务 - 添加任务

• 任务类型：备份网站（或者备份目录（/www/wwwroot整个目录））、备份数据库
• 执行周期：每天 x时x分钟执行一次（建议凌晨进行备份）
• 备份网站：选择备份的网站（建议所有网站）；保留最新 3 份；备份路径：/www/backup
• 备份目录：选择备份目录（/www/wwwroot）；保留最新 3 份；备份路径（默认，不可设置）：/www/backup
• 备份数据库：选择数据库（建议所有数据库）；保留最新 3 份；备份路径：/www/backup

网站备份保存目录：

• /www/backup/site
• 会根据对应网站名建立对应文件夹，里面就是对应网站的备份文件，如：web_wslink_20260408_013241_xPFlaL.tar.gz

目录备份保存目录：

• /www/backup/path
• 会根据对应目录名建立对应文件夹，里面就是对应目录的备份文件，如：path_wwwroot_20260408_012648_rJZMSG.tar.gz

数据库备份保存目录：

• /www/backup/database/mysql/crontab_backup
• 会根据对应数据库名建立对应文件夹，里面就是对应数据库的备份文件，如：wslink_2026-04-08_01-26-44_mysql_data.sql.gz

第二步：自动同步到本地电脑

Node + SFTP + schtasks

1/ 宝塔设置ssh安全及密钥

路径：宝塔面板 - 安全 - SSH管理

SSH服务：开启

SSH基础设置：

• SSH密码登录：开启
• SSH密钥登录：开启
• SSH端口：默认22，也可以自定义

Root设置：

• Root密码登录设置：视情况自行选择
• Root密码：设置强密码
• Root密钥：下载（将文件保存到脚本根目录下）

2/ 创建项目目录

BT-Backupd/
bt-sync/
|-- backup.js
|-- jsconfig.json
|-- package.json
|-- package-lock.json
|-- certificate/
|   `-- 180.131.145.178_id_ed25519
`-- node_modules/

目录说明

• BT-Backupd 备份保存目录
• backup.js 主脚本。负责建立 SFTP 连接、递归列出远程目录并下载文件。
• certificate/ 存放 SSH 私钥。当前脚本会读取 certificate/180.131.145.178_id_ed25519。
• jsconfig.json JS 项目配置，已关闭 JS 文件的 TypeScript 校验。
• package.json 项目依赖和脚本配置。
• node_modules/ 已安装的运行依赖。

3/ 脚本开发

1、进入bt-sync

npm init -y
npm install ssh2-sftp-client

2、创建脚本 backup.js

// backup.js
const Client = require("ssh2-sftp-client");
const fs = require("fs");
const path = require("path");

const sftp = new Client();

const config = {
    host: "你的服务器ip",
    port: 22,
    username: "root",
    privateKey: fs.readFileSync(
        path.join(__dirname, "certificate", "你的服务器ip_id_ed25519")
    ),
};

const remoteDir = "/www/backup/";
const backupRootDir = path.join(__dirname, "..", "BT-Backups");
// 保留的历史备份数量，超过这个数量的备份将被删除。设置为 0 或负数表示不删除任何备份。
const retentionCount = 5;

// 备份时要包含的路径列表（相对于 remoteDir）。
// 如果为空，则下载整个 remoteDir。
const includePaths = [
    "database",
    "path",
    "site",
];

function formatBackupDirName(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, "0");
    const day = String(date.getDate()).padStart(2, "0");
    const hours = String(date.getHours()).padStart(2, "0");
    const minutes = String(date.getMinutes()).padStart(2, "0");
    const seconds = String(date.getSeconds()).padStart(2, "0");

    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
}

const currentBackupDir = path.join(
    backupRootDir,
    formatBackupDirName(new Date())
);
const logFile = path.join(currentBackupDir, "backup.log");

function log(message) {
    const line = `[${new Date().toLocaleString()}] ${message}\n`;
    fs.appendFileSync(logFile, line, "utf8");
    console.log(message);
}

function ensureDir(dir) {
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
    }
}

function cleanupOldBackups() {
    if (retentionCount <= 0) {
        log("已跳过历史备份清理，retentionCount 小于等于 0");
        return;
    }

    const backupDirs = fs
        .readdirSync(backupRootDir, { withFileTypes: true })
        .filter((entry) => entry.isDirectory())
        .map((entry) => entry.name)
        .sort((a, b) => b.localeCompare(a, "en"));

    const expiredDirs = backupDirs.slice(retentionCount);

    for (const dirName of expiredDirs) {
        const targetDir = path.join(backupRootDir, dirName);

        if (path.dirname(targetDir) !== backupRootDir) {
            log(`跳过异常目录: ${targetDir}`);
            continue;
        }

        fs.rmSync(targetDir, { recursive: true, force: true });
        log(`已删除旧备份: ${targetDir}`);
    }
}

async function downloadDir(remotePath, localPath) {
    ensureDir(localPath);

    const items = await sftp.list(remotePath);
    for (const item of items) {
        const remoteItem = remotePath.endsWith("/")
            ? remotePath + item.name
            : remotePath + "/" + item.name;
        const localItem = path.join(localPath, item.name);

        if (item.type === "d") {
            await downloadDir(remoteItem, localItem);
        } else {
            log(`下载文件: ${remoteItem} -> ${localItem}`);
            await sftp.fastGet(remoteItem, localItem);
        }
    }
}

function normalizeRemotePath(targetPath) {
    return targetPath.replace(/\\/g, "/").replace(/\/+$/, "");
}

function resolveRemotePath(targetPath) {
    const normalizedBase = normalizeRemotePath(remoteDir);
    const normalizedTarget = normalizeRemotePath(targetPath);

    if (normalizedTarget.startsWith("/")) {
        return normalizedTarget;
    }

    return `${normalizedBase}/${normalizedTarget}`;
}

function resolveLocalPath(remotePath) {
    const normalizedBase = `${normalizeRemotePath(remoteDir)}/`;
    const normalizedRemotePath = normalizeRemotePath(remotePath);
    const relativePath = normalizedRemotePath.startsWith(normalizedBase)
        ? normalizedRemotePath.slice(normalizedBase.length)
        : path.posix.basename(normalizedRemotePath);

    return path.join(currentBackupDir, ...relativePath.split("/"));
}

async function downloadTarget(targetPath) {
    const remotePath = resolveRemotePath(targetPath);
    const localPath = resolveLocalPath(remotePath);
    const exists = await sftp.exists(remotePath);

    if (!exists) {
        log(`跳过不存在的路径: ${remotePath}`);
        return;
    }

    if (exists === "d") {
        log(`下载目录: ${remotePath} -> ${localPath}`);
        await downloadDir(remotePath, localPath);
        return;
    }

    ensureDir(path.dirname(localPath));
    log(`下载文件: ${remotePath} -> ${localPath}`);
    await sftp.fastGet(remotePath, localPath);
}

async function main() {
    ensureDir(backupRootDir);
    ensureDir(currentBackupDir);

    try {
        log("开始连接服务器...");
        await sftp.connect(config);

        if (includePaths.length > 0) {
            log(`开始按白名单同步，共 ${includePaths.length} 项`);
            for (const includePath of includePaths) {
                await downloadTarget(includePath);
            }
        } else {
            log("开始全量同步目录...");
            await downloadDir(remoteDir, currentBackupDir);
        }

        log(`同步完成，本地目录: ${currentBackupDir}`);
        cleanupOldBackups();
    } catch (err) {
        log(`发生错误: ${err.message}`);
        process.exitCode = 1;
    } finally {
        await sftp.end();
    }
}

main();