本文最后更新于：2025年2月14日 下午

之前我们介绍过 MongoDB 分片和 GridFS 的工作原理，本文用 Docker 进行实战部署，并在 GridFS 上进行分片测试。

基础准备

实战目标

  1. Docker compose 配置化部署 MongoDB 服务
    • 配置 3 个 config 服务器
    • 配置 3 个 分片存储服务器
    • 配置 1 个 路由服务器
  2. 脚本启动、初始化
  3. 实现 GridFS 数据分片
  4. 添加 GridFS 数据
  5. 查看分片效果

环境准备

环境配置

  • 安装 Docker
  • 安装 mongodbsh
  • 配置 docker compose

创建 mongo 网络

检查名为mongo的网络是否已经存在

1
docker network ls

如果mongo网络不存在，需要手动创建：

1
docker network create mongo

在 docker compose 文件中添加网络配置

1
2
3
networks:
  mongo:
    external: true

重新启动服务

1
docker-compose -f fates-mongo-compose.yaml up -d

注意事项

  • 如果你正在使用多个Docker Compose文件或者与其他项目共享网络，确保所有项目都使用相同的网络名称。
  • 如果你之前已经运行了Docker Compose并且删除了网络，你可能需要先删除旧的容器和卷，然后重新创建网络。

检查时区文件

构建时间同步的多个 MongoDB 服务需要统一的时区信息，通过共用本机的 /etc/localtime文件实现。

检查该文件是否存在，如果不存在则需要手动创建符号链接，以 Shanghai 时区为例：

1
sudo ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

更新系统时钟（可选操作）

1
sudo hwclock --systohc

验证设置

验证时区设置是否正确：

1
timedatectl

创建文件夹

在根目录创建这样的文件夹结构：

1
2
3
4
5
6
7
/mongodata
├── config1
├── config2
├── config3
├── shard1
├── shard2
└── shard3

赋予其他用户读写权限

1
sudo chmod -R 757 /mongodata

docker-compose 配置

服务定义

在services部分定义不同的MongoDB容器，包括分片（shard）、配置服务器（config）和路由进程（mongos）。

shard
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
services:
  shard1:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_shard1
    # --shardsvr: 这个参数仅仅只是将默认的27017端口改为27018,如果指定--port参数，可用不需要这个参数
    # --directoryperdb：每个数据库使用单独的文件夹
    # --replSet 副本集
    command: mongod --shardsvr --directoryperdb --replSet shard1  --wiredTigerCacheSizeGB 6
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/shard1:/data/db
    privileged: true
    # mem_limit: 16000000000
    networks:
      - mongo
config
1
2
3
4
5
6
7
8
9
10
11
config1:
  image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
  container_name: mongo_config1
  # --configsvr: 这个参数仅仅是将默认端口由27017改为27019, 如果指定--port可不添加该参数
  command: mongod --configsvr --directoryperdb --replSet fates-mongo-config
  restart: always
  volumes:
    - /etc/localtime:/etc/localtime
    - /mongodata/config1:/data/configdb
  networks:
    - mongo
mongos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
mongos:
  image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
  container_name: mongo_mongos
  command: mongos --configdb fates-mongo-config/config1:27019,config2:27019,config3:27019 --bind_ip 0.0.0.0 --port 27017
  ports:
   - 27017:27017
restart: always
  volumes:
    - /etc/localtime:/etc/localtime
  depends_on:
    - config1
    - config2
    - config3
  networks:
    - mongo

command 解释

1
mongod --shardsvr --directoryperdb --replSet shard1 --wiredTigerCacheSizeGB 2 --auth

此命令用于启动一个 MongoDB 实例，并为其配置多个关键参数，具体含义如下：

1. --shardsvr

  • 作用：指定该实例作为 分片集群中的一个分片节点。
  • 默认端口：27018（普通 mongod 默认端口为 27017）。
  • 分片集群角色：
    • 分片节点负责存储实际数据，并将数据分布到集群中。
    • 需与其他分片、配置服务器（config servers）和路由服务器（mongos）协同工作。

2. --directoryperdb

  • 作用：启用 每个数据库独立存储目录。
  • 文件管理：
    • 默认情况下，所有数据库文件存储在统一的 data/db 目录中。
    • 启用后，每个数据库会有自己的子目录（如 data/db/db1、data/db/db2），便于管理和维护。

