KingbaseES与MongoDB全面对比：一篇从理论到实战的国产化迁移指南数据库选型背景与安装随着数字化转型进程加

摘要：本文对比了国产金仓数据库KingbaseES与MongoDB的核心技术差异，并提供了详细的迁移方案。KingbaseES在多模融合架构、查询性能（平均响应时间降低81%）、安全合规等方面优势显著，支持MongoDB协议原生兼容。文章包含Docker部署指南、增删改查代码示例及两个成功迁移案例（政务系统性能提升94%，制造业系统并发能力提升78%）。建议采用"评估-迁移-验证-切换-优化"五步法，使用KDTS工具实现平滑迁移。该指南为国产化替代提供了实用技术参考。

一、数据库选型背景与安装

随着数字化转型进程加速，企业对数据库的要求不断提高——不仅需要良好的兼容性和强大的性能，安全合规更是不可或缺。MongoDB作为主流的NoSQL数据库，在文档存储方面表现卓越，但在政务、金融等关键行业中逐渐暴露出瓶颈：自主可控性不足、数据一致性保障有限、安全合规能力不足等问题。

而金仓数据库KingbaseES作为国产数据库的领军者，凭借原生兼容能力和完整的迁移方案，成为MongoDB的理想替代选择。目前已在政务、金融、医疗等多个关键行业得到验证，实力不容小觑。

1.1 硬件要求

支持 X86_64、龙芯、飞腾、鲲鹏等架构
建议至少 2 核 4G 内存，10GB 可用磁盘空间

1.2 软件要求

Docker 版本 ≥ 20.10.0（推荐 24.x 稳定版）

小提示：使用 docker --version 快速确认当前版本。本文用docker 26.1.3进行实操记录！

1.3 创建数据目录

为了避免容器销毁后数据丢失，我们先在宿主机创建持久化目录：

mkdir -p /opt/kingbase/data
chmod -R 755 /opt/kingbase/data

小提示：建议统一放在 /opt 下，方便管理。

1.4 获取镜像包

你可以通过以下方式获取 KingbaseES 镜像：

1、官网下载：www.kingbase.com.cn/

2、入口位置：服务与支持 > 下载中 > KES，如下图所示：

3、KingbaseES数据库Docker镜像，根据自己电脑配置选择对应的版本下载。

点击下载会提示下载验证，输入相关信息后就可以下载啦！

如果有特殊需求镜像：

联系销售人员或代理商获取
内部项目提供（如涉密项目）

本文使用的是KingbaseES_V009R001C010B0004_x86_64_Docker.tar 镜像包，大小约 754MB。

1.5导入镜像

1、将镜像包上传至 /opt/kingbase 目录下，这个目录可根据自身情况自定义，如下图：

2、将镜像包上传至 /opt/kingbase 目录后，执行导入：

docker load -i /opt/kingbase/KingbaseES_V009R001C010B0004_x86_64_Docker.tar

3、导入成功后，使用 docker images 查看：

REPOSITORY                                                                         TAG                                  IMAGE ID       CREATED         SIZE
kingbase_v009r001c010b0004_single_x86                                              v1                                   10ba6f33e228   2 months ago    754MB

如果 docker load 报错，可尝试 docker import，但推荐使用 load，兼容性更好。

1.6 最小启动（无持久化）

适合临时测试，容器删除后数据不保留：

docker run -tid --privileged \
  -p 54321:54321 \
  --name kingbase \
  kingbase_v009r001c010b0004_single_x86:v1 /usr/sbin/init

1.7 推荐启动（数据持久化）

生产或长期使用建议挂载数据卷：

docker run -tid --privileged \
  -p 9099:54321 \
  --name kingbase \
  -v /opt/kingbase/data:/home/kingbase/userdata \
  kingbase_v009r001c010b0004_single_x86:v1 /usr/sbin/init

端口说明：KingbaseES 默认使用 54321 端口，非 PostgreSQL 的 5432，注意区分。

1.8 查看容器状态

docker ps

输出示例：

CONTAINER ID   IMAGE                                                                                                  COMMAND                  CREATED         STATUS                  PORTS                                                                            NAMES
6f2958b65b3d   kingbase_v009r001c010b0004_single_x86:v1                                                               "/bin/bash /home/kin…"   5 seconds ago   Up 5 seconds            0.0.0.0:9099->54321/tcp, :::9099->54321/tcp                                      kingbase

1.9 进入容器

docker exec -it kingbase /bin/bash

[kingbase@6f2958b65b3d ~]$ du -sh *
8.0K   docker-entrypoint.sh
439M   install
167M   userdata

