Restaurar dados da instância para um banco de dados MongoDB autogerenciado usando backup físico - ApsaraDB for MongoDB: Central de Documentação do Alibaba Cloud

Este tópico descreve como restaurar dados de uma instância do ApsaraDB for MongoDB para um banco de dados MongoDB autogerenciado no modo standalone ou replica set, utilizando arquivos de backup físico.

Pré-requisitos

A instância deve ser do tipo replica set.
A instância utiliza discos locais para armazenamento de dados.
O recurso Transparent Data Encryption (TDE) está desativado na instância. Para mais informações, consulte Configurar TDE para uma instância.
O mecanismo de armazenamento da instância é WiredTiger ou RocksDB. Caso a instância utilize TerarkDB, restaure os dados para um banco de dados autogerenciado por meio de backup lógico. Para mais detalhes, consulte Restaurar dados da instância para um banco de dados MongoDB autogerenciado usando backup lógico.
Nota
- Verifique o mecanismo de armazenamento da instância na página Basic Information do console do ApsaraDB for MongoDB.
- Se o mecanismo de armazenamento for RocksDB, compile e instale uma aplicação MongoDB compatível com esse mecanismo.

Requisitos de versão do banco de dados

A versão da instância precisa corresponder à versão do banco de dados MongoDB autogerenciado. A tabela a seguir apresenta as compatibilidades entre a instância e o banco de dados autogerenciado.

Instância do ApsaraDB for MongoDB	Banco de dados MongoDB autogerenciado
MongoDB 3.2	MongoDB 3.2 ou 3,4
MongoDB 3.4	MongoDB 3.4
MongoDB 4.0	MongoDB 4.0
MongoDB 4.2	MongoDB 4.2

Formatos dos arquivos de backup físico

Formato do arquivo de backup físico	Extensão do arquivo	Descrição
TAR	.tar.gz	Instâncias do ApsaraDB for MongoDB criadas antes de 26 de março de 2019 possuem arquivos de backup físico no formato .tar.
xbstream	_qp.xb	Instâncias do ApsaraDB for MongoDB criadas em ou após 26 de março de 2019 possuem arquivos de backup físico no formato .xbstream. Nota O formato .xbstream está disponível apenas para Linux. O Windows não oferece suporte a esse formato porque não é compatível com a ferramenta Percona XtraBackup, necessária para descompactar os arquivos.

Ambiente

O procedimento abaixo utiliza uma instância do Elastic Compute Service (ECS) criada a partir de uma imagem Ubuntu 16.04 de 64 bits. Para saber como criar uma instância ECS, consulte Criar uma instância usando o assistente.
A versão necessária do MongoDB já está instalada na instância ECS. Para instruções de instalação, acesse Adicionar um Driver do MongoDB.
As variáveis de ambiente do banco de dados MongoDB autogerenciado estão configuradas na instância ECS. Isso evita a necessidade de informar caminhos de executáveis repetidamente ao executar comandos. Para mais informações, consulte Etapa 1: Configurar variáveis de ambiente.
O diretório /test/mongo/data da instância ECS será usado pela instância de replica set.
Os diretórios /test/mongo/data1 e /test/mongo/data2 da instância ECS serão usados pelo banco de dados MongoDB autogerenciado nos nós do replica set.

Etapa 1: Configurar variáveis de ambiente

Configure as variáveis de ambiente do banco de dados MongoDB autogerenciado para evitar a digitação dos caminhos dos executáveis sempre que executar comandos. Antes de iniciar, certifique-se de que o MongoDB está instalado. Para mais informações, visite Instalar o MongoDB.

Caso as variáveis de ambiente já estejam definidas, pule esta etapa e vá diretamente para a Etapa 2. Consulte Etapa 2: Baixar e descompactar um arquivo de backup físico.

Execute o comando abaixo para abrir o arquivo profile no Linux:
```
sudo vi /etc/profile
```
Pressione a tecla i para entrar no modo de edição e adicione o seguinte código na última linha:
```
export PATH=$PATH:/<The path of the MongoDB server>/bin
```
Nota
Neste exemplo, /test/mongo/bin representa o caminho do servidor MongoDB. Substitua pelo caminho real ao configurar suas variáveis de ambiente.
Exemplo:
```
export PATH=$PATH:/test/mongo/bin
```
Pressione Esc para sair do modo de edição e digite :wq para salvar o arquivo e fechar o editor.
Execute o comando a seguir para aplicar as variáveis de ambiente configuradas:
```
source /etc/profile
```

