ApsaraDB for MongoDB:Restaurar um backup de disco em nuvem para um banco de dados autogerenciado

Informações básicas

O MongoDB fornece um conjunto de ferramentas oficiais de backup e restauração: Mongodump e Mongorestore. O ApsaraDB for MongoDB usa o Mongodump para gerar backups lógicos. Em seguida, restaure esses backups em um banco de dados MongoDB autogerenciado com o Mongorestore.

Observações de uso

• Use uma versão do mongorestore compatível com seu banco de dados MongoDB. Versões antigas do mongorestore podem ser incompatíveis com versões recentes do banco de dados devido a atualizações frequentes. Para obter mais informações, consulte mongorestore.

• Mesmo que uma coleção contenha poucos dados e tenha apenas um arquivo BSON, como myDatabase/myCollection/data/myCollection_0_part0.bson, mescle ou renomeie os arquivos BSON. O mongorestore processa os arquivos BSON com base nos prefixos dos nomes de arquivo.

• Ao baixar um backup de disco em nuvem, o processo também trata coleções vazias com esquemas preservados e gera um arquivo BSON vazio com informações sobre o nome do banco de dados e da coleção. A ferramenta mongorestore lida corretamente com esses arquivos vazios.

• Em instâncias de cluster fragmentado, o arquivo de backup de disco em nuvem baixado não contém mais informações de roteamento de fragmentação. Portanto, restaure os dados de backup em qualquer instância de nó único, conjunto de réplicas ou cluster fragmentado. Para restaurar os dados em uma instância de cluster fragmentado, execute a pré-fragmentação.

Pré-requisitos

• No cliente (servidor local ou instância ECS) que hospeda seu banco de dados MongoDB autogerenciado, instale uma versão do MongoDB correspondente à versão da sua instância do ApsaraDB for MongoDB. Para instruções de instalação, consulte Install MongoDB.

• Baixe o arquivo de backup lógico. Caso contrário, consulte Baixar arquivos de backup.

Procedimento

1. Copie o arquivo de backup baixado para o cliente que hospeda a ferramenta mongorestore e o banco de dados MongoDB autogerenciado.

2. Descompacte o arquivo de backup.

   Os arquivos de backup estão disponíveis nos formatos tar.zst ou tar.gz, que usam os algoritmos de compactação zstd e gzip, respectivamente. Selecione o formato de download por meio do parâmetro UseZstd da operação OpenAPI CreateDownload.

   tar.zst (Console)

   zstd -d -c <backup_file.tar.zst> | tar -xvf - -C <extraction_directory>

   Certifique-se de que a ferramenta zstd esteja instalada no cliente e que o diretório de extração exista.

   Exemplo:

   mkdir -p ./download_test/test1
   zstd -d -c test1.tar.zst | tar -xvf - -C /Users/xxx/Desktop/download_test/test1/

   tar.gz (API)

   tar -zxvf <backup_file.tar.gz> -C <extraction_directory>

   Verifique se o diretório de extração existe.

   Exemplo:

   mkdir -p ./download_test/test1
   tar -zxvf testDB.tar.gz -C /Users/xxx/Desktop/download_test/test1/