进入跟目录，可以打印 docker-entrypoint.sh 启动类出来看看，看一下启动都发生了什么事，搞技术就喜欢追究底层原理，常话说：知其然，知其所以然！

[kingbase@6f2958b65b3d ~]$ vi docker-entrypoint.sh 

#!/bin/bash
  

source /etc/profile
cron_file="/etc/cron.d/KINGBASECRON"


command_options="-q -o ConnectTimeout=10 -o StrictHostKeyChecking=no -p 22"
default_pass="MTIzNDU2NzhhYgo="


function err_log()
{
    local exit_flag=$?
    local message="$1"

    if [ ${exit_flag} -ne 0 ]
    then
        echo "${message} fail"
    else
        echo "${message} success"
    fi
}

function pre_exe(){
    DB_PATH=/home/kingbase/install/kingbase
    etc_PATH=${DB_PATH}/etc
    if [ "$DATA_DIR"x == ""x ]
    then
        DATA_DIR=/home/kingbase/userdata/data
    fi
    persist_etc_PATH=${DATA_DIR}/../etc
    LOG_FILE=${DATA_DIR}/logfile
    [ "$PASSWORD"x == ""x ] && PASSWORD=`echo "${default_pass}" | base64 -d`
    [ "$DB_USER"x == ""x ] && DB_USER=system
    [ "$DB_MODE"x == "pg"x -o "$DB_MODE"x == "mysql"x ] && ENABLE_CI=""
    kingbase_user_exist=`cat /etc/bashrc |grep KINGBASE_USER|wc -l`
    [ $kingbase_user_exist -eq 0 ] && sudo echo "export KINGBASE_USER=${DB_USER}" | sudo tee -a /etc/bashrc
    local DB_NAME="kingbase" # 仅在注入 ksql 环境变量时生效
    kingbase_database_exist=`cat /etc/bashrc |grep KINGBASE_DATABASE|wc -l`
    [ $kingbase_database_exist -eq 0 ] && sudo echo "export KINGBASE_DATABASE=${DB_NAME}" | sudo tee -a /etc/bashrc
    sudo mkdir -p $DATA_DIR
    sudo chown -R kingbase:kingbase /home/kingbase/
    sudo chmod -R 700 $DATA_DIR
    test ! -d ${persist_etc_PATH} && mkdir -p ${persist_etc_PATH}
    test ! -d ${etc_PATH} && ln -s ${persist_etc_PATH} ${etc_PATH}
}
function load_env(){
   [ "$DB_PASSWORD"x != ""x ] && PASSWORD=$DB_PASSWORD
   [ "$USER_DATA"x != ""x ] && DATA_DIR=/home/kingbase/$USER_DATA
   [ "$NEED_START"x == ""x ] && NEED_START=yes
   [ "$ENCODING"x == ""x ] && ENCODING=UTF-8
}
function param_check(){
    if [ "$DB_MODE"x != ""x ]
    then
        if ! [[ "${DB_MODE}"x == "mysql"x || "${DB_MODE}"x == "oracle"x || "${DB_MODE}"x == "pg"x || "${DB_MODE}"x == "sqlserver"x ]];
        then
            echo "[ERROR] env [DB_MODE]:${DB_MODE} set error, it just could be set as {mysql,oracle,pg,sqlserver}"
            exit 1
        fi
    fi

    if [ "$ENABLE_CI"x != ""x ]
    then
        if ! [[ "${ENABLE_CI}"x == "yes"x || "${ENABLE_CI}"x == "no"x ]]
        then
            echo "[ERROR] env [ENABLE_CI]:${ENABLE_CI} set error, it just could be set as {yes, no}"
            exit 1
        fi
    fi
}
function check_and_run(){
   local DATA_DIR=$1
   pre_exe
   ${DB_PATH}/bin/sys_ctl -D ${DATA_DIR} status  2>/dev/null
   if [ $? -ne 0 ];then
       echo "[`date`]db is not running, ${DB_PATH}/bin/sys_ctl -D ${DATA_DIR} -l ${DATA_DIR}/logfile start"
       ${DB_PATH}/bin/sys_ctl -D ${DATA_DIR} -l ${LOG_FILE} start
       [ $? -eq 0 ] &&  echo "[`date`]db started" && return 0
       echo "[`date`]db start fail"
       return 0
   fi
}

