脚本概述
该脚本用于在生产环境中对超大规模 MongoDB 数据库进行自动化备份，目标存储为网络存储（NAS/NFS/SMB/SAN 等）。方案基于在副本集的隐藏/次级节点上执行逻辑备份（mongodump），并实现以下能力：
- 通过 mongodump 使用 secondary 读优先，避免影响主节点性能
- 归档输出为单一 archive 文件，使用 pigz 并行压缩，提高压缩速度
- 可选启用 AES-256-GCM 加密，确保传输与存储安全
- 将备份从本地暂存目录可靠同步至网络存储，含断点续传与重试机制
- 写入校验和与备份清单（manifest），进行完整性校验
- 自动保留/清理过期备份（可配置）
- 提供日志记录、错误处理、退出码、Slack 告警（可选）
- 输出 Prometheus 文本指标（可选），便于备份监控
适用场景：
- 超大数据集（very_large），可接受较长恢复时间（RTO：days）
- 有副本集架构，允许在隐藏/次级节点执行备份
- 使用网络存储作为归档保存位置
环境要求
- 操作系统：Linux（推荐）
- 软件依赖：
- MongoDB Database Tools（mongodump）版本 100+（与集群版本匹配）
- Python 3.9+（脚本执行环境）
- pigz（并行压缩，无则自动回退到 gzip）
- OpenSSL 1.1+（可选，用于 AES-256-GCM 加密）
- rsync（可靠网络文件同步）
- curl（可选，发送 Slack Webhook）
- 网络存储：
- 已挂载到本机的持久路径（例如 /mnt/backup/mongodb），支持读写
- 具备足够空间与吞吐能力
- MongoDB 拓扑：
- 副本集：建议在隐藏次级节点或备份专用从节点上执行
- 分片集群：请使用 mongos 连接备份所有数据库，注意 --oplog 在 mongos 场景不适用（详见注意事项）
核心代码
以下为完整可执行的 Python 备份脚本。保存为 mongodb_backup.py 并赋予执行权限。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import argparse
import datetime
import hashlib
import json
import logging
import os
import shutil
import signal
import socket
import subprocess
import sys
import time
from pathlib import Path
# ---------------------------
# Utility functions
# ---------------------------
def run_cmd(cmd, env=None, timeout=None, retries=0, backoff_sec=5, cwd=None, log_output=True):
"""Run a shell command with retries and return (rc, stdout, stderr)."""
attempt = 0
last_stdout = ""
last_stderr = ""
while True:
try:
proc = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
cwd=cwd,
text=True
)
try:
stdout, stderr = proc.communicate(timeout=timeout)
except subprocess.TimeoutExpired:
proc.kill()
stdout, stderr = proc.communicate()
raise RuntimeError(f"Command timeout: {' '.join(cmd)}")
rc = proc.returncode
if log_output:
if stdout:
logging.debug(stdout)
if stderr:
logging.debug(stderr)
if rc == 0:
return rc, stdout, stderr
else:
last_stdout, last_stderr = stdout, stderr
attempt += 1
if attempt > retries:
return rc, last_stdout, last_stderr
sleep = backoff_sec * attempt
logging.warning(f"Command failed (rc={rc}), retry {attempt}/{retries} in {sleep}s: {' '.join(cmd)}")
time.sleep(sleep)
except Exception as e:
last_stderr = str(e)
attempt += 1
if attempt > retries:
return 1, "", last_stderr
sleep = backoff_sec * attempt
logging.warning(f"Command exception, retry {attempt}/{retries} in {sleep}s: {e}")
time.sleep(sleep)
def which(bin_name):
rc, out, _ = run_cmd(["bash", "-lc", f"command -v {bin_name}"], log_output=False)
return out.strip() if rc == 0 and out.strip() else None
def compute_sha256(file_path, buf_size=64 * 1024 * 1024):
h = hashlib.sha256()
with open(file_path, "rb") as f:
while True:
data = f.read(buf_size)
if not data:
break
h.update(data)
return h.hexdigest()
def bytes_human(n):
for unit in ["B", "KB", "MB", "GB", "TB", "PB"]:
if n < 1024.0:
return f"{n:.2f}{unit}"
n /= 1024.0
def ensure_dir(path: Path):
path.mkdir(parents=True, exist_ok=True)
def now_iso():
return datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).isoformat()
def cpu_count():
try:
import multiprocessing
return multiprocessing.cpu_count()
except:
return 4
def send_slack(webhook, text):
if not webhook:
return
payload = json.dumps({"text": text})
run_cmd(["curl", "-sS", "-X", "POST", "-H", "Content-type: application/json", "--data", payload, webhook], log_output=False)
def write_prometheus_metrics(textfile_dir, metrics):
"""metrics is dict: name -> value"""
if not textfile_dir:
return
ensure_dir(Path(textfile_dir))
fname = Path(textfile_dir) / "mongodb_backup.prom"
lines = []
for k, v in metrics.items():
lines.append(f"{k} {v}")
try:
tmp = fname.with_suffix(".tmp")
with open(tmp, "w") as f:
f.write("\n".join(lines) + "\n")
os.replace(tmp, fname)
except Exception as e:
logging.warning(f"Failed to write Prometheus textfile: {e}")
# ---------------------------
# Backup process
# ---------------------------
def preflight_checks(args):
# Tools
for bin in ["mongodump", "rsync"]:
if not which(bin):
raise RuntimeError(f"Required binary not found in PATH: {bin}")
# Check mongodump version
rc, out, err = run_cmd(["mongodump", "--version"], log_output=False)
if rc != 0:
raise RuntimeError(f"mongodump not working: {err}")
logging.info(out.strip())
# Compression tool check
pigz_bin = which("pigz")
gzip_bin = which("gzip")
if not pigz_bin and not gzip_bin:
raise RuntimeError("Neither pigz nor gzip found. Please install pigz for performance or gzip.")
if pigz_bin:
logging.info(f"Using pigz for compression: {pigz_bin}")
else:
logging.info(f"Using gzip for compression: {gzip_bin}")
# OpenSSL for encryption (optional but recommended)
if args.encrypt:
openssl_bin = which("openssl")
if not openssl_bin:
raise RuntimeError("Encryption enabled but openssl not found.")
if not args.passphrase and not os.environ.get("BACKUP_PASSPHRASE"):
raise RuntimeError("Encryption enabled but no passphrase provided. Set --passphrase-file or BACKUP_PASSPHRASE.")
logging.info(f"Encryption enabled via openssl: {openssl_bin}")
# Network storage path check
net_root = Path(args.network_target_root)
if not net_root.exists():
raise RuntimeError(f"Network target root does not exist: {net_root}")
if not os.access(net_root, os.W_OK):
raise RuntimeError(f"No write permission to network target root: {net_root}")
# Local staging path
ensure_dir(Path(args.local_staging_root))
def build_mongodump_cmd(args, archive_path: Path):
cmd = [
"mongodump",
"--uri", args.mongo_uri,
"--readPreference=secondary",
"--archive=" + str(archive_path),
"--numParallelCollections", str(args.num_parallel),
"--quiet"
]
if args.oplog:
cmd.append("--oplog")
if args.tls:
cmd.append("--tls")
if args.tlsCAFile:
cmd += ["--tlsCAFile", args.tlsCAFile]
if args.tlsCertificateKeyFile:
cmd += ["--tlsCertificateKeyFile", args.tlsCertificateKeyFile]
if args.exclude_collections_with_prefix:
for p in args.exclude_collections_with_prefix:
cmd += ["--excludeCollectionsWithPrefix", p]
if args.db:
cmd += ["--db", args.db]
return cmd
def compress_file(src_path: Path, threads: int):
pigz_bin = which("pigz")
if pigz_bin:
cmd = [pigz_bin, "-f", f"-p{threads}", str(src_path)]
rc, _, err = run_cmd(cmd, retries=1)
if rc != 0:
raise RuntimeError(f"pigz compression failed: {err}")
return src_path.with_suffix(src_path.suffix + ".gz")
else:
gzip_bin = which("gzip")
cmd = [gzip_bin, "-f", str(src_path)]
rc, _, err = run_cmd(cmd, retries=1)
if rc != 0:
raise RuntimeError(f"gzip compression failed: {err}")
return src_path.with_suffix(src_path.suffix + ".gz")
def encrypt_file(src_path: Path, passphrase: str):
# AES-256-GCM with PBKDF2
openssl_bin = which("openssl")
dst = src_path.with_suffix(src_path.suffix + ".enc")
env = os.environ.copy()
env["BACKUP_PASSPHRASE"] = passphrase
cmd = [
openssl_bin, "enc",
"-aes-256-gcm",
"-salt",
"-pbkdf2",
"-pass", "env:BACKUP_PASSPHRASE",
"-in", str(src_path),
"-out", str(dst)
]
rc, _, err = run_cmd(cmd, env=env, retries=1)
if rc != 0:
raise RuntimeError(f"Encryption failed: {err}")
return dst
def rsync_upload(src_path: Path, dst_path: Path):
ensure_dir(dst_path.parent)
cmd = [
"rsync",
"-a",
"--partial",
"--inplace",
"--checksum",
"--info=progress2",
str(src_path),
str(dst_path)
]
rc, _, err = run_cmd(cmd, retries=3, backoff_sec=10)
if rc != 0:
raise RuntimeError(f"rsync upload failed: {err}")
def enforce_retention(target_root: Path, retention_days: int, name_prefix: str):
cutoff = time.time() - retention_days * 86400
removed = []
for item in target_root.glob(f"{name_prefix}-*.manifest.json"):
try:
ts_str = item.stem.replace(f"{name_prefix}-", "").replace(".manifest", "")
# Example: name-20250101T011500Z.manifest.json
# We'll parse robustly: find YYYYMMDDTHHMMSSZ in the stem
parts = item.stem.split("-")
ts_part = parts[-1].replace(".manifest", "")
# Fallback to file mtime if parse fails
mtime = item.stat().st_mtime
if mtime < cutoff:
# Remove manifest and associated files
base = item.stem.replace(".manifest", "")
for suffix in [".archive", ".archive.gz", ".archive.gz.enc", ".sha256"]:
f = target_root / f"{base}{suffix}"
if f.exists():
f.unlink(missing_ok=True)
item.unlink(missing_ok=True)
removed.append(item.name)
except Exception:
continue
if removed:
logging.info(f"Retention cleanup removed: {removed}")
def main():
parser = argparse.ArgumentParser(description="MongoDB automated backup script (logical backup with mongodump)")
parser.add_argument("--mongo-uri", default=os.environ.get("MONGO_URI"), required=True, help="MongoDB connection URI (use secondary/hidden node)")
parser.add_argument("--db", default=None, help="Backup specific database (default: all)")
parser.add_argument("--oplog", action="store_true", default=True, help="Include oplog for consistent snapshot (replica set only)")
parser.add_argument("--tls", action="store_true", default=False, help="Enable TLS")
parser.add_argument("--tlsCAFile", default=os.environ.get("TLS_CA_FILE"), help="TLS CA file")
parser.add_argument("--tlsCertificateKeyFile", default=os.environ.get("TLS_CERT_KEY_FILE"), help="TLS client cert+key")
parser.add_argument("--exclude-collections-with-prefix", nargs="*", default=["system.", "config.system.sessions"], help="Exclude collections with prefix")
parser.add_argument("--local-staging-root", default=os.environ.get("LOCAL_STAGING_ROOT", "/var/backups/mongodb"), help="Local staging directory")
parser.add_argument("--network-target-root", default=os.environ.get("NETWORK_TARGET_ROOT", "/mnt/backup/mongodb"), help="Network storage mount directory")
parser.add_argument("--name-prefix", default=os.environ.get("BACKUP_NAME_PREFIX", socket.gethostname() + "-mongodb"), help="Prefix for backup files")
parser.add_argument("--num-parallel", type=int, default=int(os.environ.get("NUM_PARALLEL", max(4, min(8, cpu_count())))), help="numParallelCollections for mongodump")
parser.add_argument("--threads", type=int, default=int(os.environ.get("COMPRESS_THREADS", max(4, cpu_count()))), help="Compression threads for pigz")
parser.add_argument("--encrypt", action="store_true", default=os.environ.get("ENCRYPT", "true").lower() in ("1", "true", "yes"), help="Enable encryption")
parser.add_argument("--passphrase-file", default=os.environ.get("BACKUP_PASSPHRASE_FILE"), help="File containing encryption passphrase")
parser.add_argument("--retention-days", type=int, default=int(os.environ.get("RETENTION_DAYS", "30")), help="Retention in days")
parser.add_argument("--slack-webhook", default=os.environ.get("SLACK_WEBHOOK_URL"), help="Slack webhook URL for notifications")
parser.add_argument("--prom-textfile-dir", default=os.environ.get("PROM_TEXTFILE_DIR"), help="Prometheus node_exporter textfile dir")
parser.add_argument("--log-file", default=os.environ.get("BACKUP_LOG_FILE"), help="Log file path")
parser.add_argument("--debug", action="store_true", help="Enable debug logging")
args = parser.parse_args()
# Logging setup
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(
level=log_level,
format="%(asctime)s %(levelname)s %(message)s",
handlers=[
logging.StreamHandler(sys.stdout),
]
)
if args.log_file:
fh = logging.FileHandler(args.log_file)
fh.setLevel(log_level)
fh.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
logging.getLogger().addHandler(fh)
# Signal handling for graceful shutdown
def handle_signal(signum, frame):
logging.error(f"Received signal {signum}, aborting.")
sys.exit(2)
signal.signal(signal.SIGINT, handle_signal)
signal.signal(signal.SIGTERM, handle_signal)
started_at = time.time()
manifest = {
"started_at": now_iso(),
"host": socket.gethostname(),
"mongo_uri_redacted": "<redacted>",
"name_prefix": args.name_prefix,
"oplog": args.oplog,
"tls": args.tls,
"num_parallel_collections": args.num_parallel,
"compress_threads": args.threads,
"encrypt": args.encrypt,
"retention_days": args.retention_days,
"status": "running"
}
# Preflight
try:
preflight_checks(args)
except Exception as e:
logging.error(f"Preflight checks failed: {e}")
send_slack(args.slack_webhook, f":x: MongoDB backup preflight failed on {socket.gethostname()}: {e}")
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 1,
"mongodb_backup_last_duration_seconds": 0,
"mongodb_backup_last_size_bytes": 0,
"mongodb_backup_last_success_timestamp": 0
})
sys.exit(1)
# Prepare paths
timestamp = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
base_name = f"{args.name_prefix}-{timestamp}"
staging_root = Path(args.local_staging_root)
ensure_dir(staging_root)
archive_path = staging_root / f"{base_name}.archive"
compressed_path = None
encrypted_path = None
sha256_local = None
# Obtain passphrase if encryption enabled
passphrase = None
if args.encrypt:
if args.passphrase_file and Path(args.passphrase_file).exists():
passphrase = Path(args.passphrase_file).read_text().strip()
else:
passphrase = os.environ.get("BACKUP_PASSPHRASE")
if not passphrase:
logging.error("Encryption enabled but passphrase not provided.")
sys.exit(1)
# Run mongodump
try:
dump_cmd = build_mongodump_cmd(args, archive_path)
manifest["dump_cmd"] = " ".join(dump_cmd[:-2]) + " --archive=<redacted>"
logging.info(f"Running mongodump to archive: {archive_path}")
rc, stdout, stderr = run_cmd(dump_cmd, retries=1, backoff_sec=10)
if rc != 0:
raise RuntimeError(f"mongodump failed: {stderr}")
manifest["dump_stdout_tail"] = stdout[-2048:] if stdout else ""
# Size before compression
size_archive = archive_path.stat().st_size
manifest["size_archive_bytes"] = size_archive
logging.info(f"Dump archive size: {bytes_human(size_archive)}")
except Exception as e:
logging.error(f"Backup failed during mongodump: {e}")
send_slack(args.slack_webhook, f":x: MongoDB backup failed (mongodump) on {socket.gethostname()}: {e}")
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 2,
"mongodb_backup_last_duration_seconds": int(time.time() - started_at),
"mongodb_backup_last_size_bytes": 0,
"mongodb_backup_last_success_timestamp": 0
})
sys.exit(2)
# Compress
try:
logging.info("Compressing archive with pigz/gzip...")
compressed_path = compress_file(archive_path, args.threads)
size_compressed = compressed_path.stat().st_size
manifest["size_compressed_bytes"] = size_compressed
logging.info(f"Compressed size: {bytes_human(size_compressed)}")
except Exception as e:
logging.error(f"Compression failed: {e}")
send_slack(args.slack_webhook, f":x: MongoDB backup failed (compression) on {socket.gethostname()}: {e}")
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 3,
"mongodb_backup_last_duration_seconds": int(time.time() - started_at),
"mongodb_backup_last_size_bytes": 0,
"mongodb_backup_last_success_timestamp": 0
})
sys.exit(3)
# Encrypt (optional)
final_local_path = compressed_path
try:
if args.encrypt:
logging.info("Encrypting compressed archive with AES-256-GCM...")
encrypted_path = encrypt_file(compressed_path, passphrase)
# Remove plaintext compressed file after successful encryption
try:
compressed_path.unlink()
except Exception:
pass
final_local_path = encrypted_path
size_encrypted = final_local_path.stat().st_size
manifest["size_encrypted_bytes"] = size_encrypted
logging.info(f"Encrypted size: {bytes_human(size_encrypted)}")
except Exception as e:
logging.error(f"Encryption failed: {e}")
send_slack(args.slack_webhook, f":x: MongoDB backup failed (encryption) on {socket.gethostname()}: {e}")
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 4,
"mongodb_backup_last_duration_seconds": int(time.time() - started_at),
"mongodb_backup_last_size_bytes": 0,
"mongodb_backup_last_success_timestamp": 0
})
sys.exit(4)
# Checksum
try:
logging.info("Computing SHA256 checksum...")
sha256_local = compute_sha256(final_local_path)
sha_file = final_local_path.with_suffix(final_local_path.suffix + ".sha256")
sha_file.write_text(sha256_local + " " + final_local_path.name + "\n")
manifest["sha256"] = sha256_local
except Exception as e:
logging.error(f"Checksum computation failed: {e}")
send_slack(args.slack_webhook, f":warning: MongoDB backup checksum failed on {socket.gethostname()}: {e}")
# Upload to network storage
network_target_root = Path(args.network_target_root)
final_name = final_local_path.name
remote_path = network_target_root / final_name
remote_sha_path = network_target_root / (final_local_path.name + ".sha256")
try:
logging.info(f"Uploading to network storage: {remote_path}")
rsync_upload(final_local_path, remote_path)
rsync_upload(final_local_path.with_suffix(final_local_path.suffix + ".sha256"), remote_sha_path)
except Exception as e:
logging.error(f"Upload failed: {e}")
send_slack(args.slack_webhook, f":x: MongoDB backup upload failed on {socket.gethostname()}: {e}")
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 5,
"mongodb_backup_last_duration_seconds": int(time.time() - started_at),
"mongodb_backup_last_size_bytes": 0,
"mongodb_backup_last_success_timestamp": 0
})
sys.exit(5)
# Verify checksum on remote (mount must be POSIX-accessible)
try:
logging.info("Verifying remote checksum...")
sha_remote = compute_sha256(remote_path)
if sha256_local and sha_remote != sha256_local:
raise RuntimeError(f"Checksum mismatch: local {sha256_local} vs remote {sha_remote}")
logging.info("Checksum verified.")
except Exception as e:
logging.error(f"Remote checksum verification failed: {e}")
send_slack(args.slack_webhook, f":warning: MongoDB backup checksum verify failed on {socket.gethostname()}: {e}")
# Write manifest to network storage
manifest["finished_at"] = now_iso()
manifest["status"] = "success"
manifest["duration_seconds"] = int(time.time() - started_at)
manifest["final_file"] = remote_path.name
try:
manifest_path = network_target_root / f"{args.name_prefix}-{timestamp}.manifest.json"
manifest_path.write_text(json.dumps(manifest, indent=2))
logging.info(f"Manifest written: {manifest_path}")
except Exception as e:
logging.warning(f"Failed to write manifest: {e}")
# Retention
try:
enforce_retention(network_target_root, args.retention_days, args.name_prefix)
except Exception as e:
logging.warning(f"Retention cleanup failed: {e}")
# Metrics & notify
write_prometheus_metrics(args.prom_textfile_dir, {
"mongodb_backup_last_exit_status": 0,
"mongodb_backup_last_duration_seconds": manifest.get("duration_seconds", 0),
"mongodb_backup_last_size_bytes": Path(remote_path).stat().st_size if remote_path.exists() else 0,
"mongodb_backup_last_success_timestamp": int(time.time())
})
send_slack(args.slack_webhook, f":white_check_mark: MongoDB backup succeeded on {socket.gethostname()} "
f"({bytes_human(Path(remote_path).stat().st_size)} in {manifest.get('duration_seconds', 0)}s) -> {remote_path}")
# Cleanup local staging
try:
for p in [final_local_path, final_local_path.with_suffix(final_local_path.suffix + ".sha256")]:
if p.exists():
p.unlink(missing_ok=True)
logging.info("Local staging cleaned up.")
except Exception as e:
logging.warning(f"Local cleanup failed: {e}")
if __name__ == "__main__":
main()
配置说明
- 环境变量（推荐用法，避免在脚本中硬编码敏感信息）：
- MONGO_URI：MongoDB 连接字符串（建议指向隐藏/次级节点，包含 replicaSet 和 readPreference=secondary）
- TLS_CA_FILE、TLS_CERT_KEY_FILE：TLS 证书文件路径（如启用 TLS）
- LOCAL_STAGING_ROOT：本地暂存目录（默认 /var/backups/mongodb）
- NETWORK_TARGET_ROOT：网络存储挂载目录（默认 /mnt/backup/mongodb）
- BACKUP_NAME_PREFIX：备份名前缀（默认 hostname-mongodb）
- NUM_PARALLEL：mongodump 并行集合数（默认 4~8，依据 CPU）
- COMPRESS_THREADS：pigz 压缩线程数（默认 CPU 核心数）
- ENCRYPT：启用加密（默认 true）
- BACKUP_PASSPHRASE 或 BACKUP_PASSPHRASE_FILE：加密口令或口令文件路径（文件权限需 600）
- RETENTION_DAYS：保留周期（默认 30）
- SLACK_WEBHOOK_URL：Slack Webhook（可选）
- PROM_TEXTFILE_DIR：Prometheus node_exporter 文本指标目录（可选，如 /var/lib/node_exporter/textfile_collector）
- BACKUP_LOG_FILE：日志文件路径（可选）
- 关键参数说明：
- --oplog：默认开启，在副本集上确保一致性快照。若通过 mongos 连接分片集群，此参数不适用（请关闭）。
- --exclude-collections-with-prefix：默认排除系统集合前缀，避免不必要内容。
- 加密：压缩后再加密（AES-256-GCM），不在脚本内硬编码口令，建议从环境变量或安全的只读文件获取。
- 保留策略：按天清理旧备份，仅删除 manifest 及对应归档文件，保留策略可按合规要求调整。
使用指南
- 准备依赖：
- 安装 MongoDB Database Tools（mongodump）
- 安装 pigz、openssl、rsync、curl
- 确认网络存储路径已挂载（例如 /mnt/backup/mongodb）
- 创建备份用户（只读角色），并在隐藏/次级节点上执行备份：
- 在 MongoDB 创建一个具备必要只读权限的用户，避免使用高权限账户
- 部署脚本：
- 将上述代码保存为 /opt/mongo-backup/mongodb_backup.py
- chmod +x /opt/mongo-backup/mongodb_backup.py
- 配置环境变量（示例）：
- 在 /etc/mongo-backup.env 写入：
- 运行一次手动备份测试：
- source /etc/mongo-backup.env
- /opt/mongo-backup/mongodb_backup.py --debug
- 检查网络存储目录中生成的 .enc、.sha256、.manifest.json 文件，确认大小和校验值
- 设置定时任务（RTO 为 days，建议每日离峰时段执行一次全量逻辑备份；如数据极其庞大可调整为每周全量+每日轻量验证任务）：
- crontab 示例（每日 01:15 执行）：
- 15 1 * * * . /etc/mongo-backup.env && /opt/mongo-backup/mongodb_backup.py >> /var/log/mongo-backup.cron.log 2>&1
- 恢复演练（建议至少每季度一次）：
- 使用 mongorestore 从网络存储读取归档解密与解压后恢复至测试环境：
- openssl enc -d -aes-256-gcm -pbkdf2 -pass env:BACKUP_PASSPHRASE -in backup.archive.gz.enc -out backup.archive.gz
- gunzip backup.archive.gz
- mongorestore --archive=backup.archive --nsInclude 'db.*' --drop
- 若使用 --oplog 进行一致性快照，确保 mongorestore 时拥有 --oplogReplay 或对应流程（注意与集群版本匹配）
注意事项
- 性能与影响：
- 严格在隐藏/次级节点执行备份，避免对主节点和生产业务造成影响
- 控制 --numParallelCollections 与压缩线程数，避免压垮备份节点的 IO/CPU
- 一致性：
- 副本集备份建议启用 --oplog，以获取一致性快照
- 分片集群若通过 mongos 备份，--oplog 不适用；需要更高级的分片一致性备份方案（如官方备份服务或经验证的第三方工具）
- 安全性：
- 不在脚本中硬编码凭据与密钥；通过环境变量或受限文件读取
- 必须启用加密存储（本脚本支持 AES-256-GCM），防止网络存储数据泄露
- 网络存储建议使用专用备份网络与访问控制列表
- 合规与保留：
- 保留周期需符合公司与监管要求；超期清理前需经过审批与审计
- 备份文件命名与 manifest 便于审计追踪
- 恢复与验证：
- 定期进行恢复演练与校验，确保备份可用、流程可重复
- 监控指标与告警（Slack）应纳入统一监控体系
- 版本兼容：
- 保持 mongodump 版本与 MongoDB 服务器兼容；升级前进行评估与测试
如需根据具体拓扑（例如多分片、巨量集合、冷热数据分层）进行进一步优化，可提供详细集群信息，我将为你定制更精细的分片一致性备份与分级存储策略。
