ApsaraDB for MongoDB:Restore a cloud disk backup to a self-managed database

Informations générales

MongoDB propose un ensemble d'outils officiels de sauvegarde et de restauration : Mongodump et Mongorestore. ApsaraDB for MongoDB utilise Mongodump pour générer des sauvegardes logiques, que vous pouvez ensuite restaurer vers une base de données MongoDB autogérée à l'aide de Mongorestore.

Remarques sur l'utilisation

• Utilisez une version de mongorestore compatible avec votre base de données MongoDB. En raison des mises à jour fréquentes, les anciennes versions de mongorestore peuvent être incompatibles avec les versions plus récentes de la base de données. Pour plus d'informations, consultez la documentation relative à mongorestore.

• Même si une collection contient très peu de données et ne possède qu'un seul fichier BSON, tel que myDatabase/myCollection/data/myCollection_0_part0.bson, vous devez fusionner ou renommer les fichiers BSON. En effet, mongorestore traite les fichiers BSON en fonction des préfixes de leurs noms de fichier.

• Lorsque vous téléchargez une sauvegarde de disque cloud, le processus de téléchargement gère également les collections vides dont les schémas sont conservés, ce qui génère un fichier BSON vide contenant les informations sur le nom de la base de données et de la collection. L'outil mongorestore peut gérer ces fichiers vides correctement.

• Pour une instance de cluster fragmenté (sharded cluster), le fichier de sauvegarde de disque cloud téléchargé ne contient plus les informations de routage de fragmentation. Par conséquent, vous pouvez restaurer les données de sauvegarde vers n'importe quelle instance à nœud unique, ensemble de réplicas ou cluster fragmenté. Si vous souhaitez restaurer les données vers une instance de cluster fragmenté, vous devez effectuer un pré-sharding.

Prérequis

• Sur le client (un serveur local ou une instance ECS) qui héberge votre base de données MongoDB autogérée, installez une version de MongoDB correspondant à la version de votre instance ApsaraDB for MongoDB. Pour obtenir des instructions d'installation, consultez la page Install MongoDB.

• Vous avez téléchargé le fichier de sauvegarde logique. Sinon, consultez la rubrique Télécharger des fichiers de sauvegarde.

Procédure

1. Copiez le fichier de sauvegarde téléchargé vers le client qui héberge à la fois l'outil mongorestore et votre base de données MongoDB autogérée.

2. Décompressez le fichier de sauvegarde.

   Vous pouvez télécharger des fichiers de sauvegarde au format tar.zst ou tar.gz, qui utilisent respectivement les algorithmes de compression zstd et gzip. Vous pouvez sélectionner le format de téléchargement à l'aide du paramètre UseZstd de l'opération OpenAPI CreateDownload.

   tar.zst (Console)

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

   Assurez-vous que l'outil zstd est installé sur le client et que le répertoire d'extraction existe.

   Exemple :

   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>

   Assurez-vous que le répertoire d'extraction existe.

   Exemple :

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

3. Fusionnez les fichiers BSON.

   Sur un client disposant d'un environnement Python, copiez le script suivant et enregistrez-le sous le nom 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)

   Exécutez la commande suivante :

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

4. Utilisez l'outil mongorestore pour restaurer les données de sauvegarde vers votre instance de base de données autogérée.

   # 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 ./

   Paramètres :

   • <mongodb-uri> : L'URI de la chaîne de connexion de votre base de données autogérée ou de votre instance ApsaraDB for MongoDB. L'URI inclut le nom d'utilisateur, le mot de passe, l'adresse IP du serveur et le port. Pour plus d'informations, consultez la documentation officielle.

   • <db> : Le nom de la base de données à restaurer.

   • <collection> : Le nom de la collection à restaurer.

   • <xxx.bson> : Le fichier de sauvegarde BSON pour la collection unique que vous souhaitez restaurer.

   • <path/to/bson/dir> : Le répertoire contenant les fichiers BSON pour l'opération de restauration.

FAQ