function start_cron()
{
    local i=0
    local cron_command="* * * * * kingbase /home/kingbase/docker-entrypoint.sh check_and_run ${DATA_DIR} >> /home/kingbase/cronlog"
    #  root用户添加CRON任务
    local cronexist=`sudo cat $cron_file 2>/dev/null| grep -wFn "${cron_command}" |wc -l`
    if [ "$cronexist"x != ""x ] && [ $cronexist -eq 1 ]
    then
        local realist=`sudo cat $cron_file | grep -wFn "${cron_command}"`
        local linenum=`echo "${realist}" |awk -F':' '{print $1}'`
        sudo sed ${linenum}s/#*// $cron_file > ${persist_etc_PATH}/KINGBASECRON
        sudo cat ${persist_etc_PATH}/KINGBASECRON | sudo tee -a  $cron_file
    elif [ "$cronexist"x != ""x ] && [ $cronexist -eq 0 ]
    then
        sudo chmod 777 $cron_file
        sudo echo -e "${cron_command}\n" |sudo tee -a  $cron_file
        sudo chmod 644 $cron_file
    else
        return 1
    fi
    return 0
}


function db_init(){
    local db_init_command="${DB_PATH}/bin/initdb -U$DB_USER -x ${PASSWORD} -D ${DATA_DIR} -E ${ENCODING}"
    if [ "$ENABLE_CI"x == "yes"x ]
    then
        db_init_command="$db_init_command --enable_ci"
    fi
    if [ "$DB_MODE"x != ""x ]
    then
        db_init_command="$db_init_command -m $DB_MODE"
    fi
    echo "[`date`]start initdb..."
    eval "$db_init_command"
    echo "[`date`]start initdb...ok"

    sed -i 's/local   all             all                                     scram-sha-256/local   all             all                                     trust/g' ${DATA_DIR}/kingbase.conf
    sed -i 's/local   replication     all                                     scram-sha-256/local   replication     all                                     trust/g' ${DATA_DIR}/kingbase.conf
    sed -i 's/^#(\s*archive_mode\s*=\s*)off/\1on/'  ${DATA_DIR}/kingbase.conf
    sed -i "s|^#(\s*archive_command\s*=\s*)''|\1'/bin/true'|"  ${DATA_DIR}/kingbase.conf

    mv ${DB_PATH}/bin/license.dat ${etc_PATH}/license.dat
    ln -s ${etc_PATH}/license.dat ${DB_PATH}/bin/license.dat

}

function main(){
    load_env
    pre_exe
    param_check
    if [ "$(ls -A ${DATA_DIR})" ];then
       echo "[`date`]data directory:${DATA_DIR} is not empty,don't need to initdb"
    else
       db_init
    fi

    if [ "$NEED_START"x == "yes"x ]
    then
        ${DB_PATH}/bin/sys_ctl -D ${DATA_DIR} -l ${LOG_FILE} start
        sudo chown -R root:root /etc/cron.d/
        sudo chmod -R 644 /etc/cron.d/
        test ! -f $cron_file &&  sudo touch $cron_file && sudo chmod 644 $cron_file
        start_cron
    elif [ "$NEED_START"x == "no"x ]
    then
        echo "[`date`]NEED_START be set as ${NEED_START},not yes, do not need start db"
        touch  ${LOG_FILE}
    fi

    if test -f ${etc_PATH}/logrotate_kingbase
    then
       echo "[`date`]cp logrotate_kingbase from  ${etc_PATH}/logrotate_kingbase  to /etc/logrotate.d/kingbase"
       sudo cp ${etc_PATH}/logrotate_kingbase  /etc/logrotate.d/kingbase
       err_log "cp ${etc_PATH}/logrotate_kingbase  /etc/logrotate.d/kingbase"
       sudo chmod 644 /etc/logrotate.d/kingbase
       sudo chown root:root /etc/logrotate.d/kingbase
    fi

    if test -f  ${etc_PATH}/KINGBASECRON
    then
       echo "[`date`]cp KINGBASECRON from  ${etc_PATH}/KINGBASECRON  to /etc/cron.d/KINGBASECRON"
       sudo cp ${etc_PATH}/KINGBASECRON  /etc/cron.d/KINGBASECRON
       err_log "sudo cp ${etc_PATH}/KINGBASECRON  /etc/cron.d/KINGBASECRON"
       sudo chmod 644 /etc/cron.d/KINGBASECRON
       sudo chown root:root /etc/cron.d/KINGBASECRON
    fi

    if test -f ${etc_PATH}/${USER}
    then
       crontab ${etc_PATH}/${USER}
    fi

    if test -f ${etc_PATH}/.encpwd
    then
       echo "[`date`]cp .encpwd from  ${etc_PATH}/.encpwd to ~/.encpwd"
       cp ${etc_PATH}/.encpwd  ~/.encpwd
       err_log "cp ${etc_PATH}/.encpwd  ~/.encpwd"
       sudo chmod 600 ~/.encpwd
       sudo chown ${USER}:${USER} ~/.encpwd
    fi
    while true;do sleep 1000;done
}
case $1 in
    "check_and_run")
        shift
        check_and_run $1
        exit 0
        ;;
    *)
        main
