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

Nesta página

Visão geral

Considerações
Passos

Visão geral

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.

Considerações

Transações entre fragmentos

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:

Mecanismo de armazenamento criptografado (somente MongoDB Enterprise)

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.

Balancer

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

Precisão

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.

Consistência

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.

Snapshots com Amazon EBS em uma configuração RAID 10

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:

Defina um bloqueio fsync para liberar todas as gravações e bloquear o cluster contra novas gravações para ajudar a reduzir a probabilidade de um estado inconsistente ocorrer durante o processo de backup.
Se você escolher essa opção, consulte Fazer backup de instâncias com arquivos de diário em um volume separado ou sem registro no diário.
Configure o LVM para executar e manter seus arquivos de dados MongoDB em cima do RAID dentro do seu sistema.
Se você escolher essa opção, realize a operação de backup do LVM descrita em Criar um snapshot.

Compatibilidade de versão

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

A partir do MongoDB 5.0.22 , os comandos fsync e fsyncUnlock podem ser executados em mongos para bloquear e desbloquear um cluster fragmentado.

Passos

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

Encontre uma janela de backup

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.

Pare o balanceador

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);
}

Bloquear o cluster

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

Faça backup do servidor de configuração primário

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.

Faça backup dos fragmentos primários

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.

Desbloquear o cluster

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

Reinicie o balanceador

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

Use Database Dumps