Converter um conjunto de réplicas autogerenciadas em um cluster fragmentado

Obtenha os usuários e roles existentes a partir do conjunto de réplicas

Para obter usuários e funções existentes, execute mongodump:

mongodump -d=admin --out=adminDump -u <adminUser> -p <password> --host <replicaSetURI> --dumpDbUsersAndRoles

Implemente o Config Server Replica Set

Implemente um conjunto de réplica de três membros para os servidores de configuração. Neste exemplo, os servidores de configuração usam os seguintes hosts:

• mongodb7.example.net

• mongodb8.example.net

• mongodb9.example.net

1. Configure os servidores de configuração

   Configure uma instância mongod em cada host do servidor de configuração. Especifique essas opções no arquivo de configuração para cada instância mongod:

   Opção	Valor
   replication.replSetName	configReplSet
   sharding.clusterRole	configsvr
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongod deve escutar conexões de cliente.

   replication:
     replSetName: configReplSet
   sharding:
     clusterRole: configsvr
   net:
     bindIp: localhost,<ipaddress>

   Inclua opções adicionais conforme apropriado para seu sistema.

2. Inicie os servidores de configuraçã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.

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

   Utilize o mongosh para conectar a um dos servidores de configuração. Por exemplo:

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

4. 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.

   Importante

   Execute rs.initiate() em apenas uma e apenas uma instânciamongod para o conjunto de réplicas.

Restaurar usuários e roles existentes para a nova configuração

Restaure os usuários e as funções existentes que você obteve ao executar mongodump.

mongorestore ./adminDump --nsInclude "admin.*" --host <configPrimaryURI>

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

A saída da execução desse comando pode ser semelhante a:

0 document(s) restored successfully

Essa mensagem não indica um problema. Essa saída significa que os documentos 0, exceto os usuários e as funções, foram restaurados.

Conjunto de réplicas do servidor de configuração segura

Reconfigurar e reiniciar o conjunto de réplicas do servidor de configuração.

1. Reconfigurar os servidores de configuração

   Selecione a guia do mecanismo de autenticação:

   Autenticação de arquivo-chave

   Autenticação X.509

   Reinicie uma instância mongod em cada um destes hosts:

   • mongodb7.example.net

   • mongodb8.example.net

   • mongodb9.example.net

   Especifique estas opções no arquivo de configuração para cada instância mongod:

   Opção	Valor
   security.keyFile	O caminho para o arquivo-chave usado para seu conjunto de réplicas inicial.

   security:
      keyFile: <PATH_TO_KEYFILE>
   replication:
      replSetName: configReplSet
   sharding:
      clusterRole: configsvr
   net:
      bindIp: localhost,<ipaddress>

   Inclua opções adicionais conforme apropriado para seu sistema.

   Reinicie uma instância mongod em cada um destes hosts:

   • mongodb7.example.net

   • mongodb8.example.net

   • mongodb9.example.net

   Especifique essas opções no arquivo de configuração para cada instância mongod, além das opções que você já configurou:

   Opção	Valor
   security.clusterAuthMode	x509
   net.tls.mode	requireTLS
   net.tls.certificateKeyFile	O caminho absoluto para o arquivo .pem que contém o certificado e a chave TLS.
   net.tls.CAFile	O caminho absoluto para o arquivo .pem que contém a sequência de certificados raiz da autoridade de certificação.
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongod deve escutar conexões de cliente. AVISO: antes de vincular a um host não local (por exemplo, acessívelIP publicamente), certifique-se de ter protegido seu cluster contra o acesso não autorizado. Para obter uma lista completa de recomendações de segurança, consulte a Lista de verificação de segurança para implementações autogerenciadas. No mínimo,procure habilitar a autenticação e fortalecer a infraestrutura de rede.

   sharding:
      clusterRole: configsvr
   replication:
      replSetName: configReplSet
   security:
      clusterAuthMode: x509
   net:
      tls:
         mode: requireTLS
         certificateKeyFile: <FILE_WITH_COMBINED_CERT_AND_KEY>
         CAFile: <CA_FILE>
      bindIp: localhost,<ipaddress>

   Inclua opções adicionais conforme apropriado para sua implantação, como net.tls.certificateKeyFilePassword se o arquivo de chave de certificado TLS estiver criptografado com uma senha.

2. Reinicie o MongoDB.

   Reinicie o mongod com sua configuração especificada:

   mongod --config <PATH_TO_CONFIG_FILE> --shutdown
   mongod --config <PATH_TO_CONFIG_FILE>

Implemente o mongos