3. Mescle os arquivos BSON.

   Em um cliente com ambiente Python, copie o script abaixo e salve-o como merge_bson_files.py.

   import os
   import struct
   import sys
   import argparse
   import shutil
   import re
   
   # Handle strings for compatibility with both Python 2 and 3
   if sys.version_info[0] >= 3:
       unicode = str
   
   def merge_single_bson_dir(input_dir: str, output_dir: str, namespace: str) -> None:
       """
       Merges BSON files within a single directory.
   
       Args:
           input_dir (str): The directory path containing the BSON files.
           output_dir (str): The directory path for the output file.
           namespace (str): The name of the output file (without extension).
       """
       try:
           # Get all BSON files matching the ***_*_part*.bson pattern and sort them by name
           files = [f for f in os.listdir(input_dir) if re.match(r'^.+_.+_part\d+\.bson$', f)]
           files.sort()  # Sort by filename
   
           if not files:
               print("No matching .bson files found in {}".format(input_dir))
               return
   
           output_file = os.path.join(output_dir, "{}.bson".format(namespace))
           if os.path.exists(output_file):
               print("Output file {} already exists, skipping...".format(output_file))
               return
   
           print("Merging {} files into {}...".format(len(files), output_file))
   
           # Stream-read and merge the files
           total_files = len(files)
           with open(output_file, "wb") as out_f:
               for index, filename in enumerate(files, 1):
                   file_path = os.path.join(input_dir, filename)
                   print("  Processing file {}/{}: {}...".format(index, total_files, filename))
   
                   try:
                       with open(file_path, "rb") as in_f:
                           while True:
                               # Read the BSON document size
                               size_data = in_f.read(4)
                               if not size_data or len(size_data) < 4:
                                   break
   
                               # Parse the document size (little-endian)
                               doc_size = struct.unpack("<i", size_data)[0]
   
                               # Reread the complete document data
                               in_f.seek(in_f.tell() - 4)
                               doc_data = in_f.read(doc_size)
   
                               if len(doc_data) != doc_size:
                                   break
   
                               out_f.write(doc_data)
                   except Exception as e:
                       print("Error reading {}: {}".format(filename, str(e)))
       except Exception as e:
           print("Error in merge_single_bson_dir: {}".format(str(e)))
   
   def merge_bson_files_recursive(input_root: str, output_root: str = None) -> None:
       """
       Recursively traverses directories and merges all BSON files.
   
       Args:
           input_root (str): The root directory path containing the BSON files.
           output_root (str): The root directory for the output files, defaults to input_root.
       """
       if output_root is None:
           output_root = input_root
   
       # Ensure the output root directory exists
       if not os.path.exists(output_root):
           os.makedirs(output_root)
   
       print("Scanning directories in {}...".format(input_root))
       
       # Traverse all items in the input root directory
       for item in os.listdir(input_root):
           item_path = os.path.join(input_root, item)
           
           # If it is a directory, process it
           if os.path.isdir(item_path):
               print("Processing directory: {}".format(item))
               
               # Create the corresponding output directory
               output_item_path = os.path.join(output_root, item)
               if not os.path.exists(output_item_path):
                   os.makedirs(output_item_path)
               
               # Traverse all subdirectories and files within this directory
               for item_d in os.listdir(item_path):
                   sub_item_path = os.path.join(item_path, item_d)
                   for sub_item in os.listdir(sub_item_path):
                       data_path = os.path.join(sub_item_path, sub_item)
                       # If it's a "data" directory, merge the BSON files within it
                       if os.path.isdir(data_path) and sub_item == "data":
                           # Extract the namespace (parent directory name)
                           namespace = os.path.basename(sub_item_path)
                           merge_single_bson_dir(data_path, output_item_path, namespace)
                       # If it's a .metadata.json file, copy it directly to the corresponding output directory
                       elif sub_item.endswith(".metadata.json"):
                           src_file = os.path.join(sub_item_path, sub_item)
                           target_dir = os.path.join(output_item_path, sub_item)
                           shutil.copy(src_file, target_dir)
                           print("Copied metadata file: {}".format(sub_item))
               print("Finished processing directory: {}".format(item))
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser(description="Recursively merge BSON files")
       parser.add_argument("input_root", help="The root directory path containing the BSON files")
       parser.add_argument("-o", "--output_root", help="The root directory path for output files, defaults to the input root")
   
       args = parser.parse_args()
       merge_bson_files_recursive(args.input_root, args.output_root)

   Execute o comando:

   python merge_bson_files.py <input_directory> -o <output_directory>

4. Use a ferramenta mongorestore para restaurar os dados de backup na instância do banco de dados autogerenciado.

   # Restore a single collection
   mongorestore --uri=<mongodb-uri> --db <db> --collection <collection>  <xxx.bson>
   # Example for a single collection
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --db testDB --collection coll1 ./testDB/coll1.bson 
   # Restore a single database
   mongorestore --uri=<mongodb-uri> --db <db> --dir </path/to/bson/dir>
   # Example for a single database
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --db testDB --dir ./testDB 
   # Restore an entire instance
   mongorestore --uri=<mongodb-uri>  --dir </path/to/bson/dir>
   # Example for an entire instance
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --dir ./

   Parâmetros:

   • <mongodb-uri>: URI da string de conexão do banco de dados autogerenciado ou da instância do ApsaraDB for MongoDB. A URI inclui nome de usuário, senha, endereço IP do servidor e porta. Para mais detalhes, consulte a documentação oficial.

   • <db>: Nome do banco de dados a ser restaurado.

   • <collection>: Nome da coleção a ser restaurada.

   • <xxx.bson>: Arquivo de backup BSON da coleção única que você deseja restaurar.

   • <path/to/bson/dir>: Diretório que contém os arquivos BSON para a operação de restauração.

Restaurar backup de disco local

Perguntas frequentes