Etapa 2: Baixar e descompactar um arquivo de backup físico

Execute o comando abaixo para baixar os dados de backup físico da instância pelo console do ApsaraDB for MongoDB. Para mais detalhes, consulte Baixar os dados de backup físico de uma instância de replica set.
```
wget -c '<External download URL of the data backup file>' -O <Custom name of the downloaded data backup file>.<File name extension>
```
Nota
Certifique-se de que a extensão do arquivo seja .tar.gz ou _qp.xb.
Execute o comando a seguir para criar um diretório chamado data dentro de /test/mongo/ e mova o arquivo de backup físico baixado para /test/mongo/data/.
```
mkdir -p /test/mongo/data && mv <Name of the physical backup file.Extension> /test/mongo/data
```
Descompacte o arquivo de backup físico.
- Se o nome do arquivo de backup físico tiver a extensão .tar.gz, como hins20190412.tar.gz, execute o comando abaixo para descompactá-lo:
```
cd /test/mongo/data/ && tar xzvf hins20190412.tar.gz 
```
  Figura 1. Resultado da descompactação
- Caso o arquivo de backup físico tenha a extensão _qp.xb, como hins20190412_qp.xb, siga os passos abaixo para descompactá-lo:
  1. Instale as ferramentas Percona XtraBackup e qpress. Para instruções, visite Instalando o Percona XtraBackup no Debian e Ubuntu.
  2. Descompacte o arquivo de backup físico. Neste exemplo, o arquivo é hins20190412_qp.xb.
```
# Go to the directory where the file is located. 
cd /test/mongo/data/
# Decompress the package. 
cat hins20190412_qp.xb | xbstream -x -v
# Decompress the physical backup file. 
innobackupex --decompress --remove-original /test/mongo/data
```
    Figura 2. Resultado da descompactação

Etapa 3: Restaurar dados para o banco de dados MongoDB autogerenciado no modo standalone

Execute o comando abaixo para criar um arquivo de configuração chamado mongod.conf no diretório /test/mongo:
```
touch /test/mongo/mongod.conf
```

Na linha de comando, digite vi /test/mongo/mongod.conf para abrir o arquivo mongod.conf. Em seguida, pressione a tecla i para entrar no modo de edição.

Escolha um modelo de configuração conforme o mecanismo de armazenamento da instância e copie-o para o arquivo de configuração mongod.conf.

Nota

Neste arquivo, ative a inicialização standalone e a autorização.

WiredTiger

systemLog:
    destination: file
    path: /test/mongo/mongod.log
    logAppend: true
security:
    authorization: enabled
storage:
    dbPath: /test/mongo/data
    directoryPerDB: true
net:
    port: 27017
    unixDomainSocket:
        enabled: false
processManagement:
    fork: true
    pidFilePath: /test/mongo/mongod.pid

Nota

Por padrão, o ApsaraDB for MongoDB usa o mecanismo de armazenamento WiredTiger com a opção directoryPerDB ativada. Por isso, directoryPerDB está definido como true na configuração acima.

RocksDB

systemLog:
    destination: file
    path: /test/mongo/logs/mongod.log
    logAppend: true
security:
    authorization: enabled
storage:
    dbPath: /test/mongo/data
        engine: rocksdb
net:
    port: 27017
    unixDomainSocket:
        enabled: false
processManagement:
    fork: true
    pidFilePath: /test/mongo/mongod.pid