O mongos fornece a interface entre os aplicativos do cliente e o cluster fragmentado.

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

   Autenticação de arquivo-chave

   Autenticação X.509

   Especifique estas opções em seu arquivo de configuração do mongos:

   Opção	Valor
   sharding.configDB	configReplSet, seguido por uma barra / e pelo menos um dos nomes de host e portas do servidor de configuração.
   security.keyFile	O caminho para o arquivo-chave usado para seu conjunto de réplicas inicial.
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongos deve escutar conexões de cliente.

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

   Inclua opções adicionais conforme apropriado para seu sistema.

   Especifique estas opções em seu arquivo de configuração do mongos:

   Opção	Valor
   sharding.configDB	configReplSet, seguido por uma barra / e pelo menos um dos nomes de host e portas do servidor de configuração.
   security.clusterAuthMode	x509
   net.tls.mode	requireTLS
   net.tls.certificateKeyFile	O caminho absoluto para o arquivo .pem que contém o certificado e a chave TLS.
   net.tls.CAFile	O caminho absoluto para o arquivo .pem que contém a sequência de certificados raiz da autoridade de certificação.
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongos deve escutar conexões de cliente.

   sharding:
      configDB: configReplSet/mongodb7.example.net:27019,mongodb8.example.net:27019,mongodb9.example.net:27019
   security:
      clusterAuthMode: x509
   net:
      tls:
         mode: requireTLS
         certificateKeyFile: <FILE_WITH_COMBINED_CERT_AND_KEY>
         CAFile: <CA_FILE>
      bindIp: localhost,<ipaddress>

   Inclua quaisquer opções adicionais apropriadas para sua implantação.

2. Implemente os mongos.

   Implemente o mongos com sua configuração especificada:

   mongos --config <PATH_TO_CONFIG_FILE>

Reinicie o conjunto de réplicas iniciais como fragmento

Neste exemplo, seu conjunto de réplicas inicial é um conjunto de réplicas de três membros. Essa etapa atualiza o conjunto inicial de réplicas para que ele possa ser adicionado como um fragmento ao seu cluster fragmentado.

O conjunto de réplicas é executado nestes hosts:

• mongodb0.example.net:27017

• mongodb1.example.net:27017

• mongodb2.example.net:27017

Para clusters fragmentados, você deve definir a função de cada instância mongod no fragmento como shardsvr. Para especificar a função do servidor, defina a configuração sharding.clusterRole no arquivo de configuração mongod.

1. 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.

   Autenticação de arquivo-chave

   Autenticação X.509

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

   Se sua implantação usar a autenticação x.509, especifique estas mongosh opções:

   • --tls

   • --tlsCAFile

   • --tlsCertificateKeyFile

   Por exemplo:

   mongosh "mongodb://<username>@mongodb0.example.net:27017" --tls --tlsCAFile <CA_FILE> --tlsCertificateKeyFile <filename>

2. 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.

3. Reinicie os secundários com a opção --shardsvr.

   Aviso

   Essa etapa exige algum tempo de inatividade para os aplicativos conectados aos secundários do conjunto de réplicas.

   Autenticação de arquivo-chave

   Autenticação X.509

   1. Conecte-se a um secundário.

      Utilize mongosh para se conectar a um dos secundários.

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

   2. Desative o secundário.

      Execute os seguintes comandos:

      use admin
      db.shutdownServer()

   3. Edite o arquivo de configuração do secundário.

      No arquivo de configuração do secundário, defina sharding.clusterRole para shardsvr:

      security:
         keyFile: <PATH_TO_KEYFILE>
      replication:
        replSetName: rs0
      sharding:
         clusterRole: shardsvr
      net:
         port: 27017
         bindIp: localhost,<ipaddress>

      Inclua opções adicionais conforme apropriado para seu sistema.

   4. Reinicie o secundário como um servidor shard.

      Execute o seguinte comando no host que contém o secundário:

      mongod --config <PATH_TO_CONFIG_FILE>

   5. Repita o desligamento e reinicie as etapas para o outro secundário.

   1. Conecte-se a um secundário.

      Utilize mongosh para se conectar a um dos secundários.

      Se sua implantação usar a autenticação x.509, especifique estas mongosh opções:

      • --tls

      • --tlsCAFile

      • --tlsCertificateKeyFile

      mongosh "mongodb://<username>@<host>:<port>" --tls --tlsCAFile <CA_FILE> --tlsCertificateKeyFile <filename>

   2. Desative o secundário.

      Execute os seguintes comandos:

      use admin
      db.shutdownServer()

   3. Edite o arquivo de configuração do secundário.

      No arquivo de configuração do secundário, defina sharding.clusterRole para shardsvr:

      replication:
         replSetName: rs0
      sharding:
         clusterRole: shardsvr
      security:
         clusterAuthMode: x509
      net:
         port: 27017
         tls:
            mode: requireTLS
            certificateKeyFile: <FILE_WITH_COMBINED_CERT_AND_KEY>
            CAFile: <CA_FILE>
         bindIp: localhost,<ipaddress>

      Inclua opções adicionais conforme apropriado para sua implantação, como net.tls.certificateKeyFilePassword se o arquivo de chave de certificado TLS estiver criptografado com uma senha.

   4. Reinicie o secundário como um servidor shard.

      Execute o seguinte comando no host que contém o secundário:

      mongod --config <PATH_TO_CONFIG_FILE>

   5. Repita o desligamento e reinicie as etapas para o outro secundário.

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

Adicione o conjunto de réplicas iniciais como um fragmento

