Converter um conjunto de réplicas em um cluster fragmentado

Implemente os membros do conjunto de réplica do servidor de configuração.

Selecione a guia do mecanismo de autenticação:

Implemente o mongod com sua configuração especificada:

mongod --config <PATH_TO_CONFIG_FILE>

Os servidores de configuração usam o directoria de dados padrão /data/configdb e a porta padrão 27019.

Conecte-se a um dos servidores de configuração.

Inicie o conjunto de réplica do servidor de configuração.

Para iniciar o conjunto de réplicas, execute 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" }
   ]
} )

O comando anterior utiliza a exceção Localhost para executar ações administrativas sem autenticação.

Crie um arquivo de configuração para os mongos.

Implemente os mongos.

Implemente o mongos com sua configuração especificada:

mongos --config <PATH_TO_CONFIG_FILE>

Conecte-se ao mongos.

Use mongosh para se conectar ao mongos.

Crie um usuário administrativo.

O método db.createUser() a seguir cria um usuário chamado admin01 com as funções clusterManager e restore:

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

Após executar o comando, o banco de dados solicita que você insira uma senha para o usuário do admin01.

Conecte-se a um membro do seu conjunto de réplicas inicial.

Use mongosh para se conectar a um dos membros do seu conjunto de réplicas inicial.

Determine o primário e os secundários do conjunto de réplicas.

Execute rs.status() para determinar a primária e as secundárias:

rs.status()

Na saída de comando, o campo replSetGetStatus.members[n].stateStr indica qual membro é o principal e quais membros são secundários.

Reinicie os segundo com a opção --shardsvr .

Reinicie o primary com a opção --shardsvr .

Conecte ao mongos como o usuário administrativo do seu cluster.

A instância do mongos está sendo executada no host mongodb6.example.net.

Esse comando autentica você como o usuário admin01 que você criou no cluster fragmentado. Depois de inserir o comando, digite a senha do usuário.

Adicione o fragmento.

Para adicionar um fragmento ao cluster, execute o método sh.addShard():

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

Inicie cada membro do conjunto de réplicas.

Implemente o mongod com sua configuração especificada:

mongod --config <PATH_TO_CONFIG_FILE>

Repita a etapa anterior para os outros dois membros do conjunto de réplicas do rs1 .

Conecte a um membro do conjunto de réplicas.

Use mongosh para se conectar a um dos membros do conjunto de réplicas. Por exemplo:

Inicie o conjunto de réplicas.

No mongosh, execute o método rs.initiate() para iniciar um conjunto de réplica que contém o membro atual:

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" }
   ]
} )

O comando anterior exige que a exceção Localhost execute ações administrativas sem autenticação.

Adicione um usuário administrativo para o conjunto de réplicas.

Depois de implantar o conjunto de réplicas, use a exceção localhost para criar o primeiro usuário do conjunto de réplicas.

rs.status()

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

Conecte mongosh ao mongos.

Execute o seguinte comando a partir da linha de comando para se conectar à instância do mongos executando no host mongodb6.example.net:

Esse comando autentica você como o usuário admin01 que você criou no cluster fragmentado. Depois de inserir o comando, digite a senha do usuário.

Adicione o segundo fragmento.

Após conectar ao mongos, adicione o conjunto de réplicas rs1 como um fragmento ao cluster com o método sh.addShard() :

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

Determine a chave de fragmento.

Determine a chave fragmentada para a coleção. A tecla Shard indica como o MongoDB distribui os documentos entre fragmentos. Boas chaves de fragmentos:

• Ter valores distribuídos uniformemente entre todos os documentos.

• Agrupe documentos que são frequentemente acessados ao mesmo tempo em chunks contíguas.

• Permitir a distribuição eficaz da atividade entre os fragmentos.

Para mais informações, consulte Escolher uma chave de fragmento.

Este procedimento utiliza o campo number como a chave de fragmento para a coleção test_collection.

Crie um índice na chave de fragmento.

Antes de fragmentar uma coleção não vazia, crie um índice na chave de fragmento:

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

Fragmentar a coleção.

No banco de dados do test, grite o test_collection. Especifique number como a chave de fragmento.

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

Da próxima vez que o balanceador for executado, ele redistribuirá blocos de documentos entre fragmentos. À medida que os clientes inserem documentos adicionais nessa coleção, o mongos roteia os documentos para o fragmento apropriado.