Pressione Esc para sair do modo de edição e digite :wq para salvar o arquivo e fechar o editor.
Inicie o MongoDB utilizando o arquivo de configuração mongod.conf.
```
mongod -f /test/mongo/mongod.conf
```
Figura 3. Exemplo de inicialização bem-sucedida
Após iniciar o MongoDB, execute o comando abaixo para fazer login no banco de dados MongoDB autogerenciado e acessar o mongo shell:
```
mongo --host 127.0.0.1 -u <username> -p <password> --authenticationDatabase admin
```
- <username>: conta usada para fazer login no banco de dados MongoDB autogerenciado. O valor padrão é root.
- <password>: senha usada para fazer login no banco de dados MongoDB autogerenciado.
  
  Nota
  Se a senha contiver caracteres especiais, envolva-a entre aspas simples (' '). Exemplo: 'test123!@#' Caso contrário, o login no banco de dados pode falhar.
Figura 4. Exemplo de login bem-sucedido no MongoDB
Execute o comando show dbs no mongo shell para listar todos os bancos de dados disponíveis no servidor MongoDB e verificar se a restauração foi concluída com êxito.
Execute o comando exit no mongo shell para encerrar a sessão.

Após concluir as etapas anteriores, o banco de dados MongoDB estará iniciado no modo standalone. Para iniciá-lo no modo replica set, siga as instruções da Etapa 4.

Etapa 4: Iniciar o banco de dados MongoDB autogerenciado no modo replica set

Os arquivos de backup físico da instância incluem, por padrão, as configurações originais do replica set. Para iniciar o banco de dados MongoDB autogerenciado no modo replica set, remova essas configurações dos backups físicos. Siga os procedimentos abaixo:

Na linha de comando, faça login no banco de dados como usuário test através do mongo shell:
```
mongo --host 127.0.0.1 -u test -p <Password of the test account> --authenticationDatabase admin
```
Nota
Se a senha contiver caracteres especiais, envolva-a entre aspas simples (' '). Exemplo: 'test123!@#' Caso contrário, o login no banco de dados pode falhar.

Após fazer login, execute os comandos do código de exemplo para realizar as seguintes operações:

Crie um usuário temporário no banco de dados admin e conceda a ele permissões de leitura e escrita no banco de dados local.
Troque para o usuário temporário e exclua a configuração original do replica set do banco de dados local.
Retorne ao usuário test e remova o usuário temporário e suas permissões.

Nota
Substitua <Password of the test account> no código abaixo pela senha da sua conta de teste.

use admin
db.runCommand({
    createRole: "tmprole",
    roles: [
        {
            role: "test",
            db: "admin"
        }
    ],
    privileges: [
        {
            resource: {
                db: 'local',
                collection: 'system.replset'
            },
            actions: [
                'remove'
            ]
        }
    ]
})
db.runCommand({
    createUser: "tmpuser",
    pwd: "tmppwd",
    roles: [
        'tmprole'
    ]
})
db.auth('tmpuser','tmppwd')
use local
db.system.replset.remove({})
use admin
db.auth('test','<Password of the test account>')
db.dropRole('tmprole')
db.dropUser('tmpuser')

Execute os comandos abaixo para encerrar o serviço do MongoDB e sair do mongo shell:
```
use admin
db.shutdownServer()
exit
```
Figura 6. Exemplo de resultado da execução
Crie o arquivo de autenticação do replica set.

Para iniciar o banco de dados no modo replica set, crie um arquivo de chave que permita a autenticação mútua entre todos os nós do conjunto.
1. Execute o comando abaixo para criar a pasta keyFile dentro do diretório mongo e gerar um arquivo de chave nesse local:
```
mkdir -p /test/mongo/keyFile && touch /test/mongo/keyFile/mongodb.key
```
2. Execute o comando vi /test/mongo/keyFile/mongodb.key para abrir o arquivo mongodb.key. Pressione a tecla i para entrar no modo de edição. Exemplo:
```
MongoDB Encrypting File
```
  Nota
  A chave usada para criptografar os dados possui as seguintes restrições:
  - Deve ter entre 6 e 1.024 caracteres.
  - Pode conter apenas caracteres codificados em Base64.
  - Não pode conter sinais de igual (=).