esac

1.10 连接数据库验证

使用 ksql 命令连接：

ksql -U kingbase -d test

你遇到的问题是：默认用户 kingbase 不存在，这是 KingbaseES 镜像——它并没有默认创建 kingbase 这个 role（用户） ，所以连接失败。

✅ 正确做法：先登录数据库，再查看/创建用户

✅ Step 1：用默认超级用户登录

KingbaseES 默认超级用户是 system，密码通常也是 system（或空密码），你可以这样登录：

ksql -U system -d test

✅ Step 2：查看已有用户

登录后执行：

\du

你会看到类似输出：

Role name  |                         Attributes                         | Member of 
------------+------------------------------------------------------------+-----------
 kcluster   | Cannot login                                               | {}
 sao        | No inheritance, Create role                                | {}
 sao_oper   | No inheritance, Cannot login                               | {}
 sao_public | No inheritance, Cannot login                               | {}
 sso        | No inheritance, Create role                                | {}
 sso_oper   | No inheritance, Cannot login                               | {}
 sso_public | No inheritance, Cannot login                               | {}
 system     | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

✅ Step 3：创建你需要的用户（如 kingbase）

CREATE USER kingbase WITH PASSWORD 'kingbase';
GRANT ALL PRIVILEGES ON DATABASE test TO kingbase;

✅ Step 4：退出并用新用户登录

\q
ksql -U kingbase -d test

✅ 总结一句话：

第一次别用 kingbase 用户登录，先用 system 登录，再自己创建用户。

🔍 步骤总结：

步骤	情况内容	操作说明
登录失败	`ksql: error: could not connect to server: FATAL: role "kingbase" does not exist`	默认`kingbase`用户不存在
登录成功	`ksql -U system -d test` 进入 `test=#`	第一次用 system 用户成功登录
创建用户	执行 `CREATE USER kingbase...`	手动创建 kingbase 用户
最终登录	`ksql -U kingbase -d test` 成功	自定义用户也能用了！

二、KingbaseES与MongoDB核心技术对比

1. 架构设计理念差异

MongoDB采用文档型数据库架构，核心特点是“灵活存储、易扩展”，适合处理半结构化/非结构化数据。在分布式部署上，MongoDB通过“副本集”（1主多从）实现高可用，通过“分片集群”支持PB级数据存储与高并发访问。

KingbaseES则采用多模融合数据库架构，通过“多语法体系一体化架构”实现一套软件兼容多种数据库语法，支持关系模型、文档模型、全文本、GIS数据、时序等数据的统一存储、混合访问和模型间转换。

2. 性能表现对比

在实际应用场景中，两者性能差异显著：

性能指标	MongoDB	KingbaseES	提升幅度
平均响应时间	3.2s	0.6s	↓81%
最大并发连接数	900	1600	↑78%
故障恢复时间	>5分钟	<10秒	↓97%
数据一致性错误	年均2起	0起	100%改善

KingbaseES通过读写分离集群架构加智能查询优化器，在高并发场景下表现尤为出色。在某电子证照系统案例中，并发连接数从1000多提升到1600多，联合查询的响应时间从5秒缩短到了0.3秒。

3. 安全合规能力

MongoDB社区版安全功能相对简单，仅支持简单密码认证，缺乏传输加密、存储加密和细粒度权限控制，难以满足政务、金融等关键行业的合规性要求。

相比之下，KingbaseES构建了纵深防御体系，提供访问控制、传输加密、存储加密、安全审计等全方位安全防护，已获得EAL4+级安全认证，满足政务系统对数据安全的严格要求。

三、增删改查操作代码对比示例

1. 数据插入操作

MongoDB插入操作：

// 单条文档插入
db.products.insertOne({
  sku: "A100",
  name: "服务器机箱",
  qty: 50,
  category: "硬件设备"
});

// 批量文档插入
db.products.insertMany([
  { sku: "B200", name: "数据库软件", qty: 100, category: "软件" },
  { sku: "C300", name: "网络交换机", qty: 30, category: "网络设备" }
]);

KingbaseES插入操作：

-- 创建表结构
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  sku VARCHAR(50) NOT NULL,
  name VARCHAR(100),
  qty INTEGER,
  category VARCHAR(50),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 单条数据插入