3. --replSet shard1

  • 作用：将该分片节点配置为 副本集 shard1 的成员。
  • 副本集的意义：
    • 每个分片通常是一个副本集，以提高数据可用性和容错性。
    • 副本集需包含多个节点（至少 3 个推荐），通过选举机制实现自动故障转移。
  • 初始化步骤：
    • 需在启动后执行 rs.initiate() 和 rs.add() 初始化副本集，添加其他成员。

4. --wiredTigerCacheSizeGB 2

  • 作用：设置 WiredTiger 存储引擎的缓存大小为 2GB。
  • 缓存机制：
    • WiredTiger 是 MongoDB 默认存储引擎，缓存用于加速数据和索引的访问。
    • 建议值为系统内存的 50% 以下（例如 64GB 内存可设为 30GB）。
  • 优化意义：避免占用过多内存影响其他服务，此处限制为 2GB。

5. --auth

  • 作用：启用 访问控制，强制要求客户端连接时进行身份验证。
  • 安全要求：
    • 需先创建管理员用户（如 admin），再为应用程序创建普通用户。
    • 用户需分配角色（如 readWrite、dbAdmin）以限制权限。

网络配置

1
2
3
networks:
  mongo:
    external: true

docker-compose.yml 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
services:
  shard1:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_shard1
    command: mongod --shardsvr --directoryperdb --replSet shard1  --wiredTigerCacheSizeGB 6
    restart: always
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/shard1:/data/db
    privileged: true
    networks:
      - mongo   

  shard2:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_shard2
    command: mongod --shardsvr --directoryperdb --replSet shard2  --wiredTigerCacheSizeGB 6
    restart: always
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/shard2:/data/db
    privileged: true
    networks:
      - mongo

  shard3:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_shard3
    command: mongod --shardsvr --directoryperdb --replSet shard3  --wiredTigerCacheSizeGB 6
    restart: always
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/shard3:/data/db
    privileged: true
    networks:
      - mongo

  config1:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_config1
    command: mongod --configsvr --directoryperdb --replSet fates-mongo-config
    restart: always
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/config1:/data/configdb
    networks:
      - mongo

  config2:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_config2
    restart: always
    command: mongod --configsvr --directoryperdb --replSet fates-mongo-config
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/config2:/data/configdb
    networks:
      - mongo

  config3:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_config3
    restart: always
    command: mongod --configsvr --directoryperdb --replSet fates-mongo-config
    volumes:
      - /etc/localtime:/etc/localtime
      - /mongodata/config3:/data/configdb
    networks:
      - mongo

  mongos:
    image: mongodb/mongodb-community-server:7.0.12-ubuntu2204
    container_name: mongo_mongos
    restart: always
    command: mongos --configdb fates-mongo-config/config1:27019,config2:27019,config3:27019 --bind_ip 0.0.0.0 --port 27017
    ports:
     - 27017:27017
    volumes:
      - /etc/localtime:/etc/localtime
    depends_on:
      - config1
      - config2
      - config3
    networks:
      - mongo    
networks:
  mongo:
    external: true

构建容器

用脚本执行，文件 mongo_deploy.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#!/bin/bash

# 检查当前用户是否是root
if [ "$(id -u)" -ne 0 ]; then
   echo "此脚本需要以root用户运行，请使用sudo运行此脚本。"
   exit 1
fi

# 定义一个函数 create_dir_if_not_exists
create_dir_if_not_exists() {
  local dir_path="$1"
  # 检查目录是否存在
  if [ ! -d "$dir_path" ]; then
    # 如果不存在，则创建目录
    mkdir -p "$dir_path"
    echo "目录 '$dir_path' 已创建。"
  else
    # 如果存在，则打印消息并跳过创建
    echo "目录 '$dir_path' 已存在，无需创建。"
  fi
}

# 使用函数创建目录
create_dir_if_not_exists /mongodata/config1
create_dir_if_not_exists /mongodata/config2
create_dir_if_not_exists /mongodata/config3

create_dir_if_not_exists /mongodata/shard1
create_dir_if_not_exists /mongodata/shard2
create_dir_if_not_exists /mongodata/shard3

# 其他用户写权限
echo "修改文件夹权限。"
chmod -R 757 /mongodata


# 启动容器
docker-compose -f docker-compose.yml up -d

echo "睡眠30s，等待mongodb所有容器构建完成"
sleep 30s


docker-compose -f docker-compose.yml exec config1 bash -c "echo 'rs.initiate({_id: \"fates-mongo-config\",configsvr: true, members: [{ _id : 0, host : \"config1:27019\" },{ _id : 1, host : \"config2:27019\" }, { _id : 2, host : \"config3:27019\" }]})' | mongosh --port 27019"

