Convert a Replica Set to a Sharded Cluster

Deploy the config server replica set members.

Select the tab for your authentication mechanism:

security:
   keyFile: <PATH_TO_KEYFILE>
replication:
   replSetName: configReplSet
sharding:
   clusterRole: configsvr
net:
   bindIp: localhost,<hostname(s)>

Deploy the mongod with your specified configuration:

mongod --config <PATH_TO_CONFIG_FILE>

The config servers use the default data directory /data/configdb and the default port 27019.

Connect to one of the config servers.

mongosh "mongodb://mongodb7.example.net:27019"

Initiate the config server replica set.

To initiate the replica set, run rs.initiate():

rs.initiate( {
   _id: "configReplSet",
   configsvr: true,
   members: [
      { _id: 0, host: "mongodb7.example.net:27019" },
      { _id: 1, host: "mongodb8.example.net:27019" },
      { _id: 2, host: "mongodb9.example.net:27019" }
   ]
} )

The preceding command uses the localhost exception to perform administrative actions without authentication.

Create a configuration file for the mongos.

sharding:
   configDB: configReplSet/mongodb7.example.net:27019,mongodb8.example.net:27019,mongodb9.example.net:27019
security:
   keyFile: <PATH_TO_KEYFILE>
net:
   bindIp: localhost,<hostname(s)>

Deploy the mongos.

Deploy the mongos with your specified configuration:

mongos --config <PATH_TO_CONFIG_FILE>

Connect to the mongos.

Use mongosh to connect to the mongos.

mongosh "mongodb://mongodb6.example.net:27017"

Create an administrative user.

The following db.createUser() method creates a user named admin01 with the clusterManager and restore roles:

use admin

db.createUser(
   {
      user: "admin01",
      pwd: passwordPrompt(),
      roles: [
         { role: "clusterManager", db: "admin" },
         { role: "restore", db: "admin" }
      ]
   }
)

After you run the command, the database prompts you to enter a password for the admin01 user.

Connect to a member of your initial replica set.

Use mongosh to connect to one of the members of your initial replica set.

mongosh "mongodb://<username>@mongodb0.example.net:27017"

Determine the replica set's primary and secondaries.

Run rs.status() to determine the primary and secondaries:

rs.status()

In the command output, the replSetGetStatus.members[n].stateStr field indicates which member is the primary and which members are secondaries.

Restart the secondaries with the --shardsvr option.

mongosh "mongodb://<username>@<host>:<port>"

use admin
db.shutdownServer()

security:
   keyFile: <PATH_TO_KEYFILE>
replication:
   replSetName: rs0
sharding:
   clusterRole: shardsvr
net:
   port: 27017
   bindIp: localhost,<hostname(s)>

mongod --config <PATH_TO_CONFIG_FILE>

Restart the primary with the --shardsvr option.

mongosh "mongodb://<username>@<host>:<port>"

rs.stepDown()

rs.status()

use admin
db.shutdownServer()

security:
   keyFile: <PATH_TO_KEYFILE>
replication:
   replSetName: rs0
sharding:
   clusterRole: shardsvr
net:
   port: 27017
   bindIp: localhost,<hostname(s)>

mongod --config <PATH_TO_CONFIG_FILE>

Connect to the mongos as your cluster's administrative user.

The mongos instance is running on host mongodb6.example.net.

mongosh "mongodb://admin01@mongodb6.example.net:27017"

This command authenticates you as the admin01 user you created on the sharded cluster. After you enter the command, enter your user's password.

Add the shard.

To add a shard to the cluster, run the sh.addShard() method:

sh.addShard( "rs0/mongodb0.example.net:27017,mongodb1.example.net:27017,mongodb2.example.net:27017" )

Start each member of the replica set.

security:
   keyFile: <PATH_TO_KEYFILE>
replication:
   replSetName: rs1
sharding:
   clusterRole: shardsvr
net:
   bindIp: localhost,<hostname(s)>

Deploy the mongod with your specified configuration:

mongod --config <PATH_TO_CONFIG_FILE>

Repeat the previous step for the other two members of the rs1 replica set.

Connect to a replica set member.

Use mongosh to connect to one of the replica set members. For example:例如：

mongosh "mongodb://mongodb3.example.net:27018"

Initiate the replica set.

In mongosh, run the rs.initiate() method to initiate a replica set that contains the current member:

rs.initiate( {
   _id : "rs1",
   members: [
       { _id: 0, host: "mongodb3.example.net:27018" },
       { _id: 1, host: "mongodb4.example.net:27018" },
       { _id: 2, host: "mongodb5.example.net:27018" }
   ]
} )

The preceding command requires the localhost exception to perform administrative actions without authentication.

Add an administrative user for the replica set.

After you deploy the replica set, use the localhost exception to create the replica set's first user.

rs.status()

mongosh "mongodb://mongodb4.example.net:27018"

use admin

db.createUser(
   {
      user: "rs1Admin",
      pwd: passwordPrompt(),
      roles: [
         { role: "userAdmin", db: "admin" }
      ]
   }
)

Connect mongosh to the mongos.

Run the following command from the command line to connect to the mongos instance running on host mongodb6.example.net:

mongosh "mongodb://admin01@mongodb6.example.net:27017/admin"

This command authenticates you as the admin01 user you created on the sharded cluster. After you enter the command, enter your user's password.

Add the second shard.

After you connect to the mongos, add the replica set rs1 as a shard to the cluster with the sh.addShard() method:

sh.addShard( "rs1/mongodb3.example.net:27018,mongodb4.example.net:27018,mongodb5.example.net:27018" )

Determine the shard key.

Determine the shard key for the collection. The shard key indicates how MongoDB distributes the documents between shards. Good shard keys:

• Have values that are evenly distributed among all documents.
• Group documents that are often accessed at the same time into contiguous chunks.
• Allow for effective distribution of activity among shards.

For more information, see Choose a Shard Key.

This procedure uses the number field as the shard key for the test_collection collection.

Create an index on the shard key.

Before you shard a non-empty collection, create an index on the shard key:

use test
db.test_collection.createIndex( { "number" : 1 } )

Shard the collection.

In the test database, shard the test_collection. Specify number as the shard key.

sh.shardCollection( "test.test_collection", { "number" : 1 } )

The next time that the balancer runs, it redistributes chunks of documents between shards. As clients insert additional documents into this collection, the mongos routes the documents to the appropriate shard.