INSERT INTO products(sku, name, qty, category) 
VALUES ('A100', '服务器机箱', 50, '硬件设备');

-- 批量数据插入
INSERT INTO products(sku, name, qty, category) 
VALUES 
  ('B200', '数据库软件', 100, '软件'),
  ('C300', '网络交换机', 30, '网络设备');

关键差异说明： KingbaseES作为关系型数据库，需要先定义表结构，确保数据完整性和一致性。而MongoDB无需预定义模式，灵活性更高，但缺乏数据约束。

2. 数据查询操作

MongoDB查询操作：

// 查询所有文档
db.products.find();

// 条件查询
db.products.find({ category: "硬件设备", qty: { $gt: 20 } });

// 排序和限制
db.products.find().sort({ qty: -1 }).limit(5);

// 复杂条件查询
db.products.find({
  $or: [
    { qty: { $lt: 10 } },
    { category: "软件" }
  ]
});

KingbaseES查询操作：

-- 查询所有记录
SELECT * FROM products;

-- 条件查询
SELECT sku, name, qty, category 
FROM products 
WHERE category = '硬件设备' AND qty > 20;

-- 排序和限制
SELECT sku, name, qty, category
FROM products 
ORDER BY qty DESC 
LIMIT 5;

-- 复杂条件查询
SELECT sku, name, qty, category
FROM products 
WHERE qty < 10 OR category = '软件';

查询性能对比： 在某制造业库存系统案例中，KingbaseES将平均查询响应时间从3.2秒降低到0.6秒，降幅达81%，这得益于其智能查询优化器和索引优化策略。

3. 数据更新操作

MongoDB更新操作：

// 更新单个文档
db.products.updateOne(
  { sku: "A100" },
  { $set: { qty: 45, updated_at: new Date() } }
);

// 更新多个文档
db.products.updateMany(
  { category: "软件" },
  { $inc: { qty: 10 } }
);

// 查找并更新文档
db.products.findOneAndUpdate(
  { sku: "B200" },
  { $set: { name: "企业级数据库软件" } },
  { returnNewDocument: true }
);

KingbaseES更新操作：

-- 更新单条记录
UPDATE products 
SET qty = 45, updated_at = CURRENT_TIMESTAMP 
WHERE sku = 'A100';

-- 更新多条记录
UPDATE products 
SET qty = qty + 10 
WHERE category = '软件';

-- 使用RETURNING子句返回更新后的数据
UPDATE products 
SET name = '企业级数据库软件' 
WHERE sku = 'B200' 
RETURNING id, sku, name, qty, category;

事务支持差异： MongoDB在分布式环境下的多文档事务支持有限，而有16MB大小限制。KingbaseES作为关系型数据库，提供完整的ACID事务支持，确保数据一致性。

4. 数据删除操作

MongoDB删除操作：

// 删除单个文档
db.products.deleteOne({ sku: "C300" });

// 条件删除多个文档
db.products.deleteMany({ qty: { $lt: 5 } });

// 删除整个集合
db.products.drop();

KingbaseES删除操作：

-- 删除单条记录
DELETE FROM products WHERE sku = 'C300';

-- 条件删除多条记录
DELETE FROM products WHERE qty < 5;

-- 清空整个表
TRUNCATE TABLE products;

-- 删除表结构
DROP TABLE products;

安全机制对比： KingbaseES在数据删除方面提供更细粒度的权限控制和审计功能，所有敏感操作均可被记录和监控，满足等保2.0三级要求。

四、KingbaseES的MongoDB兼容性特性

令人印象深刻的是，KingbaseES通过可插拔异构兼容框架，实现了对MongoDB协议的原生兼容。这意味着应用程序几乎不需要修改代码，只需更改数据库连接地址，就能平滑迁移。

兼容性覆盖范围：

协议兼容：完整支持MongoDB Wire Protocol，现有MongoDB客户端可直接连接
查询语言兼容：支持MongoDB Query Language（MQL）的大部分语法和操作符
API兼容：兼容常见的MongoDB驱动接口，如insertOne、find、updateMany等

已支持的MongoDB操作示例：

根据金仓官方文档，以下MongoDB操作在KingbaseES中均已得到支持：

// 插入操作
db.collection.insertOne() 和 db.collection.insertMany()

// 查询操作  
db.collection.find() 和 db.collection.findOne()

// 更新操作
db.collection.updateOne(), db.collection.updateMany(), db.collection.replaceOne()

// 删除操作
db.collection.deleteOne() 和 db.collection.deleteMany()

// 聚合操作
db.collection.aggregate()

// 索引操作
db.collection.createIndex(), db.collection.getIndexes() 等