Converter cluster fragmentado autogerenciado em conjunto de réplicas

Este tutorial descreve como converter um cluster fragmentado em um conjunto de réplicas não fragmentadas. Para converter um conjunto de réplicas em um cluster fragmentado, consulte Converter um conjunto de réplicas autogerenciado em um cluster fragmentado. Consulte a documentação de fragmentação para obter mais informações sobre clusters fragmentados.

Este tutorial orienta você nas seguintes tarefas:

Desabilitar o Balanceador.
Converta o cluster em um conjunto de réplicas.
Desbloqueie o cluster (somente cluster de vários shards).

Antes de começar

A partir do MongoDB 8.0, você pode usar a função directShardOperations para realizar operações de manutenção que exigem que você execute comandos diretamente em um shard.

Aviso

Executar comandos utilizando a função directShardOperations pode fazer com que seu cluster pare de funcionar corretamente e pode causar corrupção de dados. Use a função directShardOperations apenas para fins de manutenção ou sob a orientação do suporte do MongoDB . Pare de usar a função directShardOperations quando terminar de executar as operações de manutenção.

Compatibilidade de versão

As etapas deste tutorial exigem o MongoDB 6.0 ou posterior.

Autorização

Os comandosfsyncefsyncUnlockexigem a ação de autorizaçãofsync , que pode ser atribuída por meio da funçãohostManagerou de uma função personalizada.

Usuários e roles

Em um cluster fragmentado, o MongoDB armazena definições de usuário e função no banco de dados admin dos servidores de configuração. Essas definições não são transferidas para o conjunto de réplicas quando você converte o cluster.

Antes que seus aplicativos se conectem ao conjunto de réplicas, crie os usuários e as funções que seu sistema exige no conjunto de réplicas. Para saber mais, consulte Criar um usuário em implantações autogerenciadas e Gerenciar usuários e funções em implantações autogerenciadas.

Agendar a conversão de cluster

Converta o cluster quando migrações de chunk, refragmentação e transformações de esquema não forem normalmente realizadas.

Passos

No caso de um cluster com apenas um fragmento, esse fragmento contém o conjunto completo de dados. Para converter esse cluster em um conjunto de réplicas não fragmentadas :

Desabilitar o balancer

Para desabilitar o balanceador:

Conecte mongosh o a uma mongos instância do no cluster fragmentado.
Para parar o balanceador, execute:
```
sh.stopBalancer()
```
Para verificar se o balanceador está desativado, execute o seguinte comando e verifique se a saída é false:
```
sh.getBalancerState()
```

Converter o cluster em um conjunto de réplicas

Pare todas as instâncias mongos.
Reconfigure o aplicativo para se conectar diretamente aos nós do conjunto de réplicas do shard que se tornará o novo conjunto de réplicas.
Execute uma reinicialização contínua dos nós do conjunto de réplicas para remover a opção --shardsvr de mongod.
Dica
A alteração da opção --shardsvr altera a porta em que o mongod escuta conexões de entrada.

O cluster de shard único agora é um conjunto de réplicas não sharded que aceita operações de leitura e gravação no conjunto de dados. Você pode desativar os servidores de configuração conforme necessário.

Use o procedimento a seguir para fazer a transição de um cluster fragmentado com mais de um fragmento para um conjunto de réplicas totalmente novo.

Desativar o Balanceador e Bloquear o Cluster

Para desabilitar o balanceador e bloqueio o cluster:

Conecte mongosh o a uma mongos instância do no cluster fragmentado.
Para parar o balanceador, execute:
```
sh.stopBalancer()
```
Para verificar se o balanceador está desativado, execute o seguinte comando e verifique se a saída é false:
```
sh.getBalancerState()
```
Para bloqueio o cluster fragmentado, que impede gravações do banco de dados , execute:
```
db.getSiblingDB( "admin" ).fsyncLock()
```
Para confirmar a bloqueio, execute:
```
db.getSiblingDB( "admin" ).aggregate( [   { $currentOp: { } },   { $facet: {      "locked": [         { $match: { $and: [            { fsyncLock: { $exists: true } }         ] } }      ],      "unlocked": [         { $match: { fsyncLock: { $exists: false } } }      ]   } },   { $project: {      "fsyncLocked": { $gt: [ { $size: "$locked" }, 0 ] },      "fsyncUnlocked": { $gt: [ { $size: "$unlocked" }, 0 ] }   } }] )
```
Certifique-se de que a saída mostre que fsyncLocked é true, o que significa que o cluster está bloqueado:
```
[ { fsyncLocked: true }, { fsyncUnlocked: false } ]
```

Converter o cluster em um conjunto de réplicas

Com o cluster fragmentado bloqueado e o balanceador desabilitado, implementeum novo conjunto de réplicas além do seu cluster fragmentado. O conjunto de réplicas deve ter capacidade suficiente para manter todos os arquivos de dados de todos os shards atuais combinados. Não configure o aplicação para se conectar ao novo conjunto de réplicas até que a transferência de dados seja concluída.
Reconfigure seu aplicativo ou interrompa todas as mongos instâncias. Se você interromper todas as instâncias, os aplicativos não poderão ler a partir do banco de mongos dados. Se você interromper todas as instâncias,mongos mongos inicie uma instância temporária que os aplicativos não podem acessar para o procedimento de migração de dados.
Use o mongodump e o mongorestore para migrar os dados da instância mongos para o novo conjunto de réplicas.
Exclua o banco de dados config ao executar mongorestore. Use a opção como mostrado neste --nsExclude exemplo:
```
mongorestore --nsExclude="config.*" <connection-string> /data/backup
```
Observação
Nem todas as coleções em todos os bancos de dados são necessariamente fragmentadas. Não migre apenas a coleção fragmentada. Certifique-se de que todos os bancos de dados e todas as coleções sejam migrados corretamente.
Reconfigure o aplicativo para utilizar o conjunto de réplicas não fragmentadas em vez da instância mongos.
Depois de converter o cluster fragmentado em um conjunto de réplicas, atualize a string de conexão usada pelos seus aplicativos para a string de conexão do conjunto de réplicas. Em seguida, reinicie seus aplicativos.

O aplicativo agora usa o conjunto de réplicas não sharded para leituras e gravações. Agora você pode desativar a infraestrutura de cluster sharded não utilizada.

Desbloquear o cluster

Depois de converter o cluster sharded em um conjunto de réplicas, desbloqueie o cluster:

Para desbloquear o cluster e permitir que as gravações do banco de dados sejam retomadas, execute:
```
db.getSiblingDB( "admin" ).fsyncUnlock()
```
Para confirmar o desbloqueio, execute:
```
db.getSiblingDB( "admin" ).aggregate( [   { $currentOp: { } },   { $facet: {      "locked": [         { $match: { $and: [            { fsyncLock: { $exists: true } }         ] } } ],         "unlocked": [         { $match: { fsyncLock: { $exists: false } } }      ]   } },   { $project: {      "fsyncLocked": { $gt: [ { $size: "$locked" }, 0 ] },      "fsyncUnlocked": { $gt: [ { $size: "$unlocked" }, 0 ] }   } }] )
```
Certifique-se de que a saída mostre que fsyncLocked é false, o que significa que o cluster está desbloqueado:
```
[ { fsyncLocked: false }, { fsyncUnlocked: true } ]
```

Saiba mais

Gerenciar balancer de cluster fragmentado

Voltar

Fazer backup dos metadados do cluster

Converter um conjunto de réplicas em um cluster fragmentado