3. Pressione Esc para sair do modo de edição e digite :wq para salvar o arquivo e fechar o editor.
4. Na linha de comando, execute o comando abaixo para alterar as permissões do arquivo de autenticação para 400, garantindo que apenas o proprietário possa ler o conteúdo.
```
sudo chmod 400 /test/mongo/keyFile/mongodb.key
```
Nota
Este arquivo de autenticação aplica-se a todos os nós do replica set.
Prepare dois nós vazios para o replica set seguindo os passos abaixo:
1. Execute o comando a seguir para criar duas cópias do arquivo mongod.conf, que servirão como configuração para os outros dois nós.
```
cp /test/mongo/mongod.conf /test/mongo/mongod1.conf && cp /test/mongo/mongod.conf /test/mongo/mongod2.conf
```
2. Execute o comando abaixo para criar os diretórios de dados dos outros dois nós:
```
mkdir -p /test/mongo/data1 && mkdir -p /test/mongo/data2
```
Modifique o arquivo de configuração de cada nó conforme descrito a seguir:
- Execute o comando vi /test/mongo/mongod.conf para abrir o arquivo de configuração do Nó 1 e altere-o conforme o conteúdo abaixo. Salve e saia do arquivo.
```
systemLog:
    destination: file
    path: /test/mongo/mongod.log
    logAppend: true
security:
    authorization: enabled
    keyFile: /test/mongo/keyFile/mongodb.key
storage:
    dbPath: /test/mongo/data
    directoryPerDB: true
net:
    bindIp: 127.0.0.1
    port: 27017
    unixDomainSocket:
        enabled: false
processManagement:
    fork: true
    pidFilePath: /test/mongo/mongod.pid
replication:
    replSetName: "rs0"
```
- Execute o comando vi /test/mongo/mongod1.conf para abrir o arquivo de configuração do Nó 2 e altere-o conforme o conteúdo abaixo. Salve e saia do arquivo.
```
systemLog:
    destination: file
    path: /test/mongo/mongod1.log
    logAppend: true
security:
    authorization: enabled
    keyFile: /test/mongo/keyFile/mongodb.key
storage:
    dbPath: /test/mongo/data1
    directoryPerDB: true
net:
    bindIp: 127.0.0.1
    port: 27018
    unixDomainSocket:
        enabled: false
processManagement:
    fork: true
    pidFilePath: /test/mongo/mongod1.pid
replication:
    replSetName: "rs0"
```
- Execute o comando vi /test/mongo/mongod2.conf para abrir o arquivo de configuração do Nó 3 e altere-o conforme o conteúdo abaixo. Salve e saia do arquivo.
```
systemLog:
    destination: file
    path: /test/mongo/mongod2.log
    logAppend: true
security:
    authorization: enabled
    keyFile: /test/mongo/keyFile/mongodb.key
storage:
    dbPath: /test/mongo/data2
    directoryPerDB: true
net:
    bindIp: 127.0.0.1
    port: 27019
    unixDomainSocket:
        enabled: false
processManagement:
    fork: true
    pidFilePath: /test/mongo/mongod2.pid
replication:
    replSetName: "rs0"
```
É possível ajustar os seguintes parâmetros nos arquivos de configuração:
- path em systemLog.path: caminho onde os arquivos de log do MongoDB serão armazenados no nó atual.
- dbpath: caminho onde os arquivos de dados do MongoDB serão armazenados no nó atual.
- pidFilePath: caminho onde os arquivos de ID de processo (PID) do MongoDB serão armazenados no nó atual.
- keyFile: caminho do arquivo de autenticação do replica set. Todos os nós devem usar o mesmo arquivo.
- bindIp: endereço IP do nó atual. Se todos os nós estiverem no mesmo servidor, podem compartilhar o mesmo IP.
- port: número da porta do nó atual. Se todos os nós estiverem no mesmo servidor, cada um deve usar uma porta diferente.
- replication: configurações do replica set.
- replSetName: nome do replica set.

Execute o comando abaixo para iniciar os três nós:

mongod -f /test/mongo/mongod.conf && mongod -f /test/mongo/mongod1.conf && mongod -f /test/mongo/mongod2.conf