Após converter o conjunto de réplica inicial (rs0) em um fragmento, adicione-o ao cluster fragmentado.

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

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

   Autenticação de arquivo-chave

   Autenticação X.509

   Para conectar mongosh ao mongos, execute o seguinte comando:

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

   Se sua implantação usar a autenticação x.509, especifique estas mongosh opções:

   Se sua implantação usar a autenticação x.509, especifique estas mongosh opções:

   • --tls

   • --tlsCAFile

   • --tlsCertificateKeyFile

   mongosh "mongodb://admin01@mongodb6.example.net:27017" --tls --tlsCAFile <CA_FILE> --tlsCertificateKeyFile <filename>

   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.

2. 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" )

Atualize a string de conexão do seu aplicativo

Depois de adicionar o primeiro fragmento ao cluster, atualize a connection string usada pelos aplicativos para a connection string do cluster fragmentado. Em seguida, reinicie seus aplicativos.

Implemente um segundo conjunto de réplicas

Implemente um novo conjunto de réplicas chamado rs1. Os membros do conjunto de réplica rs1 estão nos seguintes hosts:

• mongodb3.example.net

• mongodb4.example.net

• mongodb5.example.net

1. Inicie cada membro do conjunto de réplicas.

   Autenticação de arquivo-chave

   Autenticação X.509

   Para cada instância do mongod no conjunto de réplica, crie um arquivo de configuração com estas opções:

   Opção	Valor
   security.keyFile	O caminho para o arquivo-chave usado para seu conjunto de réplicas inicial.
   replication.replSetName	rs1
   sharding.clusterRole	shardsvr
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongod deve escutar conexões de cliente.

   security:
      keyFile: <PATH_TO_KEYFILE>
   replication:
      replSetName: rs1
   sharding:
      clusterRole: shardsvr
   net:
      bindIp: localhost,<ipaddress>

   Inclua opções adicionais conforme apropriado para seu sistema.

   Para cada membro, inicie um mongod com as seguintes opções:

   Opção	Valor
   replication.replSetName	rs1
   sharding.clusterRole	shardsvr
   security.clusterAuthMode	x509
   net.tls.mode	requireTLS
   net.tls.certificateKeyFile	O caminho absoluto para o arquivo .pem que contém o certificado e a chave TLS.
   net.tls.CAFile	O caminho absoluto para o arquivo .pem que contém a sequência de certificados raiz da autoridade de certificação.
   net.bindIp	localhost, seguido por quaisquer outros nomes de host nos quais mongod deve escutar conexões de cliente.

   replication:
      replSetName: rs1
   sharding:
      clusterRole: shardsvr
   security:
      clusterAuthMode: x509
   net:
      tls:
         mode: requireTLS
         certificateKeyFile: <FILE_WITH_COMBINED_CERT_AND_KEY>
         CAFile: <CA_FILE>
      bindIp: localhost,<ipaddress>

   Implemente o mongod com sua configuração especificada:

   mongod --config <PATH_TO_CONFIG_FILE>

   Observação

   Quando você especifica a opção --shardsvr para uma instância do mongod, a instância é executada na porta 27018 por padrão.

2. Inicie cada membro do conjunto de réplicas.

3. 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:

   Autenticação de arquivo-chave

   Autenticação X.509

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

   mongosh "mongodb://mongodb3.example.net:27018" --tls --tlsCAFile <CA_FILE> --tlsCertificateKeyFile <filename>

4. 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.

   Importante

   Execute rs.initiate() em apenas uma e apenas uma instânciamongod para o conjunto de réplicas.

5. 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.

   1. Determine o conjunto de réplicas primário.

      Para determinar a primária, execute rs.status():

      rs.status()

      Na saída do comando, o campo replSetGetStatus.members[n].stateStr indica qual membro é o principal.

   2. Conecte-se ao conjunto de réplicas primário.

      Conecte-se ao conjunto de réplicas primário com mongosh. Por exemplo, se o primário for mongodb4.example.net, execute este comando:

      Autenticação de arquivo-chave

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

   3. Crie um usuário administrativo.

      Execute o seguinte método do db.createUser() para criar um usuário denominado rs1Admin com o papel userAdmin:

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

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

Adicione o conjunto de segunda réplica ao cluster como fragmento

Adicione o novo conjunto de réplicas, rs1, ao cluster fragmentado.

1. 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:

   Autenticação de arquivo-chave

   Autenticação X.509

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

   mongosh "mongodb://admin01@mongodb6.example.net:27017/admin" --tls --tlsCAFile <CA_FILE> --tlsCertificateKeyFile <filename>

   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.

2. 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" )

Fragmentar uma Coleção

A etapa final do procedimento é fragmentar uma coleção no cluster fragmentado.

1. Determine a chave de fragmento.

   Determine a chave fragmentada para a coleção. A chave de fragmento 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.

2. 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 } )

3. 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.

   Quando o balanceador redistribui blocos, isso pode afetar negativamente o desempenho do seu aplicativo. Para minimizar o impacto no desempenho, você pode especificar quando o balanceador é executado para que ele não seja executado durante os horários de pico. Para saber mais, consulte Agendar a janela de equilíbrio.