bash <(wget -qO- https://xuanyuan.cloud/docker.sh)

# 拉取 6.0.18 穩定版（指定patch版本，避免版本漂移，適合開發/生產）
docker pull docker.xuanyuan.run/library/mongo:6.0.18

# （可選）將鏡像改名為官方標準名稱
docker tag docker.xuanyuan.run/library/mongo:6.0.18 mongo:6.0.18
# 刪除臨時鏡像標籤，釋放空間
docker rmi docker.xuanyuan.run/library/mongo:6.0.18

# 直接拉取 Docker Hub 官方鏡像（指定patch版本）
docker pull mongo:6.0.18

REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
mongo        6.0.18    d3ad5c1a1b22   5 days ago     700MB

# 提示：請勿在生產環境直接明文寫密碼，建議使用系統環境變量
# 示例：先導出環境變量 export MONGO_ROOT_PWD=$(openssl rand -base64 16)
docker run -d \
  --name mongo-dev \          # 容器名稱（自定義，如 mongo-test）
  -e MONGO_INITDB_ROOT_USERNAME=admin \  # 初始化 root 用户名（必填，避免無密碼風險）
  -e MONGO_INITDB_ROOT_PASSWORD=${MONGO_ROOT_PWD:-ReplaceWithStrongRandomPwd!} \  # 優先使用系統環境變量，強制提示替換強密碼
  -v mongo-data:/data/db \    # 持久化數據（用 Docker named volume，避免權限問題）
  -p 27017:27017 \            # 開發環境映射端口，生產環境請刪除此行
  --memory=4g \               # 資源限制：最大使用4G內存
  --cpus=2 \                  # 資源限制：最大使用2核CPU
  --restart unless-stopped \  # 容器異常時自動重啓（開發/生產均推薦）
  --health-cmd "mongosh --eval 'db.runCommand({ping:1})' --quiet" \  # 健康檢查：檢測MongoDB可用性
  --health-interval=30s \     # 每30秒檢查一次
  --health-timeout=5s \       # 檢查超時時間5秒
  --health-retries=3 \        # 連續3次失敗標記為不健康
  mongo:6.0.18                # 鏡像名稱:指定patch版本，避免版本漂移

# 在 docker-compose.yml 同級目錄創建 .env 文件
# 提示：1. 替換為強隨機密碼（推薦用 openssl rand -base64 16 生成）
#      2. 添加 .env 到 .gitignore，避免提交到版本庫
#      3. 定期更換密碼並備份該文件
MONGO_INITDB_ROOT_USERNAME=admin
MONGO_INITDB_ROOT_PASSWORD=ReplaceWithStrongRandomPwd2024!
MONGO_INITDB_DATABASE=myappdb
MONGO_APP_USER=appuser
MONGO_APP_PASSWORD=AppUserStrongPwd2024!
MONGO_MEMORY_LIMIT=4g
MONGO_CPU_LIMIT=2

version: "3.8"  # 兼容主流 Docker Compose v2.x 版本
services:
  mongo:
    image: mongo:6.0.18  # 指定patch版本，避免版本漂移
    container_name: mongo-dev
    env_file:
      - .env  # 引用 .env 文件，加載敏感環境變量，避免明文泄露
    volumes:
      - mongo-data:/data/db
      - ./initdb:/docker-entrypoint-initdb.d:ro  # 初始化腳本掛載（ro：只讀，安全）
    # 生產環境請刪除以下 ports 配置，禁止公網暴露端口
    ports:
      - "27017:27017"
    restart: unless-stopped  # 自動重啓策略（生產環境可改為 always）
    mem_limit: ${MONGO_MEMORY_LIMIT}  # 從 .env 加載內存限制
    cpus: ${MONGO_CPU_LIMIT}          # 從 .env 加載CPU限制
    healthcheck:  # 健康檢查（生產環境必須啓用）
      test: ["CMD", "mongosh", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 10s  # 容器啓動後10秒再開始檢查

# 聲明 named volume（無需手動創建，Docker 會自動初始化）
volumes:
  mongo-data:

# 開發環境覆蓋配置，與 docker-compose.yml 同級目錄
# 生產環境部署時，可通過 -f 指定主配置，忽略該文件：docker compose -f docker-compose.yml up -d
version: "3.8"
services:
  mongo:
    # 開發環境額外映射端口、開啓調試日誌
    ports:
      - "27017:27017"
    command: ["mongod", "--verbose"]  # 開啓詳細日誌，便於開發調試

# 在 docker-compose.yml 所在目錄執行
docker compose up -d

# 查看容器運行狀態（健康狀態顯示 healthy 即為正常）
docker ps | grep mongo-dev

# 替換為你的用户名和密碼
mongosh "mongodb://admin:ReplaceWithStrongRandomPwd2024!@localhost:27017/admin"

# 替換為你的密碼
docker exec -it mongo-dev mongosh -u admin -p ReplaceWithStrongRandomPwd2024! --authenticationDatabase admin

# 在 docker-compose.yml 所在目錄創建 initdb 文件夾
mkdir -p initdb
# 創建初始化腳本（用 vim 或記事本編輯，新手可複製內容）
vim initdb/01-create-app-user-and-index.js

try {
  // 從容器環境變量中讀取業務用户配置（避免明文硬編碼）
  const appUser = process.env.MONGO_APP_USER;
  const appPwd = process.env.MONGO_APP_PASSWORD;
  const targetDbName = process.env.MONGO_INITDB_DATABASE || "myappdb";

  // 校驗環境變量是否存在
  if (!appUser || !appPwd) {
    throw new Error("業務用户配置缺失：請在 .env 中設置 MONGO_APP_USER 和 MONGO_APP_PASSWORD");
  }

  // 切換到預創建的業務數據庫
  const targetDb = db.getSiblingDB(targetDbName);

  // 檢查業務用户是否已存在，避免重複創建報錯
  const existingUser = targetDb.getUser(appUser);
  if (existingUser) {
    print(`業務用户 ${appUser} 已存在，無需重複創建`);
    return;
  }

  // 創建業務用户（僅授予 targetDbName 的讀寫權限，遵循最小權限原則）
  targetDb.createUser({
    user: appUser,
    pwd: appPwd,
    roles: [
      { role: "readWrite", db: targetDbName }  // 僅授予業務數據庫讀寫權限，禁止root權限
    ]
  });
  print(`業務用户 ${appUser} 創建成功`);

  // 創建常用索引（優化查詢性能，生產環境必備）
  // 示例1：用户表按手機號創建唯一索引
  const userCollection = targetDb.createCollection("users");
  userCollection.createIndex({ phone: 1 }, { unique: true, background: true });
  print("用户表 phone 唯一索引創建成功");

  // 示例2：日誌表按時間戳創建索引
  const logCollection = targetDb.createCollection("operation_logs");
  logCollection.createIndex({ createTime: -1 }, { background: true });
  print("日誌表 createTime 倒序索引創建成功");

  // （可選）插入測試數據
  const insertResult = targetDb.testCollection.insertOne({ 
    name: "MongoDB_Init_Test", 
    time: new Date(),
    status: "success"
  });
  if (insertResult.insertedId) {
    print(`測試數據插入成功，ID：${insertResult.insertedId}`);
  } else {
    print("測試數據插入失敗");
  }
} catch (err) {
  print(`初始化腳本執行異常：${err.message}`);
  // 拋出異常，讓容器啓動失敗，便於發現問題
  throw err;
}

volumes:
  - mongo-data:/data/db
  - ./initdb:/docker-entrypoint-initdb.d:ro  # 已掛載，無需重複修改

# 警告：-v 參數會刪除 mongo-data 數據卷，清空所有原有數據！
# 僅首次執行初始化腳本時使用，已有業務數據請勿執行此命令
docker compose down -v  
# 重新啓動容器，執行初始化腳本
docker compose up -d

# 方式1：容器內用業務用户連接測試
docker exec -it mongo-dev mongosh -u ${MONGO_APP_USER} -p ${MONGO_APP_PASSWORD} --authenticationDatabase myappdb
# 查看測試數據（若輸出插入的文檔，説明腳本生效）
db.testCollection.find().pretty();
# 查看索引（驗證索引創建成功）
db.users.getIndexes();
db.operation_logs.getIndexes();

# 方式2：檢查腳本執行日誌（排查失敗原因）
docker logs mongo-dev | grep -E "appuser|MongoDB_Init_Test|索引創建成功"

# 1. 定義帶時間戳的備份目錄
BACKUP_TIMESTAMP=$(date +%F-%H%M%S)
HOST_BACKUP_DIR="/backup/mongo/${BACKUP_TIMESTAMP}"
mkdir -p ${HOST_BACKUP_DIR}

# 2. 容器內執行壓縮備份（gzip 壓縮，減少存儲佔用）
docker exec -it mongo-dev bash -c "
  mongodump --uri='mongodb://admin:ReplaceWithStrongRandomPwd2024!@localhost:27017' \
    --gzip \  # 啓用 gzip 壓縮
    --out /tmp/backup_${BACKUP_TIMESTAMP}
"

# 3. 複製壓縮備份到宿主機，並對齊 UID/GID（避免權限無法訪問）
docker cp mongo-dev:/tmp/backup_${BACKUP_TIMESTAMP} ${HOST_BACKUP_DIR}
chown -R $(id -u):$(id -g) ${HOST_BACKUP_DIR}  # 對齊宿主機當前用户權限
echo "壓縮備份完成，存儲路徑：${HOST_BACKUP_DIR}"

# 4. 刪除容器內臨時備份
docker exec -it mongo-dev rm -rf /tmp/backup_${BACKUP_TIMESTAMP}

# 前提：僅副本集支持增量備份（單節點無 oplog 完整日誌）
# 1. 先執行一次全量備份，記錄 oplog 時間點
FULL_BACKUP_DIR="/backup/mongo/full-$(date +%F)"
mkdir -p ${FULL_BACKUP_DIR}
docker exec -it mongo1 mongosh -u admin -p ReplaceWithStrongRandomPwd2024! --authenticationDatabase admin --eval '
  var backupTimestamp = new Date();
  printjson({ fullBackupTime: backupTimestamp, ts: db.getReplicationInfo().latestOpTime.ts });
' > ${FULL_BACKUP_DIR}/backup-meta.json

# 2. 執行全量備份
docker exec -it mongo1 bash -c "
  mongodump --uri='mongodb://admin:ReplaceWithStrongRandomPwd2024!@localhost:27017' \
    --gzip \
    --out /tmp/full-backup \
    --oplog  # 記錄備份期間的 oplog
"
docker cp mongo1:/tmp/full-backup ${FULL_BACKUP_DIR}
chown -R $(id -u):$(id -g) ${FULL_BACKUP_DIR}

# 3. 增量備份（基於上次全量備份的 oplog 時間點）
INCR_BACKUP_DIR="/backup/mongo/incr-$(date +%F-%H%M%S)"
mkdir -p ${INCR_BACKUP_DIR}
docker exec -it mongo1 bash -c "
  mongodump --uri='mongodb://admin:ReplaceWithStrongRandomPwd2024!@localhost:27017' \
    --gzip \
    --out /tmp/incr-backup \
    --oplogReplay \  # 重放 oplog 實現增量備份
    --sinceTimestamp $(cat ${FULL_BACKUP_DIR}/backup-meta.json | grep ts | awk -F ':' '{print $2}' | tr -d ' ,')
"
docker cp mongo1:/tmp/incr-backup ${INCR_BACKUP_DIR}
chown -R $(id -u):$(id -g) ${INCR_BACKUP_DIR}
echo "增量備份完成，存儲路徑：${INCR_BACKUP_DIR}"

# 替換為你的備份目錄（帶時間戳）
BACKUP_DIR="/backup/mongo/2024-10-01-143000"
# 恢復前建議停止業務服務，避免數據寫入衝突
mongorestore --uri="mongodb://admin:ReplaceWithStrongRandomPwd2024!@localhost:27017" \
  --gzip \  # 若備份時啓用壓縮，恢復時需指定
  ${BACKUP_DIR}
echo "數據恢復完成"

# 3節點副本集（無仲裁節點，推薦生產使用）
┌─────────────┐     寫請求     ┌─────────────┐
│  客户端     ├───────────────>│  Primary    │
│             │                │  (mongo1)   │
└─────────────┘                └──────┬──────┘
       ▲                             │
       │ 讀請求（secondaryPreferred） │ 數據同步
       │                             │
┌──────┴──────┐                ┌──────▼──────┐
│ Secondary 1 │<───────────────│ Secondary 2 │
│ (mongo2)    │                │ (mongo3)    │
└─────────────┘                └─────────────┘
# 故障轉移：當 mongo1 宕機後，mongo2/mongo3 自動選舉新主節點，客户端無縫切換

version: "3.8"
# 自定義 Docker 網絡，用於副本集節點內部通信（無需依賴端口映射）
networks:
  mongo-net:
    driver: bridge  # 單機部署使用 bridge 網絡，跨主機使用 overlay 網絡

services:
  # 主節點（初始，後續自動選舉）
  mongo1:
    image: mongo:6.0.18
    container_name: mongo1
    command: ["mongod", "--replSet", "rs0", "--bind_ip_all"]  # --replSet 指定副本集名稱 rs0
    ports: ["27017:27017"]  # 開發環境映射，生產環境刪除
    volumes: ["mongo1-data:/data/db"]
    restart: unless-stopped
    networks: [mongo-net]  # 加入自定義內部網絡
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3

  # 從節點1
  mongo2:
    image: mongo:6.0.18
    container_name: mongo2
    command: ["mongod", "--replSet", "rs0", "--bind_ip_all"]
    ports: ["27018:27017"]  # 開發環境映射，生產環境刪除
    volumes: ["mongo2-data:/data/db"]
    restart: unless-stopped
    networks: [mongo-net]
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3

  # 從節點2
  mongo3:
    image: mongo:6.0.18
    container_name: mongo3
    command: ["mongod", "--replSet", "rs0", "--bind_ip_all"]
    ports: ["27019:27017"]  # 開發環境映射，生產環境刪除
    volumes: ["mongo3-data:/data/db"]
    restart: unless-stopped
    networks: [mongo-net]
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3

volumes:
  mongo1-data:
  mongo2-data:
  mongo3-data:

docker compose -f docker-compose-replica-basic.yml up -d

# 等待所有節點健康運行（約10秒）
sleep 10
# 進入 mongo1 容器，執行初始化命令
docker exec -it mongo1 mongosh --eval '
  rs.initiate({
    _id: "rs0",  # 副本集名稱，需與 command 中 --replSet 一致
    members: [
      { _id: 0, host: "mongo1:27017" },  # 節點1（容器名:端口，內部網絡通信）
      { _id: 1, host: "mongo2:27017" },  # 節點2
      { _id: 2, host: "mongo3:27017" }   # 節點3
    ]
  })
'

# 進入 mongo1，查看副本集狀態
docker exec -it mongo1 mongosh
# 執行命令查看狀態（"stateStr" 為 "PRIMARY" 的是主節點，"SECONDARY" 是從節點）
rs.status()

# 1. 創建 keyfile 存儲目錄
mkdir -p mongo-keyfile
# 2. 生成 keyfile（256位隨機字符串，MongoDB 要求）
openssl rand -base64 756 > mongo-keyfile/keyfile
# 3. 設置權限為 600（MongoDB 強制要求，否則節點啓動失敗）
chmod 600 mongo-keyfile/keyfile
# 4. （Linux/Mac）修改所屬用户（避免容器內權限問題）
chown 999:999 mongo-keyfile/keyfile  # 999 是 mongo 容器內默認用户ID

# 方式1：生成自簽名證書（僅測試環境使用，生產環境請使用 CA 簽發證書）
mkdir -p mongo-tls
openssl req -x509 -newkey rsa:4096 -days 365 -nodes \
  -keyout mongo-tls/mongo.key \
  -out mongo-tls/mongo.crt \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=MyCompany/OU=IT/CN=mongo.rs0.local"

# 設置證書權限
chmod 600 mongo-tls/mongo.key
chown 999:999 mongo-tls/mongo.key mongo-tls/mongo.crt

# 方式2：生產環境掛載 CA 簽發證書（將證書放入 mongo-tls 目錄即可，無需重新生成）

version: "3.8"
networks:
  mongo-net:
    driver: bridge  # 跨主機部署時改為 overlay 網絡（需 Docker Swarm/K8s）

services:
  mongo1:
    image: mongo:6.0.18
    container_name: mongo1
    command: [
      "mongod", 
      "--replSet", "rs0", 
      "--bind_ip_all", 
      "--keyFile", "/etc/mongo-keyfile/keyfile",  # 掛載 keyfile
      "--authorization", "enabled",  # 啓用認證
      "--sslMode", "requireSSL",  # 強制啓用 TLS/SSL 加密
      "--sslPEMKeyFile", "/etc/mongo-tls/mongo.crt",  # 證書（含公鑰+私鑰）
      "--sslCAFile", "/etc/mongo-tls/mongo.crt",  # CA 證書（自簽名證書與服務端證書一致）
      "--sslAllowInvalidCertificates"  # 測試環境允許無效證書（生產環境刪除此行）
    ]
    volumes:
      - mongo1-data:/data/db
      - ./mongo-keyfile:/etc/mongo-keyfile:ro  # 只讀掛載 keyfile 目錄
      - ./mongo-tls:/etc/mongo-tls:ro  # 只讀掛載 TLS/SSL 證書目錄
    restart: always
    networks: [mongo-net]
    mem_limit: 8g
    cpus: 4
    healthcheck:
      test: ["CMD", "mongosh", "-u", "admin", "-p", "${MONGO_ROOT_PASSWORD}", "--ssl", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3
    env_file:
      - .env.prod

  mongo2:
    image: mongo:6.0.18
    container_name: mongo2
    command: [
      "mongod", 
      "--replSet", "rs0", 
      "--bind_ip_all", 
      "--keyFile", "/etc/mongo-keyfile/keyfile",
      "--authorization", "enabled",
      "--sslMode", "requireSSL",
      "--sslPEMKeyFile", "/etc/mongo-tls/mongo.crt",
      "--sslCAFile", "/etc/mongo-tls/mongo.crt",
      "--sslAllowInvalidCertificates"  # 測試環境刪除，生產環境保留CA驗證
    ]
    volumes:
      - mongo2-data:/data/db
      - ./mongo-keyfile:/etc/mongo-keyfile:ro
      - ./mongo-tls:/etc/mongo-tls:ro
    restart: always
    networks: [mongo-net]
    mem_limit: 8g
    cpus: 4
    healthcheck:
      test: ["CMD", "mongosh", "-u", "admin", "-p", "${MONGO_ROOT_PASSWORD}", "--ssl", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3
    env_file:
      - .env.prod

  mongo3:
    image: mongo:6.0.18
    container_name: mongo3
    command: [
      "mongod", 
      "--replSet", "rs0", 
      "--bind_ip_all", 
      "--keyFile", "/etc/mongo-keyfile/keyfile",
      "--authorization", "enabled",
      "--sslMode", "requireSSL",
      "--sslPEMKeyFile", "/etc/mongo-tls/mongo.crt",
      "--sslCAFile", "/etc/mongo-tls/mongo.crt",
      "--sslAllowInvalidCertificates"  # 測試環境刪除，生產環境保留CA驗證
    ]
    volumes:
      - mongo3-data:/data/db
      - ./mongo-keyfile:/etc/mongo-keyfile:ro
      - ./mongo-tls:/etc/mongo-tls:ro
    restart: always
    networks: [mongo-net]
    mem_limit: 8g
    cpus: 4
    healthcheck:
      test: ["CMD", "mongosh", "-u", "admin", "-p", "${MONGO_ROOT_PASSWORD}", "--ssl", "--eval", "db.runCommand({ping:1})", "--quiet"]
      interval: 30s
      timeout: 5s
      retries: 3
    env_file:
      - .env.prod

volumes:
  mongo1-data:
  mongo2-data:
  mongo3-data:

MONGO_INITDB_ROOT_USERNAME=admin
MONGO_ROOT_PASSWORD=ReplaceWithStrongRandomPwd2024!  # 用 openssl rand -base64 16 生成
MONGO_INITDB_DATABASE=admin
MONGO_APP_USER=appuser
MONGO_APP_PASSWORD=AppUserStrongPwd2024!

# 1. 啓動容器
docker compose -f docker-compose-replica-prod.yml up -d
# 2. 等待節點健康運行
sleep 10
# 3. 初始化副本集（啓用 keyfile 認證+SSL）
docker exec -it mongo1 mongosh -u admin -p ReplaceWithStrongRandomPwd2024! --authenticationDatabase admin --ssl --eval '
  rs.initiate({
    _id: "rs0",
    keyFile: "/etc/mongo-keyfile/keyfile",  # 指定 keyfile 路徑
    members: [
      { _id: 0, host: "mongo1:27017" },
      { _id: 1, host: "mongo2:27017" },
      { _id: 2, host: "mongo3:27017" }
    ]
  })
'
# 4. 驗證副本集狀態
docker exec -it mongo1 mongosh -u admin -p ReplaceWithStrongRandomPwd2024! --authenticationDatabase admin --ssl
rs.status()

# 添加 crontab 定時任務（每天凌晨 2 點執行壓縮備份）
crontab -e
# 寫入以下內容
0 2 * * * /bin/bash /backup/mongo-backup-script.sh >> /var/log/mongo-backup.log 2>&1

docker run -d \
  --name mongo-exporter \
  --net mongo-net \
  -e MONGODB_URI="mongodb://admin:ReplaceWithStrongPwd!@mongo1:27017?ssl=true" \
  prom/mongodb-exporter:latest

scrape_configs:
  - job_name: 'mongodb'
    static_configs:
      - targets: ['mongo-exporter:9216']

# 複製此文件為 .env，修改為實際配置
# 生成強密碼命令：openssl rand -base64 16
MONGO_INITDB_ROOT_USERNAME=admin
MONGO_INITDB_ROOT_PASSWORD=ReplaceWithStrongRandomPwd2024!
MONGO_INITDB_DATABASE=myappdb
MONGO_APP_USER=appuser
MONGO_APP_PASSWORD=AppUserStrongPwd2024!
MONGO_MEMORY_LIMIT=4g
MONGO_CPU_LIMIT=2

# 生產環境環境變量模板
MONGO_INITDB_ROOT_USERNAME=admin
MONGO_ROOT_PASSWORD=ReplaceWithStrongRandomPwd2024!
MONGO_INITDB_DATABASE=admin
MONGO_APP_USER=appuser
MONGO_APP_PASSWORD=AppUserStrongPwd2024!
MONGO_MEMORY_LIMIT=8g
MONGO_CPU_LIMIT=4