docker-compose -f docker-compose.yml exec shard1 bash -c "echo 'rs.initiate({_id: \"shard1\",members: [{ _id : 0, host : \"shard1:27018\" }]})' | mongosh --port 27018"
docker-compose -f docker-compose.yml exec shard2 bash -c "echo 'rs.initiate({_id: \"shard2\",members: [{ _id : 0, host : \"shard2:27018\" }]})' | mongosh --port 27018"
docker-compose -f docker-compose.yml exec shard3 bash -c "echo 'rs.initiate({_id: \"shard3\",members: [{ _id : 0, host : \"shard3:27018\" }]})' | mongosh --port 27018"

sleep 5s

docker-compose -f docker-compose.yml exec mongos bash -c "echo 'sh.addShard(\"shard1/shard1:27018\")' | mongosh"
sleep 1s
docker-compose -f docker-compose.yml exec mongos bash -c "echo 'sh.addShard(\"shard2/shard2:27018\")' | mongosh"
sleep 1s
docker-compose -f docker-compose.yml exec mongos bash -c "echo 'sh.addShard(\"shard3/shard3:27018\")' | mongosh"

sleep 1s

执行脚本

1
2
chmod +x mongo_deploy.sh
sudo ./mongo_deploy.sh

GridFS 分片

以 vvd 数据库为例

mongosh 进入 mongos 容器的 mongodb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> mongosh
Current Mongosh Log ID:	67177c2e4b6a404e86838725
Connecting to:		mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.2.15
Using MongoDB:		7.0.12
Using Mongosh:		2.2.15
mongosh 2.3.2 is available for download: https://www.mongodb.com/try/download/shell

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

------
   The server generated these startup warnings when booting
   2024-10-22T18:13:59.284+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
------

[direct: mongos] test> use vvd
switched to db vvd
[direct: mongos] vvd>

启用分片，让当前库支持分片

1
sh.enableSharding("vvd")

给 fs.chunks 集合分片

可选创建索引 db.fs.chunks.createIndex( { files_id : 1 , n : 1 } )

1
sh.shardCollection('vvd.fs.chunks',{files_id:'hashed', n:1})

添加 GridFS 数据

需要进入到 mongos 里，我是这么干的：

1
docker exec -it mongo_mongos bash

之后为了找一个测试文件，我进到 /var/log中，把 faillog 文件当作测试文件

1
mongofiles -d myDatabase -c myGridFSBucket put /path/to/your/file.txt

这里-d指定数据库，-c指定GridFS存储桶（如果未指定，默认为fs）。

1
2
cd /var/log
mongofiles -d vvd put faillog

多执行几遍，权当测试文件

查看分片状态

回到刚刚的 mongosh，这时在 vvd 数据库中查看 collections 可以看到 fs.chunks 和 fs.files集合，表明 GridFS 数据添加成功：

1
2
3
[direct: mongos] vvd> show collections
fs.chunks
fs.files

