ApsaraDB for MongoDB:Memulihkan backup disk cloud ke database yang dikelola sendiri

Catatan penggunaan

• Gunakan versi mongorestore yang kompatibel dengan database MongoDB Anda. Karena pembaruan yang sering terjadi, versi mongorestore yang lebih lama mungkin tidak kompatibel dengan versi database yang lebih baru. Untuk informasi selengkapnya, lihat mongorestore.

• Bahkan jika sebuah koleksi hanya berisi sedikit data dan hanya memiliki satu file BSON, seperti myDatabase/myCollection/data/myCollection_0_part0.bson, Anda tetap harus menggabungkan atau mengganti nama file-file BSON tersebut. Hal ini karena mongorestore memproses file BSON berdasarkan awalan nama filenya.

• Saat Anda mengunduh backup disk cloud, proses pengunduhan juga menangani koleksi kosong dengan skema yang dipertahankan, menghasilkan file BSON kosong yang berisi informasi nama database dan koleksi. Alat mongorestore dapat menangani file kosong ini dengan benar.

• Untuk instansi kluster sharded, file backup disk cloud yang diunduh tidak lagi berisi informasi entri rute sharding. Oleh karena itu, Anda dapat memulihkan data backup ke instans single-node, replica set, atau kluster sharded apa pun. Jika Anda ingin memulihkan data ke instansi kluster sharded, Anda harus melakukan pre-sharding.

Prasyarat

• Pada klien (server lokal atau instance ECS) yang menjalankan database MongoDB yang dikelola sendiri, instal versi MongoDB yang sesuai dengan versi instans ApsaraDB for MongoDB Anda. Untuk instruksi instalasi, lihat Install MongoDB.

• Anda telah mengunduh file backup logis. Jika belum, lihat Download backup files.

Prosedur

1. Salin file backup yang telah diunduh ke klien yang menjalankan alat mongorestore dan database MongoDB yang dikelola sendiri.

2. Ekstrak file backup.

   Anda dapat mengunduh file backup dalam format tar.zst atau tar.gz, yang masing-masing menggunakan algoritma kompresi zstd dan gzip. Anda dapat memilih format unduhan dengan menggunakan parameter UseZstd pada operasi OpenAPI CreateDownload .

   tar.zst (Console)

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

   Pastikan alat zstd telah terinstal pada klien dan direktori ekstraksi sudah ada.

   Contoh:

   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>

   Pastikan direktori ekstraksi sudah ada.

   Contoh:

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

3. Gabungkan file BSON.

   Pada klien dengan lingkungan Python, salin skrip berikut dan simpan sebagai 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:
       """
       Menggabungkan file BSON dalam satu direktori.
   
       Args:
           input_dir (str): Path direktori yang berisi file BSON.
           output_dir (str): Path direktori untuk file output.
           namespace (str): Nama file output (tanpa ekstensi).
       """
       try:
           # Dapatkan semua file BSON yang sesuai pola ***_*_part*.bson dan urutkan berdasarkan nama
           files = [f for f in os.listdir(input_dir) if re.match(r'^.+_.+_part\d+\.bson$', f)]
           files.sort()  # Urutkan berdasarkan nama file
   
           if not files:
               print("Tidak ditemukan file .bson yang sesuai di {}".format(input_dir))
               return
   
           output_file = os.path.join(output_dir, "{}.bson".format(namespace))
           if os.path.exists(output_file):
               print("File output {} sudah ada, dilewati...".format(output_file))
               return
   
           print("Menggabungkan {} file menjadi {}...".format(len(files), output_file))
   
           # Baca dan gabungkan file secara streaming
           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("  Memproses file {}/{}: {}...".format(index, total_files, filename))
   
                   try:
                       with open(file_path, "rb") as in_f:
                           while True:
                               # Baca ukuran dokumen BSON
                               size_data = in_f.read(4)
                               if not size_data or len(size_data) < 4:
                                   break
   
                               # Uraikan ukuran dokumen (little-endian)
                               doc_size = struct.unpack("<i", size_data)[0]
   
                               # Baca ulang data dokumen lengkap
                               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 membaca {}: {}".format(filename, str(e)))
       except Exception as e:
           print("Error di merge_single_bson_dir: {}".format(str(e)))
   
   
   def merge_bson_files_recursive(input_root: str, output_root: str = None) -> None:
       """
       Melintasi direktori secara rekursif dan menggabungkan semua file BSON.
   
       Args:
           input_root (str): Path root direktori yang berisi file BSON.
           output_root (str): Path root direktori untuk file output, default ke input_root.
       """
       if output_root is None:
           output_root = input_root
   
       # Pastikan direktori root output ada
       if not os.path.exists(output_root):
           os.makedirs(output_root)
   
       print("Memindai direktori di {}...".format(input_root))
       
       # Lintasi semua item di direktori root input
       for item in os.listdir(input_root):
           item_path = os.path.join(input_root, item)
           
           # Jika berupa direktori, proses
           if os.path.isdir(item_path):
               print("Memproses direktori: {}".format(item))
               
               # Buat direktori output yang sesuai
               output_item_path = os.path.join(output_root, item)
               if not os.path.exists(output_item_path):
                   os.makedirs(output_item_path)
               
               # Lintasi semua subdirektori dan file di dalam direktori ini
               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)
                       # Jika berupa direktori "data", gabungkan file BSON di dalamnya
                       if os.path.isdir(data_path) and sub_item == "data":
                           # Ekstrak namespace (nama direktori induk)
                           namespace = os.path.basename(sub_item_path)
                           merge_single_bson_dir(data_path, output_item_path, namespace)
                       # Jika berupa file .metadata.json, salin langsung ke direktori output yang sesuai
                       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("File metadata disalin: {}".format(sub_item))
               print("Selesai memproses direktori: {}".format(item))
   
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser(description="Menggabungkan file BSON secara rekursif")
       parser.add_argument("input_root", help="Path root direktori yang berisi file BSON")
       parser.add_argument("-o", "--output_root", help="Path root direktori untuk file output, default ke root input")
   
       args = parser.parse_args()
       merge_bson_files_recursive(args.input_root, args.output_root)

   Jalankan perintah:

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

4. Gunakan alat mongorestore untuk memulihkan data backup ke instans database yang dikelola sendiri.

   # Memulihkan satu koleksi
   mongorestore --uri=<mongodb-uri> --db <db> --collection <collection>  <xxx.bson>
   # Contoh untuk satu koleksi
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --db testDB --collection coll1 ./testDB/coll1.bson 
   # Memulihkan satu database
   mongorestore --uri=<mongodb-uri> --db <db> --dir </path/to/bson/dir>
   # Contoh untuk satu database
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --db testDB --dir ./testDB 
   # Memulihkan seluruh instans
   mongorestore --uri=<mongodb-uri>  --dir </path/to/bson/dir>
   # Contoh untuk seluruh instans
   mongorestore --uri='mongodb://127.x.x.x:27017/?authSource=admin' --dir ./

   Parameter:

   • <mongodb-uri>: URI string koneksi database yang dikelola sendiri atau instans ApsaraDB for MongoDB Anda. URI mencakup username, password, alamat IP server, dan port. Untuk informasi selengkapnya, lihat dokumentasi resmi.

   • <db>: Nama database yang akan dipulihkan.

   • <collection>: Nama koleksi yang akan dipulihkan.

   • <xxx.bson>: File backup BSON untuk satu koleksi yang ingin dipulihkan.

   • <path/to/bson/dir>: Direktori yang berisi file BSON untuk operasi pemulihan.

FAQ