以下是 MongoDB 自动化脚本安装方案，安装方式：
本文提供五个脚本 安装脚本 状态检查脚本 服务管理脚本 独立用户账号生成脚本 生成集合案例脚本 ；无法直接添加附件
📦 MongoDB 一键安装脚本
脚本功能：
-
✅ 支持 MongoDB 6.0 版本选择
-
✅ 官方仓库和发行版仓库安装
-
✅ 自动安全配置和认证
-
✅ 性能优化配置
-
✅ 备份和监控脚本
🔧 完整安装脚本
1.安装后可以直接；
2.已修复重启服务器， /var/run/mongodb/mongod.pid丢失无法启动问题；
3.包含账号密码生成 默认未开启认证，需要可自行开启或运行独立脚本（账号生成）；
bash
#!/bin/bash
# MongoDB 自动化安装脚本
# 支持 Ubuntu, CentOS, RHEL, Debian 等主流 Linux 发行版
set -e
# 配置参数
MONGO_VERSION="${1:-"6.0"}" # MongoDB 版本
MONGO_PORT="${2:-"27017"}" # 服务端口
# MONGO_BIND_IP="${3:-"127.0.0.1"}" # 绑定IP地址
MONGO_BIND_IP="${3:-"0.0.0.0"}" # 绑定IP地址
DATA_DIR="${4:-"/var/lib/mongodb"}" # 数据目录
LOG_DIR="${5:-"/var/log/mongodb"}" # 日志目录
CONFIG_DIR="${6:-"/etc"}" # 配置目录
ADMIN_USER="${7:-"admin"}" # 新增：管理员用户名
ADMIN_PASSWORD="${8:-"admin123"}" # 新增：管理员密码
ENABLE_AUTH="${9:-"no"}" # 新增：是否启用认证
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
# 日志函数
log_info() {
echo -e "${GREEN}[信息]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}
log_warn() {
echo -e "${YELLOW}[警告]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}
log_error() {
echo -e "${RED}[错误]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}
log_step() {
echo -e "${BLUE}[步骤]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}
# 显示使用说明
usage() {
echo "使用方法: $0 [版本] [端口] [绑定IP] [数据目录] [日志目录] [配置目录]"
echo "示例: $0 6.0 27017 0.0.0.0 /data/mongodb /var/log/mongodb /etc"
echo "默认值: $0 6.0 27017 127.0.0.1 /var/lib/mongodb /var/log/mongodb /etc"
exit 1
}
# 显示横幅
show_banner() {
cat << "EOF"
__ __ ____ ____
/ / / /___ ____ ____ _/ __ \ / __ )
/ /_/ / __ \/ __ \/ __ `/ / / // __ |
/ __ / /_/ / / / / /_/ / /_/ // /_/ /
/_/ /_/\____/_/ /_/\__, /_____//_____/
/____/
MongoDB 自动化安装脚本
EOF
}
# 检查 root 权限
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本必须以 root 权限运行"
exit 1
fi
log_info "权限检查通过"
}
# 检测操作系统
detect_os() {
log_step "检测操作系统..."
if [[ -f /etc/os-release ]]; then
source /etc/os-release
OS=$ID
OS_VERSION=$VERSION_ID
log_info "检测到操作系统: $NAME $VERSION"
elif [[ -f /etc/redhat-release ]]; then
OS="centos"
OS_VERSION=$(cat /etc/redhat-release | sed 's/.*release \([0-9]\).*/\1/')
log_info "检测到操作系统: CentOS $OS_VERSION"
else
log_error "无法检测操作系统类型"
exit 1
fi
# 检查架构
ARCH=$(uname -m)
case $ARCH in
x86_64)
log_info "系统架构: x86_64"
;;
aarch64)
log_info "系统架构: ARM64"
;;
*)
log_error "不支持的架构: $ARCH"
exit 1
;;
esac
}
# 安装系统依赖
install_dependencies() {
log_step "安装系统依赖包..."
case $OS in
ubuntu|debian)
apt-get update
apt-get install -y wget gnupg curl apt-transport-https ca-certificates \
software-properties-common lsb-release
;;
centos|rhel|fedora)
yum install -y wget curl epel-release
;;
*)
log_error "不支持的操作系统: $OS"
exit 1
;;
esac
log_info "系统依赖安装完成"
}
# 配置 MongoDB 仓库
setup_repository() {
log_step "配置 MongoDB 官方仓库..."
case $OS in
ubuntu|debian)
# 导入 MongoDB GPG 密钥
wget -qO - https://www.mongodb.org/static/pgp/server-${MONGO_VERSION}.asc | apt-key add -
# 添加仓库
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/${MONGO_VERSION} multiverse" | \
tee /etc/apt/sources.list.d/mongodb-org-${MONGO_VERSION}.list
apt-get update
;;
centos|rhel)
# 创建仓库文件
cat > /etc/yum.repos.d/mongodb-org-${MONGO_VERSION}.repo << EOF
[mongodb-org-${MONGO_VERSION}]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/\$releasever/mongodb-org/${MONGO_VERSION}/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-${MONGO_VERSION}.asc
EOF
;;
fedora)
cat > /etc/yum.repos.d/mongodb-org-${MONGO_VERSION}.repo << EOF
[mongodb-org-${MONGO_VERSION}]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/fedora/\$releasever/mongodb-org/${MONGO_VERSION}/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-${MONGO_VERSION}.asc
EOF
;;
esac
log_info "MongoDB 仓库配置完成"
}
# 安装 MongoDB
install_mongodb() {
log_step "安装 MongoDB 版本 $MONGO_VERSION..."
case $OS in
ubuntu|debian)
apt-get install -y mongodb-org
;;
centos|rhel|fedora)
yum install -y mongodb-org
;;
esac
# 锁定版本，防止意外升级
case $OS in
ubuntu|debian)
echo "mongodb-org hold" | dpkg --set-selections
echo "mongodb-org-server hold" | dpkg --set-selections
echo "mongodb-org-shell hold" | dpkg --set-selections
echo "mongodb-org-mongos hold" | dpkg --set-selections
echo "mongodb-org-tools hold" | dpkg --set-selections
;;
centos|rhel|fedora)
echo "exclude=mongodb-org,mongodb-org-server,mongodb-org-shell,mongodb-org-mongos,mongodb-org-tools" >> /etc/yum.conf
;;
esac
log_info "MongoDB 安装完成"
}
# 创建目录结构
create_directories() {
log_step "创建 MongoDB 目录结构..."
# 创建必要目录
mkdir -p $DATA_DIR
mkdir -p $LOG_DIR
mkdir -p $(dirname $CONFIG_DIR/mongod.conf)
# 创建 MongoDB 用户和组
if ! id "mongodb" &>/dev/null; then
useradd -r -s /bin/false -d $DATA_DIR -M mongodb
log_info "创建 MongoDB 系统用户"
fi
# 设置目录权限
chown -R mongodb:mongodb $DATA_DIR
chown -R mongodb:mongodb $LOG_DIR
chmod 755 $DATA_DIR
chmod 755 $LOG_DIR
log_info "目录结构创建完成:"
log_info " 数据目录: $DATA_DIR"
log_info " 日志目录: $LOG_DIR"
}
# 生成 MongoDB 配置文件
create_config() {
log_step "生成 MongoDB 配置文件..."
local config_file="$CONFIG_DIR/mongod.conf"
# 计算推荐的内存配置 (系统的 50%，最大 2GB)
local total_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
local cache_size_gb=$(echo "scale=1; ($total_mem / 1024 / 1024 * 0.5)" | bc | awk '{if($1>2) print 2; else if($1<0.5) print 0.5; else print $1}')
cat > $config_file << EOF
# MongoDB 配置文件
# 生成时间: $(date)
# 系统日志配置
systemLog:
destination: file
logAppend: true
path: $LOG_DIR/mongod.log
logRotate: reopen
timeStampFormat: iso8601-local
# 存储配置
storage:
dbPath: $DATA_DIR
journal:
enabled: true
wiredTiger:
engineConfig:
cacheSizeGB: $cache_size_gb
journalCompressor: snappy
collectionConfig:
blockCompressor: snappy
indexConfig:
prefixCompression: true
# 网络配置
net:
port: $MONGO_PORT
bindIp: $MONGO_BIND_IP
maxIncomingConnections: 1000
wireObjectCheck: true
ipv6: false
# 进程管理
processManagement:
fork: false
pidFilePath: /var/run/mongodb/mongod.pid
timeZoneInfo: /usr/share/zoneinfo
# 安全配置 (初始安装后请启用)
security:
authorization: disabled
javascriptEnabled: true
# 操作分析配置
operationProfiling:
mode: slowOp
slowOpThresholdMs: 100
slowOpSampleRate: 1.0
# 复制集配置 (可选)
#replication:
# replSetName: rs0
# 分片配置 (可选)
#sharding:
# clusterRole: configsvr|shardsvr
# 审计日志配置 (可选)
#auditLog:
# destination: file
# format: JSON
# path: $LOG_DIR/audit.log
# SNMP 配置 (可选)
#snmp:
# disabled: false
# subagent: true
EOF
chown mongodb:mongodb $config_file
chmod 644 $config_file
log_info "配置文件生成完成: $config_file"
log_info " 绑定地址: $MONGO_BIND_IP"
log_info " 服务端口: $MONGO_PORT"
log_info " 缓存大小: ${cache_size_gb}GB"
}
# 创建 systemd 服务文件
create_systemd_service() {
log_step "创建 systemd 服务配置..."
local service_file="/etc/systemd/system/mongod.service"
cat > $service_file << EOF
[Unit]
Description=MongoDB Database Server
Documentation=https://docs.mongodb.org/manual
After=network.target
Wants=network.target
[Service]
Type=simple
User=mongodb
Group=mongodb
Environment="OPTIONS=-f $CONFIG_DIR/mongod.conf"
ExecStart=/usr/bin/mongod \$OPTIONS
ExecReload=/bin/kill -HUP \$MAINPID
Restart=always
RestartSec=10
StartLimitInterval=60
StartLimitBurst=5
SuccessExitStatus=143
TimeoutStopSec=60
# 确保 PID 目录在启动前创建
ExecStartPre=/bin/mkdir -p /var/run/mongodb
ExecStartPre=/bin/chown mongodb:mongodb /var/run/mongodb
ExecStartPre=/bin/chmod 755 /var/run/mongodb
# 安全配置
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=$DATA_DIR $LOG_DIR
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
log_info "Systemd 服务配置完成"
}
# 配置防火墙
configure_firewall() {
log_step "配置防火墙规则..."
if command -v ufw >/dev/null 2>&1; then
# Ubuntu UFW
ufw allow $MONGO_PORT/tcp comment "MongoDB Service"
log_info "UFW 防火墙已配置，端口 $MONGO_PORT 已开放"
elif command -v firewall-cmd >/dev/null 2>&1; then
# CentOS FirewallD
if systemctl is-active --quiet firewalld; then
firewall-cmd --permanent --add-port=$MONGO_PORT/tcp
firewall-cmd --reload
log_info "FirewallD 已配置，端口 $MONGO_PORT 已开放"
fi
elif command -v iptables >/dev/null 2>&1; then
# iptables
iptables -I INPUT -p tcp --dport $MONGO_PORT -j ACCEPT
log_info "iptables 已配置，端口 $MONGO_PORT 已开放"
else
log_warn "未检测到防火墙工具，请手动开放端口 $MONGO_PORT"
fi
}
# 优化系统配置
optimize_system() {
log_step "优化系统配置..."
# 禁用透明大页
if [[ -f /sys/kernel/mm/transparent_hugepage/enabled ]]; then
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi
# 配置系统限制
if ! grep -q "mongodb" /etc/security/limits.conf; then
cat >> /etc/security/limits.conf << EOF
# MongoDB 系统限制
mongodb soft nproc 64000
mongodb hard nproc 64000
mongodb soft nofile 64000
mongodb hard nofile 64000
mongodb soft nice -20
mongodb hard nice -20
EOF
fi
# 配置系统服务限制
mkdir -p /etc/systemd/system/mongod.service.d/
cat > /etc/systemd/system/mongod.service.d/limits.conf << EOF
[Service]
LimitNOFILE=64000
LimitNPROC=64000
LimitMEMLOCK=infinity
EOF
systemctl daemon-reload
log_info "系统优化完成"
}
# 修复 systemd 服务冲突
fix_service_conflict() {
log_step "检查并修复 systemd 服务冲突..."
# 检查是否存在服务文件冲突
local service_files=(
"/etc/systemd/system/mongod.service"
"/usr/lib/systemd/system/mongod.service"
"/lib/systemd/system/mongod.service"
)
local symlink_locations=(
"/etc/systemd/system/multi-user.target.wants/mongod.service"
)
# 备份并移除冲突的符号链接
for link in "${symlink_locations[@]}"; do
if [[ -L "$link" ]]; then
log_warn "发现冲突的符号链接: $link"
cp "$link" "${link}.backup.$(date +%Y%m%d_%H%M%S)" 2>/dev/null || true
rm -f "$link"
log_info "已移除符号链接: $link"
fi
done
# 重新加载 systemd
systemctl daemon-reload
log_info "systemd 配置已重新加载"
}
# 启动 MongoDB 服务
start_mongodb() {
log_step "启动 MongoDB 服务..."
# 先修复服务冲突
fix_service_conflict
# 创建 PID 文件目录
mkdir -p /var/run/mongodb
chown mongodb:mongodb /var/run/mongodb
# 启动服务
systemctl start mongod
# 检查服务状态
local max_retries=30
local count=0
while [ $count -lt $max_retries ]; do
if systemctl is-active --quiet mongod; then
log_info "MongoDB 服务启动成功"
break
fi
sleep 2
count=$((count + 1))
done
if [ $count -eq $max_retries ]; then
log_error "MongoDB 服务启动失败，请检查日志: $LOG_DIR/mongod.log"
journalctl -u mongod --no-pager -l
exit 1
fi
# 启用开机自启
systemctl enable mongod
log_info "MongoDB 开机自启已启用"
}
# 验证安装
verify_installation() {
log_step "验证 MongoDB 安装..."
# 检查服务状态
if systemctl is-active --quiet mongod; then
log_info "✓ MongoDB 服务运行正常"
else
log_error "✗ MongoDB 服务未运行"
return 1
fi
# 检查端口监听
if netstat -tlnp | grep -q ":$MONGO_PORT "; then
log_info "✓ MongoDB 端口 $MONGO_PORT 监听正常"
else
log_error "✗ MongoDB 端口 $MONGO_PORT 未监听"
return 1
fi
# 测试连接
if command -v mongosh >/dev/null 2>&1; then
if mongosh --port $MONGO_PORT --eval "db.version()" --quiet >/dev/null 2>&1; then
log_info "✓ MongoDB 连接测试成功"
else
log_error "✗ MongoDB 连接测试失败"
return 1
fi
else
if mongo --port $MONGO_PORT --eval "db.version()" --quiet >/dev/null 2>&1; then
log_info "✓ MongoDB 连接测试成功"
else
log_error "✗ MongoDB 连接测试失败"
return 1
fi
fi
log_info "MongoDB 安装验证完成"
return 0
}
# 创建管理员用户
create_admin_user() {
log_step "创建管理员用户..."
local admin_user="${1:-"admin"}"
local admin_password="${2:-"admin123"}"
# 等待 MongoDB 完全启动
sleep 5
# 创建管理员用户
if command -v mongosh >/dev/null 2>&1; then
mongosh --port $MONGO_PORT --eval "
db = db.getSiblingDB('admin');
db.createUser({
user: '$admin_user',
pwd: '$admin_password',
roles: [
{ role: 'root', db: 'admin' },
{ role: 'userAdminAnyDatabase', db: 'admin' },
{ role: 'readWriteAnyDatabase', db: 'admin' }
]
});
" > /dev/null 2>&1
if [ $? -eq 0 ]; then
log_info "管理员用户创建成功"
log_info "用户名: $admin_user"
log_info "密码: $admin_password"
else
log_warn "管理员用户创建失败，可能已存在"
fi
else
log_warn "未找到 mongosh 命令，跳过用户创建"
fi
}
# 启用安全认证
enable_security() {
log_step "启用安全认证..."
local config_file="$CONFIG_DIR/mongod.conf"
# 备份原配置
cp $config_file "${config_file}.backup.$(date +%Y%m%d_%H%M%S)"
# 启用认证
sed -i 's/authorization: disabled/authorization: enabled/' $config_file
# 重启服务使配置生效
systemctl restart mongod
log_info "安全认证已启用，现在需要用户名密码连接"
}
# 显示安装摘要
show_summary() {
log_step "=== 显示MongoDB 安装摘要 ==="
log_info "版本: MongoDB $MONGO_VERSION"
log_info "数据目录: $DATA_DIR"
log_info "日志目录: $LOG_DIR"
log_info "配置文件: $CONFIG_DIR/mongod.conf"
log_info "服务端口: $MONGO_PORT"
log_info "绑定地址: $MONGO_BIND_IP"
log_info "服务状态: $(systemctl is-active mongod)"
log_info "服务管理: systemctl {start|stop|restart|status} mongod"
log_info "日志文件: $LOG_DIR/mongod.log"
log_info "连接命令: mongosh --port $MONGO_PORT"
log_step "========================="
}
# 显示账号密码摘要
show_userpwd() {
log_step "=== 显示MongoDB 创建账号密码信息 ==="
log_info "MongoDB版本: $MONGO_VERSION"
log_info " 监听端口: $MONGO_PORT"
log_info " 服务绑定IP: $MONGO_BIND_IP"
log_info " 管理员账号: $ADMIN_USER"
log_info " 管理员密码: $ADMIN_PASSWORD"
#log_info "连接命令: mongosh --port $MONGO_PORT"
#log_info "连接命令: mysql -h 127.0.0.1 -P $MYSQL_PORT -u root -p$MYSQL_ROOT_PASSWORD"
log_step "========================="
}
# 主安装流程
main() {
show_banner
check_root
detect_os
log_step "开始安装 MongoDB..."
log_info "安装参数:"
log_info " 版本: $MONGO_VERSION"
log_info " 端口: $MONGO_PORT"
log_info " 绑定IP: $MONGO_BIND_IP"
log_info " 数据目录: $DATA_DIR"
# 执行安装步骤
install_dependencies
setup_repository
install_mongodb
create_directories
create_config
create_systemd_service
configure_firewall
optimize_system
start_mongodb
# 验证安装
if verify_installation; then
log_info "🎉 MongoDB 安装成功完成！"
show_summary
else
log_error "MongoDB 安装过程中出现问题"
exit 1
fi
# 创建登录用户和登录密码 若需要修改顶部变量ENABLE_AUTH值为yes,默认是no 不执行
# create_admin_user() # 创建管理员用户 enable_security() # 启用安全认证
if [[ "$ENABLE_AUTH" == "yes" ]]; then
log_info "MongoDB 是否启用认证: $ENABLE_AUTH"
create_admin_user "$ADMIN_USER" "$ADMIN_PASSWORD"
enable_security
show_userpwd
fi
if [[ "$ENABLE_AUTH" == "no" ]]; then
log_info "MongoDB 是否启用认证: $ENABLE_AUTH (未启用认证状态)"
fi
}
# 信号处理
trap 'log_error "安装过程被中断"; exit 1' INT TERM
# 脚本入口
if [[ $# -gt 0 && ($1 == "-h" || $1 == "--help") ]]; then
usage
fi
main🔍 安装执行过程
过程太长 贴部分片段
🔧 账号生成脚本
完整安装脚本中已经包含了 账号密码生成功能， 默认是不启用的，如何安装时需要生成开启即可；
本脚本是独立运行的脚本 ；
bash
#!/bin/bash
# create-mongodb-user.sh - MongoDB 用户创建脚本
set -e
# 默认配置
MONGO_PORT=${1:-"27017"}
ADMIN_USER=${2:-"admin"}
ADMIN_PASSWORD=${3:-"admin123"}
ENABLE_AUTH=${4:-"yes"}
# 颜色定义
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'
log_info() { echo -e "${GREEN}[信息]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[警告]${NC} $1"; }
log_error() { echo -e "${RED}[错误]${NC} $1"; }
create_mongodb_user() {
log_info "开始创建 MongoDB 用户..."
# 检查 MongoDB 是否运行
if ! systemctl is-active mongod >/dev/null 2>&1; then
log_error "MongoDB 服务未运行"
return 1
fi
# 创建用户
log_info "创建管理员用户: $ADMIN_USER"
if command -v mongosh >/dev/null 2>&1; then
mongosh --port $MONGO_PORT --eval "
db = db.getSiblingDB('admin');
try {
db.createUser({
user: '$ADMIN_USER',
pwd: '$ADMIN_PASSWORD',
roles: [
{ role: 'root', db: 'admin' },
{ role: 'userAdminAnyDatabase', db: 'admin' },
{ role: 'readWriteAnyDatabase', db: 'admin' },
{ role: 'dbAdminAnyDatabase', db: 'admin' },
{ role: 'clusterAdmin', db: 'admin' }
]
});
print('用户创建成功');
} catch (e) {
if (e.codeName === 'DuplicateKey') {
print('用户已存在，跳过创建');
} else {
throw e;
}
}
" --quiet
log_info "用户创建完成"
else
log_error "未找到 mongosh 命令"
return 1
fi
# 启用认证（如果要求）
if [[ "$ENABLE_AUTH" == "yes" ]]; then
enable_mongodb_auth
fi
log_info "🎉 MongoDB 用户配置完成！"
echo
log_info "连接信息:"
log_info " 用户名: $ADMIN_USER"
log_info " 密码: $ADMIN_PASSWORD"
log_info " 端口: $MONGO_PORT"
log_info " 连接命令: mongosh -u $ADMIN_USER -p --authenticationDatabase admin --port $MONGO_PORT"
}
enable_mongodb_auth() {
log_info "启用 MongoDB 安全认证..."
local config_file="/etc/mongod.conf"
if [[ ! -f "$config_file" ]]; then
log_error "配置文件不存在: $config_file"
return 1
fi
# 备份配置
cp "$config_file" "${config_file}.backup.$(date +%Y%m%d_%H%M%S)"
# 启用认证
if grep -q "authorization: disabled" "$config_file"; then
sed -i 's/authorization: disabled/authorization: enabled/' "$config_file"
log_info "已启用安全认证"
elif grep -q "authorization: enabled" "$config_file"; then
log_info "安全认证已启用"
else
# 如果不存在 authorization 配置，则添加
if grep -q "security:" "$config_file"; then
sed -i '/security:/a\ authorization: enabled' "$config_file"
else
echo -e "\nsecurity:\n authorization: enabled" >> "$config_file"
fi
log_info "已添加安全认证配置"
fi
# 重启服务
systemctl restart mongod
sleep 3
if systemctl is-active mongod >/dev/null 2>&1; then
log_info "MongoDB 服务重启成功，安全认证已生效"
else
log_error "MongoDB 服务重启失败"
return 1
fi
}
# 显示使用说明
usage() {
echo "使用方法: $0 [端口] [用户名] [密码] [是否启用认证]"
echo "示例: $0 27017 admin admin123 yes"
echo "默认: $0 27017 admin admin123 yes"
exit 1
}
# 主函数
main() {
if [[ $# -gt 0 && ($1 == "-h" || $1 == "--help") ]]; then
usage
fi
create_mongodb_user
}
main "$@"🔧 生成库表案例
MongoDB 初次登录时空的，为了丰满起来 看着友好点 下面生成一些集合数据 。
bash
#!/bin/bash
# init-mongodb-complete-fixed.sh
set -e
MONGO_PORT=${1:-"27017"}
GREEN='\033[0;32m'
BLUE='\033[0;34m'
RED='\033[0;31m'
NC='\033[0m'
log_info() { echo -e "${GREEN}[信息]${NC} $1"; }
log_step() { echo -e "${BLUE}[步骤]${NC} $1"; }
log_error() { echo -e "${RED}[错误]${NC} $1"; }
create_sample_databases() {
log_step "创建示例数据库和集合..."
mongosh --port $MONGO_PORT --eval "
// =============================================
// MongoDB 完整示例数据库初始化
// =============================================
print('=== 开始创建示例数据库 ===');
// 1. 创建电商数据库
print('1. 创建电商数据库...');
db = db.getSiblingDB('ecommerce');
// 用户集合
db.customers.insertMany([
{
customer_id: 'C001',
name: '张三',
email: 'zhangsan@email.com',
phone: '13800138001',
address: {
city: '北京',
district: '海淀区',
street: '中关村大街1号'
},
registration_date: new Date('2023-01-15'),
status: 'active'
},
{
customer_id: 'C002',
name: '李四',
email: 'lisi@email.com',
phone: '13900139001',
address: {
city: '上海',
district: '浦东新区',
street: '陆家嘴路100号'
},
registration_date: new Date('2023-02-20'),
status: 'active'
},
{
customer_id: 'C003',
name: '王五',
email: 'wangwu@email.com',
phone: '13700137001',
address: {
city: '深圳',
district: '南山区',
street: '科技园路200号'
},
registration_date: new Date('2023-03-10'),
status: 'inactive'
}
]);
// 产品集合
db.products.insertMany([
{
product_id: 'P001',
name: 'iPhone 15 Pro',
category: 'electronics',
price: 7999,
stock: 50,
attributes: {
brand: 'Apple',
color: '黑色',
storage: '128GB'
},
tags: ['手机', '苹果', '智能手机'],
created_at: new Date()
},
{
product_id: 'P002',
name: 'MacBook Air',
category: 'electronics',
price: 8999,
stock: 30,
attributes: {
brand: 'Apple',
screen: '13.6英寸',
memory: '8GB',
storage: '256GB'
},
tags: ['笔记本', '苹果', '电脑'],
created_at: new Date()
},
{
product_id: 'P003',
name: '咖啡机',
category: 'home_appliances',
price: 1299,
stock: 100,
attributes: {
brand: 'Philips',
color: '白色',
capacity: '1.5L'
},
tags: ['家电', '咖啡', '厨房'],
created_at: new Date()
}
]);
// 订单集合
db.orders.insertMany([
{
order_id: 'ORD001',
customer_id: 'C001',
customer_name: '张三',
items: [
{
product_id: 'P001',
product_name: 'iPhone 15 Pro',
quantity: 1,
price: 7999
}
],
total_amount: 7999,
status: 'completed',
order_date: new Date('2024-01-15'),
shipping_address: {
recipient: '张三',
phone: '13800138001',
address: '北京市海淀区中关村大街1号'
}
},
{
order_id: 'ORD002',
customer_id: 'C002',
customer_name: '李四',
items: [
{
product_id: 'P002',
product_name: 'MacBook Air',
quantity: 1,
price: 8999
},
{
product_id: 'P003',
product_name: '咖啡机',
quantity: 2,
price: 1299
}
],
total_amount: 11597,
status: 'shipped',
order_date: new Date('2024-01-16'),
shipping_address: {
recipient: '李四',
phone: '13900139001',
address: '上海市浦东新区陆家嘴路100号'
}
}
]);
print('电商数据库创建完成 ✓');
// 2. 创建博客数据库
print('2. 创建博客数据库...');
db = db.getSiblingDB('blog');
db.users.insertMany([
{
username: 'admin',
email: 'admin@blog.com',
role: 'administrator',
created_at: new Date('2023-01-01')
},
{
username: 'author1',
email: 'author1@blog.com',
role: 'author',
created_at: new Date('2023-02-01')
}
]);
db.categories.insertMany([
{ name: '技术', slug: 'technology', description: '技术相关文章' },
{ name: '生活', slug: 'life', description: '生活相关文章' },
{ name: '旅游', slug: 'travel', description: '旅游相关文章' }
]);
db.posts.insertMany([
{
title: 'MongoDB 入门指南',
content: '这是 MongoDB 的入门教程...',
author: 'author1',
category: '技术',
tags: ['mongodb', '数据库', 'nosql'],
status: 'published',
created_at: new Date('2024-01-10'),
views: 150
},
{
title: '如何学习编程',
content: '学习编程的方法和技巧...',
author: 'admin',
category: '技术',
tags: ['编程', '学习', '技巧'],
status: 'published',
created_at: new Date('2024-01-12'),
views: 89
},
{
title: '北京旅游攻略',
content: '北京著名景点介绍...',
author: 'author1',
category: '旅游',
tags: ['北京', '旅游', '景点'],
status: 'draft',
created_at: new Date('2024-01-14'),
views: 45
}
]);
db.comments.insertMany([
{
post_title: 'MongoDB 入门指南',
author: '读者A',
content: '很好的教程，学习了！',
created_at: new Date('2024-01-11')
},
{
post_title: '如何学习编程',
author: '读者B',
content: '对我很有帮助，谢谢分享',
created_at: new Date('2024-01-13')
}
]);
print('博客数据库创建完成 ✓');
// 3. 创建学校管理数据库
print('3. 创建学校管理数据库...');
db = db.getSiblingDB('school');
db.students.insertMany([
{
student_id: 'S001',
name: '小明',
age: 18,
grade: '高三',
class: '1班',
subjects: ['数学', '物理', '英语'],
contact: {
phone: '13800138002',
email: 'xiaoming@school.com'
},
enrollment_date: new Date('2022-09-01')
},
{
student_id: 'S002',
name: '小红',
age: 17,
grade: '高二',
class: '2班',
subjects: ['语文', '历史', '英语'],
contact: {
phone: '13900139002',
email: 'xiaohong@school.com'
},
enrollment_date: new Date('2023-09-01')
}
]);
db.teachers.insertMany([
{
teacher_id: 'T001',
name: '张老师',
subject: '数学',
years_experience: 10,
classes: ['1班', '2班']
},
{
teacher_id: 'T002',
name: '李老师',
subject: '英语',
years_experience: 8,
classes: ['1班', '3班']
}
]);
db.courses.insertMany([
{
course_id: 'MATH001',
name: '高等数学',
teacher: '张老师',
schedule: '周一 9:00-11:00',
classroom: 'A101'
},
{
course_id: 'ENG001',
name: '大学英语',
teacher: '李老师',
schedule: '周三 14:00-16:00',
classroom: 'B205'
}
]);
print('学校数据库创建完成 ✓');
// 创建索引
print('4. 创建索引...');
db = db.getSiblingDB('ecommerce');
db.customers.createIndex({ customer_id: 1 }, { unique: true });
db.products.createIndex({ product_id: 1 }, { unique: true });
db.orders.createIndex({ order_id: 1 }, { unique: true });
db.products.createIndex({ category: 1 });
db.orders.createIndex({ order_date: -1 });
db = db.getSiblingDB('blog');
db.posts.createIndex({ tags: 1 });
db.posts.createIndex({ created_at: -1 });
db.posts.createIndex({ category: 1 });
db = db.getSiblingDB('school');
db.students.createIndex({ student_id: 1 }, { unique: true });
db.teachers.createIndex({ teacher_id: 1 }, { unique: true });
db.courses.createIndex({ course_id: 1 }, { unique: true });
print('索引创建完成 ✓');
// 显示创建结果
print('');
print('=== 数据库创建完成 ===');
print('');
var databases = ['ecommerce', 'blog', 'school'];
var totalCollections = 0;
var totalDocuments = 0;
databases.forEach(function(dbName) {
var dbObj = db.getSiblingDB(dbName);
print('数据库: ' + dbName);
var collections = dbObj.getCollectionNames();
var dbCollections = 0;
var dbDocuments = 0;
collections.forEach(function(coll) {
if (!coll.startsWith('system.')) {
var count = dbObj[coll].countDocuments();
print(' ├─ ' + coll + ': ' + count + ' 个文档');
dbCollections++;
dbDocuments += count;
}
});
totalCollections += dbCollections;
totalDocuments += dbDocuments;
print(' └─ 总计: ' + dbCollections + ' 个集合, ' + dbDocuments + ' 个文档');
print('');
});
print('=== 总体统计 ===');
print('数据库数量: ' + databases.length);
print('集合总数: ' + totalCollections);
print('文档总数: ' + totalDocuments);
print('');
print('🎉 示例数据已就绪，可以开始使用 MongoDB 了！');
"
}
# 简单的测试脚本（推荐先用这个）
create_simple_test_data() {
log_step "创建简单的测试数据..."
mongosh --port $MONGO_PORT --eval "
print('=== 创建简单测试数据 ===');
// 使用 test 数据库
db = db.getSiblingDB('test');
// 创建用户集合
db.users.insertMany([
{ name: '张三', age: 25, city: '北京', created: new Date() },
{ name: '李四', age: 30, city: '上海', created: new Date() },
{ name: '王五', age: 28, city: '深圳', created: new Date() }
]);
// 创建产品集合
db.products.insertMany([
{ name: '笔记本电脑', price: 5999, category: '电子产品', stock: 50 },
{ name: '智能手机', price: 3999, category: '电子产品', stock: 100 },
{ name: '书籍', price: 59, category: '文化用品', stock: 200 }
]);
print('测试数据创建完成！');
print('数据库: ' + db.getName());
print('集合: ' + db.getCollectionNames().join(', '));
print('用户数量: ' + db.users.countDocuments());
print('产品数量: ' + db.products.countDocuments());
print('');
print('🎉 现在可以开始使用 MongoDB 了！');
print('试试这些命令:');
print(' show dbs');
print(' use test');
print(' show collections');
print(' db.users.find()');
print(' db.products.find({category: \\\"电子产品\\\"})');
"
}
show_usage_guide() {
log_step "MongoDB 使用指南:"
echo ""
echo "1. 连接 MongoDB:"
echo " mongosh --port $MONGO_PORT"
echo ""
echo "2. 查看所有数据库:"
echo " show dbs"
echo ""
echo "3. 使用数据库:"
echo " use test"
echo " use ecommerce"
echo " use blog"
echo " use school"
echo ""
echo "4. 查看集合:"
echo " show collections"
echo ""
echo "5. 查询数据:"
echo " db.users.find()"
echo " db.products.find()"
echo " db.posts.find({status: 'published'})"
echo ""
echo "6. 格式化输出:"
echo " db.users.find().pretty()"
echo ""
echo "7. 条件查询:"
echo " db.products.find({price: {\$gt: 5000}})"
echo " db.users.find({city: '北京'})"
}
main() {
log_step "MongoDB 数据库初始化"
echo "端口: $MONGO_PORT"
echo ""
# 先创建简单的测试数据
log_info "第一步：创建简单测试数据..."
if create_simple_test_data; then
log_info "简单测试数据创建成功！"
echo ""
# 询问是否创建完整示例数据
read -p "是否创建完整示例数据库？(y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
log_info "第二步：创建完整示例数据库..."
if create_sample_databases; then
log_info "完整示例数据库创建成功！"
else
log_error "完整示例数据库创建失败"
fi
fi
else
log_error "测试数据创建失败，请检查 MongoDB 服务状态"
exit 1
fi
echo ""
log_info "🎉 MongoDB 数据初始化完成！"
echo ""
show_usage_guide
}
# 如果直接运行，执行主函数
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi🔍 生成执行过程
🔍 查看生成案例
🔧 状态检查脚本
bash
#!/bin/bash
# MongoDB 状态检查脚本
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'
# 日志函数
log_info() { echo -e "${GREEN}[信息]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[警告]${NC} $1"; }
log_error() { echo -e "${RED}[错误]${NC} $1"; }
log_step() { echo -e "${BLUE}[步骤]${NC} $1"; }
log_detail() { echo -e "${CYAN}[详情]${NC} $1"; }
# 打印分隔线
print_separator() {
echo "================================================================"
}
# 打印标题
print_title() {
echo
print_separator
echo -e "${BLUE}$1${NC}"
print_separator
}
# 检查系统信息
check_system_info() {
print_title "系统信息"
# OS 信息
if [[ -f /etc/os-release ]]; then
source /etc/os-release
echo -e "操作系统: ${GREEN}$NAME $VERSION${NC}"
echo -e "系统架构: ${GREEN}$(uname -m)${NC}"
echo -e "内核版本: ${GREEN}$(uname -r)${NC}"
else
echo -e "操作系统: ${YELLOW}$(cat /etc/redhat-release 2>/dev/null || echo "未知")${NC}"
fi
# 系统时间
echo -e "系统时间: ${GREEN}$(date)${NC}"
echo -e "运行时间: ${GREEN}$(uptime -p)${NC}"
# 内存使用
local mem_info=$(free -h | grep Mem)
echo -e "内存使用: ${GREEN}$mem_info${NC}"
# 磁盘使用
echo -e "根分区使用: ${GREEN}$(df -h / | tail -1)${NC}"
}
# 检查 MongoDB 服务状态
check_mongodb_service() {
print_title "MongoDB 服务状态"
# 检查服务是否运行
if systemctl is-active mongod >/dev/null 2>&1; then
echo -e "服务状态: ${GREEN}运行中 ✓${NC}"
else
echo -e "服务状态: ${RED}未运行 ✗${NC}"
fi
# 检查是否启用开机自启
if systemctl is-enabled mongod >/dev/null 2>&1; then
echo -e "开机自启: ${GREEN}已启用 ✓${NC}"
else
echo -e "开机自启: ${YELLOW}未启用 ⚠${NC}"
fi
# 显示详细的服务状态
log_detail "详细服务状态:"
systemctl status mongod --no-pager --lines=5 || true
}
# 检查 MongoDB 进程
check_mongodb_process() {
print_title "MongoDB 进程信息"
local mongo_pids=$(pgrep mongod || true)
if [[ -n "$mongo_pids" ]]; then
echo -e "MongoDB 进程数: ${GREEN}$(echo "$mongo_pids" | wc -l)${NC}"
echo -e "进程PID: ${GREEN}$mongo_pids${NC}"
# 显示进程详情
for pid in $mongo_pids; do
log_detail "进程 $pid 详情:"
ps -p $pid -o pid,ppid,user,%cpu,%mem,cmd --no-headers 2>/dev/null || true
done
else
echo -e "MongoDB 进程: ${RED}未找到 ✗${NC}"
fi
}
# 检查端口监听
check_port_listening() {
print_title "网络端口监听"
local default_port="27017"
local port=${1:-$default_port}
echo -e "检查端口: ${CYAN}$port${NC}"
# 使用 netstat 检查
if netstat -tlnp 2>/dev/null | grep -q ":$port "; then
echo -e "端口状态: ${GREEN}已监听 ✓${NC}"
netstat -tlnp 2>/dev/null | grep ":$port " | while read line; do
echo -e "监听信息: ${GREEN}$line${NC}"
done
else
echo -e "端口状态: ${RED}未监听 ✗${NC}"
fi
# 使用 ss 检查（备选）
if command -v ss >/dev/null 2>&1; then
ss -tlnp | grep -q ":$port " && {
echo -e "SS 检查: ${GREEN}端口 $port 正在监听${NC}"
} || {
echo -e "SS 检查: ${RED}端口 $port 未监听${NC}"
}
fi
}
# 检查 MongoDB 配置文件
check_mongodb_config() {
print_title "MongoDB 配置文件"
local config_files=(
"/etc/mongod.conf"
"/etc/mongodb.conf"
"/usr/local/etc/mongod.conf"
)
local found_config=""
for config in "${config_files[@]}"; do
if [[ -f "$config" ]]; then
found_config="$config"
echo -e "配置文件: ${GREEN}$config ✓${NC}"
# 显示关键配置项
log_detail "关键配置信息:"
grep -E "^(dbPath|port|bindIp|logpath|storage|net|security)" "$config" | head -10 | while read line; do
echo -e " ${CYAN}$line${NC}"
done
break
fi
done
if [[ -z "$found_config" ]]; then
echo -e "配置文件: ${YELLOW}未找到默认配置文件 ⚠${NC}"
fi
}
# 检查数据目录和日志
check_directories() {
print_title "数据目录和日志"
# 尝试从配置文件获取目录
local config_file="/etc/mongod.conf"
local db_path=""
local log_path=""
if [[ -f "$config_file" ]]; then
db_path=$(grep 'dbPath:' "$config_file" | awk '{print $2}' | head -1)
log_path=$(grep 'path:' "$config_file" | awk '{print $2}' | head -1)
log_path=$(dirname "$log_path" 2>/dev/null || echo "")
fi
# 默认目录
db_path=${db_path:-"/var/lib/mongodb"}
log_path=${log_path:-"/var/log/mongodb"}
echo -e "数据目录: ${CYAN}$db_path${NC}"
if [[ -d "$db_path" ]]; then
local db_size=$(du -sh "$db_path" 2>/dev/null | cut -f1 || echo "未知")
echo -e " 存在: ${GREEN}是 ✓${NC}"
echo -e " 大小: ${GREEN}$db_size${NC}"
echo -e " 权限: ${GREEN}$(ls -ld "$db_path" | awk '{print $1 " " $3 ":" $4}')${NC}"
else
echo -e " 存在: ${RED}否 ✗${NC}"
fi
echo -e "日志目录: ${CYAN}$log_path${NC}"
if [[ -d "$log_path" ]]; then
local log_size=$(du -sh "$log_path" 2>/dev/null | cut -f1 || echo "未知")
echo -e " 存在: ${GREEN}是 ✓${NC}"
echo -e " 大小: ${GREEN}$log_size${NC}"
# 检查日志文件
local log_file="$log_path/mongod.log"
if [[ -f "$log_file" ]]; then
echo -e " 日志文件: ${GREEN}$log_file ✓${NC}"
echo -e " 日志大小: ${GREEN}$(du -h "$log_file" | cut -f1)${NC}"
echo -e " 最后更新: ${GREEN}$(stat -c %y "$log_file" 2>/dev/null | cut -d. -f1 || echo "未知")${NC}"
else
echo -e " 日志文件: ${YELLOW}不存在 ⚠${NC}"
fi
else
echo -e " 存在: ${RED}否 ✗${NC}"
fi
}
# 检查 MongoDB 连接
check_mongodb_connection() {
print_title "MongoDB 连接测试"
local port=${1:-"27017"}
# 检查 mongosh 或 mongo 命令
local mongo_cmd=""
if command -v mongosh >/dev/null 2>&1; then
mongo_cmd="mongosh"
elif command -v mongo >/dev/null 2>&1; then
mongo_cmd="mongo"
fi
if [[ -n "$mongo_cmd" ]]; then
echo -e "客户端工具: ${GREEN}$mongo_cmd ✓${NC}"
# 测试连接
if timeout 5s $mongo_cmd --port $port --eval "db.version()" --quiet >/dev/null 2>&1; then
echo -e "连接测试: ${GREEN}成功 ✓${NC}"
# 获取版本信息
local version=$($mongo_cmd --port $port --eval "db.version()" --quiet 2>/dev/null)
echo -e "MongoDB 版本: ${GREEN}$version${NC}"
# 获取基本状态
log_detail "数据库状态:"
$mongo_cmd --port $port --eval "
print('主机名: ' + db.serverStatus().host);
print('运行时间: ' + db.serverStatus().uptime + ' 秒');
print('连接数: ' + db.serverStatus().connections.current);
print('数据库数量: ' + db.getMongo().getDBNames().length);
" --quiet 2>/dev/null | while read line; do
echo -e " ${CYAN}$line${NC}"
done || true
else
echo -e "连接测试: ${RED}失败 ✗${NC}"
echo -e "错误信息: ${RED}无法连接到 MongoDB 服务${NC}"
fi
else
echo -e "客户端工具: ${RED}未找到 ✗${NC}"
echo -e "连接测试: ${YELLOW}跳过 ⚠${NC}"
fi
}
# 检查系统资源
check_system_resources() {
print_title "系统资源使用"
# CPU 使用率
echo -e "CPU 使用率: ${GREEN}$(top -bn1 | grep "Cpu(s)" | awk '{print $2}')%${NC}"
# 内存使用详情
log_detail "内存使用详情:"
free -h | while read line; do
echo -e " ${CYAN}$line${NC}"
done
# 磁盘使用详情
log_detail "磁盘使用详情:"
df -h | grep -E "(文件系统|^/dev/)" | head -5 | while read line; do
echo -e " ${CYAN}$line${NC}"
done
}
# 检查防火墙状态
check_firewall_status() {
print_title "防火墙状态"
local port=${1:-"27017"}
# 检查 UFW
if command -v ufw >/dev/null 2>&1; then
if ufw status | grep -q "Status: active"; then
echo -e "UFW 状态: ${GREEN}活跃${NC}"
if ufw status | grep -q "$port"; then
echo -e "端口 $port: ${GREEN}已放行 ✓${NC}"
else
echo -e "端口 $port: ${RED}未放行 ✗${NC}"
fi
else
echo -e "UFW 状态: ${YELLOW}未激活${NC}"
fi
# 检查 FirewallD
elif command -v firewall-cmd >/dev/null 2>&1; then
if systemctl is-active firewalld >/dev/null 2>&1; then
echo -e "FirewallD 状态: ${GREEN}活跃${NC}"
if firewall-cmd --list-ports | grep -q "$port/tcp"; then
echo -e "端口 $port: ${GREEN}已放行 ✓${NC}"
else
echo -e "端口 $port: ${RED}未放行 ✗${NC}"
fi
else
echo -e "FirewallD 状态: ${YELLOW}未激活${NC}"
fi
else
echo -e "防火墙: ${YELLOW}未检测到常用防火墙工具${NC}"
fi
}
# 生成总结报告
generate_summary() {
print_title "状态总结报告"
local issues=0
local warnings=0
# 服务状态检查
if ! systemctl is-active mongod >/dev/null 2>&1; then
echo -e "❌ ${RED}问题: MongoDB 服务未运行${NC}"
((issues++))
fi
# 端口检查
if ! netstat -tlnp 2>/dev/null | grep -q ":27017 "; then
echo -e "❌ ${RED}问题: 端口 27017 未监听${NC}"
((issues++))
fi
# 连接检查
if command -v mongosh >/dev/null 2>&1; then
if ! timeout 3s mongosh --port 27017 --eval "db.version()" --quiet >/dev/null 2>&1; then
echo -e "❌ ${RED}问题: 无法连接到 MongoDB${NC}"
((issues++))
fi
else
echo -e "⚠️ ${YELLOW}警告: 未找到 MongoDB 客户端工具${NC}"
((warnings++))
fi
# 数据目录检查
local config_file="/etc/mongod.conf"
local db_path=""
if [[ -f "$config_file" ]]; then
db_path=$(grep 'dbPath:' "$config_file" | awk '{print $2}' | head -1)
fi
db_path=${db_path:-"/var/lib/mongodb"}
if [[ ! -d "$db_path" ]]; then
echo -e "⚠️ ${YELLOW}警告: 数据目录不存在${NC}"
((warnings++))
fi
# 输出总结
echo
if [[ $issues -eq 0 && $warnings -eq 0 ]]; then
echo -e "🎉 ${GREEN}所有检查通过！MongoDB 状态正常。${NC}"
elif [[ $issues -eq 0 ]]; then
echo -e "ℹ️ ${YELLOW}有 $warnings 个警告，但无严重问题。${NC}"
else
echo -e "💥 ${RED}发现 $issues 个问题，$warnings 个警告，需要处理。${NC}"
fi
}
# 主函数
main() {
echo
print_title "MongoDB 状态检查报告 - $(date)"
check_system_info
check_mongodb_service
check_mongodb_process
check_port_listening "27017"
check_mongodb_config
check_directories
check_mongodb_connection "27017"
check_system_resources
check_firewall_status "27017"
generate_summary
echo
print_separator
echo -e "${GREEN}状态检查完成${NC}"
print_separator
echo
}
# 脚本入口
if [[ $# -gt 0 && ($1 == "-h" || $1 == "--help") ]]; then
echo "使用方法: $0"
echo "功能: 检查 MongoDB 的完整状态信息"
exit 0
fi
main "$@"🔍 状态执行过程
⚙️ 服务管理脚本
为了管理方便 封装了服务管理脚本
bash
#!/bin/bash
# MongoDB 管理脚本
set -e
# 配置
CONFIG_FILE="/etc/mongod.conf"
SERVICE_NAME="mongod"
DATA_DIR=$(grep 'dbPath:' $CONFIG_FILE 2>/dev/null | awk '{print $2}' || echo "/var/lib/mongodb")
LOG_DIR=$(grep 'path:' $CONFIG_FILE 2>/dev/null | awk '{print $2}' | head -1 | xargs dirname || echo "/var/log/mongodb")
# 颜色定义
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'
# 日志函数
log_info() { echo -e "${GREEN}[信息]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[警告]${NC} $1"; }
log_error() { echo -e "${RED}[错误]${NC} $1"; }
# 显示使用说明
usage() {
cat << EOF
使用方法: $0 {start|stop|restart|status|logs|backup|restore|clean}
命令说明:
start 启动 MongoDB 服务
stop 停止 MongoDB 服务
restart 重启 MongoDB 服务
status 查看服务状态
logs 查看服务日志
backup 备份 MongoDB 数据
restore 恢复 MongoDB 数据
clean 清理日志和临时文件
示例:
$0 start
$0 status
$0 backup /backup/mongodb
EOF
}
# 检查服务状态
check_service() {
if ! systemctl is-enabled $SERVICE_NAME >/dev/null 2>&1; then
log_error "MongoDB 服务未安装或未启用"
return 1
fi
return 0
}
# 启动服务
start_service() {
log_info "启动 MongoDB 服务..."
# 创建 PID 文件目录 （服务器重启之后 /var/run/mongodb 会自行删除，或编写脚本服务器启动立刻生成）
sudo mkdir -p /var/run/mongodb
sudo chown mongodb:mongodb /var/run/mongodb
sudo chmod 755 /var/run/mongodb
systemctl start $SERVICE_NAME
systemctl is-active $SERVICE_NAME && log_info "服务启动成功" || log_error "服务启动失败"
}
# 停止服务
stop_service() {
log_info "停止 MongoDB 服务..."
systemctl stop $SERVICE_NAME
if systemctl is-active $SERVICE_NAME; then
log_error "服务停止失败"
return 1
else
log_info "服务停止成功"
fi
}
# 重启服务
restart_service() {
log_info "重启 MongoDB 服务..."
# 创建 PID 文件目录 （服务器重启之后 /var/run/mongodb 会自行删除，或编写脚本服务器启动立刻生成）
sudo mkdir -p /var/run/mongodb
sudo chown mongodb:mongodb /var/run/mongodb
sudo chmod 755 /var/run/mongodb
systemctl restart $SERVICE_NAME
systemctl is-active $SERVICE_NAME && log_info "服务重启成功" || log_error "服务重启失败"
}
# 查看状态
show_status() {
echo "=== MongoDB 服务状态 ==="
systemctl status $SERVICE_NAME --no-pager -l
echo -e "\n=== 端口监听状态 ==="
netstat -tlnp | grep mongod || echo "未检测到 MongoDB 端口监听"
echo -e "\n=== 数据目录使用情况 ==="
du -sh $DATA_DIR 2>/dev/null || echo "数据目录不存在: $DATA_DIR"
echo -e "\n=== 日志目录使用情况 ==="
du -sh $LOG_DIR 2>/dev/null || echo "日志目录不存在: $LOG_DIR"
}
# 查看日志
show_logs() {
local lines=${1:-50}
if [[ -f "$LOG_DIR/mongod.log" ]]; then
tail -f -n $lines "$LOG_DIR/mongod.log"
else
journalctl -u $SERVICE_NAME -f -n $lines
fi
}
# 备份数据
backup_data() {
local backup_dir=${1:-"/backup/mongodb"}
local timestamp=$(date +%Y%m%d_%H%M%S)
local backup_path="$backup_dir/backup_$timestamp"
log_info "开始备份 MongoDB 数据..."
# 创建备份目录
mkdir -p $backup_path
# 检查 mongodump 命令
if ! command -v mongodump &> /dev/null; then
log_error "未找到 mongodump 命令，请安装 MongoDB 工具包"
return 1
fi
# 执行备份
if mongodump --out $backup_path > /dev/null 2>&1; then
log_info "数据备份成功: $backup_path"
# 备份配置文件
cp $CONFIG_FILE $backup_path/
# 创建备份信息文件
cat > $backup_path/backup.info << EOF
备份时间: $(date)
MongoDB 版本: $(mongodump --version | head -1)
数据目录: $DATA_DIR
备份大小: $(du -sh $backup_path | cut -f1)
EOF
log_info "备份完成，位置: $backup_path"
else
log_error "数据备份失败"
return 1
fi
}
# 恢复数据
restore_data() {
local backup_path=$1
if [[ -z "$backup_path" ]]; then
log_error "请指定备份文件路径"
return 1
fi
if [[ ! -d "$backup_path" ]]; then
log_error "备份目录不存在: $backup_path"
return 1
fi
log_info "开始恢复 MongoDB 数据..."
# 停止服务
stop_service
# 执行恢复
if mongorestore $backup_path > /dev/null 2>&1; then
log_info "数据恢复成功"
# 启动服务
start_service
else
log_error "数据恢复失败"
start_service
return 1
fi
}
# 清理操作
cleanup() {
log_info "开始清理操作..."
# 清理日志文件 (保留最近7天)
find $LOG_DIR -name "*.log*" -type f -mtime +7 -delete
log_info "日志文件清理完成"
# 清理临时文件
find /tmp -name "mongodb*" -type f -mtime +1 -delete
log_info "临时文件清理完成"
# 清空 journal 目录 (谨慎操作)
local journal_dir="$DATA_DIR/journal"
if [[ -d "$journal_dir" ]]; then
find $journal_dir -name "prealloc.*" -type f -delete
log_info "Journal 预分配文件清理完成"
fi
}
# 主函数
main() {
local command=$1
local argument=$2
case $command in
start)
check_service && start_service
;;
stop)
check_service && stop_service
;;
restart)
check_service && restart_service
;;
status)
check_service && show_status
;;
logs)
show_logs $argument
;;
backup)
backup_data $argument
;;
restore)
restore_data $argument
;;
clean)
cleanup
;;
*)
usage
exit 1
;;
esac
}
# 脚本入口
if [[ $# -eq 0 ]]; then
usage
exit 1
fi
main "$@"🚀 快速安装方式
方法1：一键脚本安装
bash
# 下载脚本
wget -O install-mongodb.sh https://raw.githubusercontent.com/example/install-mongodb/master/install-mongodb.sh
# 添加执行权限
chmod +x install-mongodb.sh
# 运行安装
sudo ./install-mongodb.sh方法2：各系统快速安装
bash
# Ubuntu/Debian
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt update
sudo apt install -y mongodb-org
sudo systemctl enable mongod && sudo systemctl start mongod
# CentOS/RHEL/Amazon Linux
cat > /etc/yum.repos.d/mongodb-org-6.0.repo << EOF
[mongodb-org-6.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/\$releasever/mongodb-org/6.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-6.0.asc
EOF
sudo yum install -y mongodb-org
sudo systemctl enable mongod && sudo systemctl start mongod⚙️ 常用管理命令
bash
# 服务管理
sudo systemctl start mongod # 启动
sudo systemctl stop mongod # 停止
sudo systemctl restart mongod # 重启
sudo systemctl status mongod # 查看状态
sudo systemctl enable mongod # 设置开机自启
# MongoDB连接
mongo --port 27017 -u admin -p <password> --authenticationDatabase admin # 认证连接
mongo --port 27017 # 无认证连接（如果禁用认证）
# 数据库操作
mongo -u admin -p <password> --eval "show dbs" # 查看数据库
mongo -u admin -p <password> --eval "use mydb" # 切换数据库
mongo -u admin -p <password> --eval "db.createCollection('users')" # 创建集合
# 用户管理
mongo -u admin -p <password> --eval "
db.createUser({
user: 'myuser',
pwd: 'mypassword',
roles: [{ role: 'readWrite', db: 'mydb' }]
})"
# 备份恢复
mongodump -u admin -p <password> --out /backup/ # 备份
mongorestore -u admin -p <password> /backup/ # 恢复📁 重要目录和文件
bash
/var/lib/mongodb/ # 数据目录
/var/log/mongodb/ # 日志目录
├── mongod.log # 主日志文件
/etc/mongod/ # 配置目录
├── mongod.conf # 主配置文件
/var/run/mongodb/ # 运行时文件
├── mongod.pid # PID文件🔧 常用配置修改
修改监听地址
bash
sudo vi /etc/mongod/mongod.conf
# 修改:
net:
bindIp: 0.0.0.0 # 允许所有IP连接调整缓存大小
bash
# 根据服务器内存调整
storage:
wiredTiger:
engineConfig:
cacheSizeGB: 2启用分片集群
bash
sharding:
clusterRole: shardsvr配置OPLog大小
bash
replication:
oplogSizeMB: 1024🔍 安装验证和测试
bash
# 检查服务状态
sudo systemctl status mongod
# 检查端口监听
netstat -tulpn | grep 27017
ss -tulpn | grep 27017
# 测试连接
mongo --port 27017 -u admin -p <password> --authenticationDatabase admin --eval "db.adminCommand('ping')"
# 查看版本信息
mongo --port 27017 -u admin -p <password> --eval "db.version()"
# 性能测试
mongo --port 27017 -u admin -p <password> --eval "
db.runCommand({serverStatus: 1})"
# 创建测试数据
mongo --port 27017 -u admin -p <password> --authenticationDatabase admin << EOF
use testdb;
for (var i = 1; i <= 1000; i++) {
db.users.insert({
name: "用户" + i,
age: Math.floor(Math.random() * 50) + 18,
created: new Date()
});
}
db.users.count();
db.users.find().limit(5);
EOF🔍 客户端链接测试
这个脚本提供了完整的MongoDB安装方案，包括安全配置、性能优化集支持，适合生产环境使用！