查看数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[direct: mongos] vvd> db.fs.files.find()
[
  {
    _id: ObjectId('67177fa370974ed1e8520d0b'),
    length: Long('3264'),
    chunkSize: 261120,
    uploadDate: ISODate('2024-10-22T10:34:11.711Z'),
    filename: 'faillog',
    metadata: {}
  },
  {
    _id: ObjectId('67177ff87f90b296fcac0d30'),
    length: Long('3264'),
    chunkSize: 261120,
    uploadDate: ISODate('2024-10-22T10:35:36.665Z'),
    filename: 'faillog',
    metadata: {}
  },
...

查看分片状态：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
[direct: mongos] vvd> sh.status()
shardingVersion
{ _id: 1, clusterId: ObjectId('67177b0f7478e63cb9a618a5') }
---
shards
[
  {
    _id: 'shard1',
    host: 'shard1/shard1:27018',
    state: 1,
    topologyTime: Timestamp({ t: 1729592126, i: 2 })
  },
  {
    _id: 'shard2',
    host: 'shard2/shard2:27018',
    state: 1,
    topologyTime: Timestamp({ t: 1729593951, i: 2 })
  },
  {
    _id: 'shard3',
    host: 'shard3/shard3:27018',
    state: 1,
    topologyTime: Timestamp({ t: 1729593958, i: 2 })
  }
]
---
active mongoses
[ { '7.0.12': 1 } ]
---
autosplit
{ 'Currently enabled': 'yes' }
---
balancer
{
  'Currently enabled': 'yes',
  'Failed balancer rounds in last 5 attempts': 0,
  'Currently running': 'no',
  'Migration Results for the last 24 hours': 'No recent migrations'
}
---
databases
[
  {
	{
    database: {
      _id: 'vvd',
      primary: 'shard3',
      partitioned: false,
      version: {
        uuid: UUID('5ffbe210-fe2a-4b96-8b98-f568eab7fbec'),
        timestamp: Timestamp({ t: 1729594145, i: 1 }),
        lastMod: 1
      }
    },
    collections: {
      'vvd.fs.chunks': {
        shardKey: { files_id: 'hashed', n: 1 },
        unique: false,
        balancing: true,
        chunkMetadata: [
          { shard: 'shard1', nChunks: 2 },
          { shard: 'shard2', nChunks: 2 },
          { shard: 'shard3', nChunks: 2 }
        ],
        chunks: [
          { min: { files_id: MinKey(), n: MinKey() }, max: { files_id: Long('-6148914691236517204'), n: MinKey() }, 'on shard': 'shard3', 'last modified': Timestamp({ t: 1, i: 0 }) },
          { min: { files_id: Long('-6148914691236517204'), n: MinKey() }, max: { files_id: Long('-3074457345618258602'), n: MinKey() }, 'on shard': 'shard3', 'last modified': Timestamp({ t: 1, i: 1 }) },
          { min: { files_id: Long('-3074457345618258602'), n: MinKey() }, max: { files_id: Long('0'), n: MinKey() }, 'on shard': 'shard1', 'last modified': Timestamp({ t: 1, i: 2 }) },
          { min: { files_id: Long('0'), n: MinKey() }, max: { files_id: Long('3074457345618258602'), n: MinKey() }, 'on shard': 'shard1', 'last modified': Timestamp({ t: 1, i: 3 }) },
          { min: { files_id: Long('3074457345618258602'), n: MinKey() }, max: { files_id: Long('6148914691236517204'), n: MinKey() }, 'on shard': 'shard2', 'last modified': Timestamp({ t: 1, i: 4 }) },
          { min: { files_id: Long('6148914691236517204'), n: MinKey() }, max: { files_id: MaxKey(), n: MaxKey() }, 'on shard': 'shard2', 'last modified': Timestamp({ t: 1, i: 5 }) }
        ],
        tags: []
      }
    }
  }
]

可以看到添加的数据被分配到三个 mongodb 中。

GridFS 分片成功！

用户管理

之后需要手动进行用户管理：

  1. 连接到 MongoDB
1
mongosh mongodb://host:27017
  1. 创建 root 用户
1
2
3
4
5
6
7
8
use admin
db.createUser(
    {
        user:"root",
        pwd:"passwd",
        roles:["root"]
    }
)
  1. 核心数据库管理者，我们的 mongodb 数据库命名为 test_db
1
2
3
4
5
6
7
8
9
10
11
12
13
db.createUser({
    user:"manager",
    pwd:"passwd",
    customData:{
        name:'vvd',
        email:'zywvvd@mail.ustc.edu.cn',
        age:33,
    },
    roles:[
        {role:"readWrite",db:"test_db"},
        'read'// 对其他数据库有只读权限，对 test_db 是读写权限
    ]
})
  1. 数据读取者，对 test_db 仅有只读权限：
1
2
3
4
5
6
7
8
9
10
11
12
db.createUser({
    user:"filereader",
    pwd:"passwd",
    customData:{
        name:'reader',
        email:'reader@test.cn',
        age:18,
    },
    roles:[
        {role:"read",db:"test_db"}
    ]
})

  1. 开启访问控制

    mongodb 默认关闭访问控制，需要在创建用户后手动开启

    1
    docker exec -it mongo_mongos bash

    在 mongos 容器中执行命令：

    1
    mongod --auth

迁移

尝试了将本机 /mongodata 文件夹完整移动到服务器，并启动同样配置的分片服务，可以成功迁移数据库。

可能存在其他未知风险。

问题排查

  • 如果 容器启动后瞬间 Down 掉，可以通过 docker logs <container_id_or_name> 查看问题原因，我遇到的大多都是磁盘映射的权限问题，

    听说 777 大法百毒不侵

  • 如果 Mongodb 报很多奇怪的错误可以排查是不是版本有问题，6.0 以后mongo 会变成 mongosh

  • MongoDB 删除集合中的数据后不会立刻让出磁盘空间，需要调用：

    1
    2
    3
    4
    # 4.2 版本之前
    db.repairDatabase();
    # 4.2 版本之后
    db.runCommand({ compact: 'yourCollectionName' });

    如果是分片数据集，则需要进入分片 mongo 中运行命令

    删除集合也可以解决问题。

构建初始用户

https://github.com/docker-library/mongo/issues/475

1
openssl rand -base64 756 > replica.key
  • 构建带有该 key 的容器
1
2
3
4
5
6
7
8
FROM mongodb/mongodb-community-server:7.0.12-ubuntu2204
USER root
COPY replica.key /data/db/replica.key
RUN chown 101:101 /data/db/replica.key
RUN chmod 400 /data/db/replica.key
ENV MONGO_INITDB_DATABASE=admin
ENV MONGO_INITDB_ROOT_USERNAM=root
ENV MONGO_INITDB_ROOT_PASSWORD=root
  • 构建镜像：
1
docker build --no-cache -t mongo:1.0.1 .
  • docker-compose.yml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
services:
  shard1:
    image: mongo:1.0.1
    container_name: mongo_shard1
    restart: always
    entrypoint:
      - bash
      - -c
      - |
          if [ ! -f /data/db/replica.key ]; then
            echo "错误：密钥文件 /data/db/replica.key 不存在！"
            exit 1
          fi
          chmod 400 /data/db/replica.key
          chown 101:101 /data/db/replica.key
          mongod --shardsvr --directoryperdb --replSet shard1 --wiredTigerCacheSizeGB 6 --keyFile /data/db/replica.key --bind_ip_all
    volumes:
      - /etc/localtime:/etc/localtime
      - /data/mongo/shard1/db:/data/db
      - /data/mongo/shard1/configdb:/data/configdb
      - /data/mongo/shard1/share:/share
    privileged: true
    networks:
      - mongo   

  shard2:
    image: mongo:1.0.1
    container_name: mongo_shard2
    restart: always
    entrypoint:
      - bash
      - -c
      - |
          if [ ! -f /data/db/replica.key ]; then
            echo "错误：密钥文件 /data/db/replica.key 不存在！"
            exit 1
          fi
          chmod 400 /data/db/replica.key
          chown 101:101 /data/db/replica.key
          mongod --shardsvr --directoryperdb --replSet shard2 --wiredTigerCacheSizeGB 6 --keyFile /data/db/replica.key --bind_ip_all
    volumes:
      - /etc/localtime:/etc/localtime
      - /data/mongo/shard2/db:/data/db
      - /data/mongo/shard2/configdb:/data/configdb
      - /data/mongo/shard2/share:/share
    privileged: true
    networks:
      - mongo

  config1:
    image: mongo:1.0.1
    container_name: mongo_config1
    restart: always
    entrypoint:
      - bash
      - -c
      - |
          if [ ! -f /data/db/replica.key ]; then
            echo "错误：密钥文件 /data/db/replica.key 不存在！"
            exit 1
          fi
          chmod 400 /data/db/replica.key
          chown 101:101 /data/db/replica.key
          mongod --configsvr --directoryperdb --replSet fates-mongo-config  --keyFile /data/db/replica.key --bind_ip_all
    volumes:
      - /etc/localtime:/etc/localtime
      - /data/mongo/config1/db:/data/db
      - /data/mongo/config1/configdb:/data/configdb
      - /data/mongo/config1/share:/share
    networks:
      - mongo

  mongos:
    image: mongo:1.0.1
    container_name: mongo_mongos
    restart: always
    command: mongos --configdb fates-mongo-config/config1:27019,config2:27019 --bind_ip 0.0.0.0 --port 27017
    ports:
     - 27010-27017:27010-27017
    volumes:
      - /etc/localtime:/etc/localtime
      - /data/mongo/mongos/db:/data/db
      - /data/mongo/mongos/configdb:/data/configdb
      - /data/mongo/mongos/share:/share
    depends_on:
      - config1
    networks:
      - mongo

networks:
  mongo:
    external: true

可以建立不崩溃的容器，但是没有成功创建默认用户。

参考资料



文章链接：
https://www.zywvvd.com/notes/coding/dataset/mongodb-slice-docker/mongodb-slice-docker/

“觉得不错的话，给点打赏吧 ୧(๑•̀⌄•́๑)૭”

微信二维码

微信支付

支付宝二维码

支付宝支付

Coding > Database > MongoDB
#Coding #Database #MongoDB
MongoDB 分片实战 GridFS
https://www.zywvvd.com/notes/coding/dataset/mongodb-slice-docker/mongodb-slice-docker/
作者
Yiwei Zhang
发布于
2024年10月22日
许可协议