Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/ / / /

Faça backup de um cluster fragmentado autogerenciado com snapshots do sistema de arquivos

Nesta página

  • Visão geral
  • Considerações
  • Antes de começar
  • Passos

Este documento descreve um procedimento para fazer backup de todos os componentes de umcluster fragmentado . Este procedimento usa snapshots do sistema de arquivos para capturar uma cópia da instância mongod .

Importante

Para fazer backup de um cluster fragmentado, você deve interromper todas as gravações no cluster.

Para obter mais informações sobre backups no MongoDB e backups de clusters fragmentados em particular, consulte Métodos de backup para uma implementação autogerenciada e Backup e restauração de um cluster fragmentado autogerenciado.

Para fazer um backup com um snapshot do sistema de arquivos, primeiro você deve parar o balanceador, parar as gravações e parar quaisquer operações de transformação de esquema no cluster.

O MongoDB fornece operações de backup e restauração que podem ser executadas com o balanceador e as transações em execução por meio dos seguintes serviços:

  • MongoDB Atlas

  • MongoDB Cloud Manager

  • MongoDB Ops Manager

Para mecanismos de armazenamento criptografado que usam o modo de criptografia AES256-GCM, AES256-GCM exige que cada processo use um valor de bloco de contador exclusivo com a chave.

Para mecanismo de armazenamento criptografado configurado com cifra AES256-GCM:

  • Restauração a partir de um hot backup
    A partir da versão 4.2, se você restaurar a partir de arquivos obtidos via backup "quente" (ou seja, o mongod está em execução), o MongoDB pode detectar chaves "sujas" na inicialização e rolar automaticamente a chave do banco de dados para evitar a reutilização IV (Initialization Vector).
  • Restaurando a partir do Cold Backup

    No entanto, se você restaurar a partir de arquivos obtidos via backup "frio" (ou seja, o mongod não está em execução), o MongoDB não poderá detectar chaves "sujas" na inicialização, e a reutilização do IV anulará as garantias de confidencialidade e integridade.

    A partir do 4,2, para evitar a reutilização das chaves após restaurar de um snapshot de sistema de arquivos frio, o MongoDB adiciona uma nova opção de linha de comando --eseDatabaseKeyRollover. Quando iniciada com a opção --eseDatabaseKeyRollover, a instância mongod rola as chaves de banco de dados configuradas com AES256-GCM cifra e sai.

É essencial que você pare o balanceador antes de captar um backup.

Se o balanceador estiver ativo enquanto você capta backups, os artefatos de backup podem estar incompletos ou ter dados duplicados, pois as partes podem migrar durante a gravação de backups.

Neste procedimento, você interromperá o balanceador e fará um backup do banco de dados de configuração. Em seguida, fará backups de cada fragmento no cluster usando uma ferramenta de snapshot do sistema de arquivos. Se você precisar de um snapshot exato do sistema, precisará interromper todas as gravações antes de fazer os snapshots do sistema de arquivos; caso contrário, o snapshot fará apenas uma aproximação de um ponto temporal.

Para fazer backup de um cluster fragmentado, você deve usar o comando fsync ou o método db.fsyncLock() para interromper as gravações no cluster. Isso ajuda a reduzir a probabilidade de inconsistências no backup.

Observação

Essas etapas só podem produzir um backup consistente se forem seguidas exatamente e se nenhuma operação estiver em andamento quando você começar.

Se a sua implementação depender do Elastic Block Storage (EBS) da Amazon com RAID configurado em sua instância, será impossível obter um estado consistente em todos os discos usando a ferramenta de instantâneo da plataforma. Como alternativa, você pode fazer um dos seguintes procedimentos:

Esse procedimento requer uma versão do MongoDB que seja compatível com o bloqueio fsync do mongos.

A partir de MongoDB 7.1 (também disponível a partir de 7.0.2, 6.0.11 e 5.0.22) os comandos fsync e fsyncUnlock podem ser executados no mongos para bloquear e desbloquear um cluster fragmentado.

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 . Quando terminar de executar as operações de manutenção, pare de usar a função directShardOperations .

Para fazer um backup autogerenciado de um cluster fragmentado, conclua as seguintes etapas:

1

Migrações de partes, refragmentação e operações de migração de esquema podem causar inconsistências nos backups. Para encontrar um bom momento para realizar um backup, monitore o uso do aplicativo e do banco de dados e encontre um horário em que é improvável que essas operações ocorram.

Para obter mais informações, consulte Janela de agendamento de backup para um cluster fragmentado autogerenciado.

2

Para evitar que migrações de partes interrompam o backup, use o método sh.stopBalancer() para parar o balanceador:

sh.stopBalancer()

Se uma rodada de balanceamento estiver em andamento, a operação aguardará a conclusão do balanceamento.

Para verificar se o balanceador está parado, use o método sh.getBalancerState():

use config
while( sh.isBalancerRunning().mode != "off" ) {
print("waiting...");
sleep(1000);
}
3

As gravações no banco de dados podem causar inconsistências no backup. Bloqueie seu cluster fragmentado para proteger o banco de dados contra gravações.

Para fazer o bloqueio de um cluster fragmentado, utilize o método db.fsyncLock():

db.getSiblingDB("admin").fsyncLock()

Execute o seguinte pipeline de agregação no mongos e no mongod primário dos servidores de configuração. Para confirmar o bloqueio, certifique-se de que o campo fysncLocked retorne true e o campo fsyncUnlocked retorne false.

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 ] }
} }
] )
[ { fsyncLocked: true }, { fsyncUnlocked: false } ]
4

Observação

Fazer backup de um servidor de configuração faz backup dos metadados do cluster fragmentado. Você só precisa fazer backup de um servidor de configuração, pois todos eles contêm os mesmos dados. Execute essa etapa em relação ao membro principal do CSRS.

Para criar um snapshot do sistema de arquivos do servidor de configuração, siga o procedimento em Criar um snapshot.

5

Execute um snapshot do sistema de arquivos no membro principal de cada shard, usando o procedimento encontrado em Backup e Restauração de um Sistema Autogerenciado com Snapshots do Sistema de Arquivos.

6

Após a conclusão do backup, você deve desbloquear o cluster para permitir que as gravações sejam retomadas.

Para desbloquear o cluster, use o método db.fsyncUnlock():

db.getSibling("admin").fsyncUnlock()

Execute o seguinte pipeline de agregação no mongos e no mongod primário dos servidores de configuração. Para confirmar o desbloqueio, certifique-se de que o campo fysncLocked retorne false e o campo fsyncUnlocked retorne true.

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 ] }
} }
] )
[ { fsyncLocked: false }, { fsyncUnlocked: true } ]
7

Para reiniciar o balanceador, use o método sh.startBalancer():

sh.startBalancer()

Para confirmar que o balanceador está em execução, use o método sh.getBalancerState():

sh.getBalancerState()
true

O comando retorna true quando o balanceador está em execução.

Voltar

Restaurar clusters fragmentados