Após iniciar os três nós, faça login no banco de dados MongoDB autogerenciado usando a conta de teste.
```
mongo --host 127.0.0.1 -u test -p <Password of the test account> --authenticationDatabase admin
```
Nota
Se a senha contiver caracteres especiais, envolva-a entre aspas simples (' '). Exemplo: 'test123!@#' Caso contrário, o login no banco de dados pode falhar.
No mongo shell, execute o comando abaixo para adicionar os nós criados anteriormente ao replica set e inicializá-lo:
```
rs.initiate( {
   _id : "rs0",
   version : 1,
   members: [
      { _id: 0, host: "127.0.0.1:27017" , priority : 1},
      { _id: 1, host: "127.0.0.1:27018" , priority : 0},
      { _id: 2, host: "127.0.0.1:27019" , priority : 0}
   ]
})
```
Uma inicialização bem-sucedida retorna a seguinte saída:
```
> rs.initiate( {
...    _id : "rs0",
...    version : 1,
...    members: [
...       { _id: 0, host: "127.0.0.1:27017" , priority : 1},
...       { _id: 1, host: "127.0.0.1:27018" , priority : 0},
...       { _id: 2, host: "127.0.0.1:27019" , priority : 0}
...    ]
... })
{ "ok" : 1 }
rs0:SECONDARY>
```
Nota
Este passo utiliza o comando rs.initiate(). Para mais informações sobre este comando, visite rs.initiate().

Após a execução do comando, os dados são sincronizados entre os dois nós adicionados e o nó primário. O tempo necessário varia conforme o tamanho do arquivo de backup. Quando a sincronização terminar, o banco de dados MongoDB autogerenciado estará operando no modo replica set.
Verifique se o banco de dados MongoDB autogerenciado foi iniciado corretamente no modo replica set:
1. Execute o comando exit para sair do mongo shell.
2. Execute o comando abaixo para fazer login novamente no banco de dados MongoDB autogerenciado:
```
mongo -u <username> -p <password> --authenticationDatabase admin
```
  - <username>: conta usada para fazer login no banco de dados MongoDB autogerenciado. O valor padrão é root.
  - <password>: senha usada para fazer login no banco de dados MongoDB autogerenciado.
    
    Nota
    Se a senha contiver caracteres especiais, envolva-a entre aspas simples (' '). Exemplo: 'test123!@#' Caso contrário, o login no banco de dados pode falhar.
3. Confirme se o banco de dados MongoDB autogerenciado está no modo replica set. Se <Name of the replica set>:PRIMARY> aparecer no lado esquerdo da linha de comando do mongo shell, o banco de dados foi iniciado com sucesso no modo replica set.
  
  Figura 8. Exemplo de inicialização bem-sucedida no modo replica set

Perguntas frequentes

Por que ocorre um erro ao iniciar o banco de dados MongoDB autogerenciado com o arquivo de configuração mongod.conf especificado?

As causas mais comuns incluem:

O banco de dados MongoDB autogerenciado pode ter sido iniciado antes da definição do arquivo de configuração mongod.conf, gerando automaticamente o arquivo storage.bson no diretório de dados. Nesse caso, remova o arquivo storage.bson e inicie o banco de dados especificando o arquivo de configuração mongod.conf.
Outro processo mongod pode estar em execução no sistema. Execute o comando ps -e | grep mongod para obter o PID e use kill <PID> para interromper o processo. Depois, inicie o banco de dados MongoDB autogerenciado com o arquivo de configuração mongod.conf.
O caminho de log definido em systemLog.path no arquivo de configuração mongod.conf pode ser inválido. Verifique se o caminho existe e se o arquivo de log possui o nome correto. Exemplo: path: /<Path of the log file>/<Name of the log file>.log.

Por que ocorre um erro ao iniciar o banco de dados MongoDB autogerenciado no modo replica set usando o arquivo de configuração mongod.conf?

É possível que as permissões do arquivo de autenticação keyFile não tenham sido alteradas corretamente para 600. Na linha de comando, execute sudo chmod 600 <Path of keyFile> para ajustar as permissões.

Por que o desempenho do sistema diminui após iniciar o banco de dados MongoDB autogerenciado no modo replica set?

Ao iniciar o banco de dados no modo replica set, o sistema começa automaticamente a sincronizar os dados do nó primário com os demais nós, o que pode impactar temporariamente o desempenho. Após a conclusão da sincronização, o desempenho volta ao normal.