ApsaraDB for MongoDB：Memulihkan data cadangan disk yang diunduh ke database yang dikelola sendiri

Perhatian

• Karena MongoDB sering diperbarui, versi lama mongorestore mungkin tidak kompatibel dengan versi MongoDB yang lebih baru. Pastikan Anda menggunakan versi mongorestore yang kompatibel. Untuk informasi lebih lanjut, lihat mongorestore.

• Bahkan jika koleksi berisi sejumlah kecil data dan hanya memiliki satu file .bson, seperti myDatabase/myCollection/data/myCollection_0_part0.bson, Anda harus menggabungkan atau mengubah nama file tersebut. Hal ini karena mongorestore memproses file .bson berdasarkan awalan nama filenya.

• Saat Anda mengunduh cadangan disk, proses ini juga mencakup koleksi kosong yang mempertahankan skemanya. Ini membuat file .bson kosong yang berisi informasi nama database dan koleksi. mongorestore dapat memproses file kosong ini.

• Untuk instans kluster sharded, file cadangan disk yang diunduh tidak berisi informasi routing shard. Anda dapat memulihkan data cadangan ke instans node tunggal, ReplicaSet, atau kluster sharded. Jika Anda ingin memulihkan data ke instans kluster sharded, Anda harus melakukan operasi pre-sharding.

Prasyarat

• Unduh dan instal MongoDB pada klien yang menjadi host database yang dikelola sendiri. Klien bisa berupa server lokal atau instans Elastic Compute Service (ECS). Pastikan versi MongoDB sama dengan versi instans ApsaraDB for MongoDB Anda. Untuk informasi lebih lanjut tentang instalasi, lihat Instal MongoDB.

• Unduh file cadangan logis. Untuk informasi lebih lanjut, lihat Unduh File Cadangan.

Prosedur

1. Salin file cadangan yang diunduh ke perangkat tempat klien untuk database MongoDB yang dikelola sendiri berada. Alat mongorestore harus diinstal pada perangkat ini.

2. Dekompresi file cadangan.

   File cadangan yang diunduh tersedia dalam format `tar.zst` dan `tar.gz`, yang menggunakan algoritma kompresi zstd dan gzip, masing-masing. Anda dapat memilih format menggunakan parameter `UseZstd` dari operasi API CreateDownload API.

   tar.zst (unduhan konsol)

   zstd -d -c <tar.zst_backup_package> | tar -xvf - -C <decompression_directory_path>

   Pastikan alat zstd tersedia secara lokal dan direktori dekompresi ada.

   Contoh:

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

   tar.gz (format unduhan OpenAPI default)

   tar -zxvf <tar.gz_backup_package> -C <decompression_directory_path>

   Pastikan direktori dekompresi ada.

   Contoh:

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

3. Gabungkan file .bson.

   Salin file `merge_bson_files.py` berikut ke perangkat yang memiliki lingkungan Python.

   import os
   import struct
   import sys
   import argparse
   import shutil
   import re
   
   # Menangani string untuk kompatibilitas Python 2 dan 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): Jalur ke direktori yang berisi file .bson.
           output_dir (str): Jalur ke direktori untuk file keluaran.
           namespace (str): Nama file keluaran, tanpa ekstensi.
       """
       try:
           # Dapatkan semua file .bson yang cocok dengan 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 ada file .bson yang cocok ditemukan di {}".format(input_dir))
               return
   
           output_file = os.path.join(output_dir, "{}.bson".format(namespace))
           if os.path.exists(output_file):
               print("File keluaran {} sudah ada, dilewati...".format(output_file))
               return
   
           print("Menggabungkan {} file menjadi {}...".format(len(files), output_file))
   
           # Stream dan gabungkan file
           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
   
                               # Parse ukuran dokumen (little-endian)
                               doc_size = struct.unpack("<i", size_data)[0]
   
                               # Baca ulang seluruh data dokumen
                               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("Kesalahan membaca {}: {}".format(filename, str(e)))
       except Exception as e:
           print("Kesalahan 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): Jalur ke direktori root yang berisi file .bson.
           output_root (str): Jalur ke direktori root untuk file keluaran. Defaultnya adalah input_root.
       """
       if output_root is None:
           output_root = input_root
   
       # Pastikan direktori root keluaran 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 item adalah direktori, proses itu
           if os.path.isdir(item_path):
               print("Memproses direktori: {}".format(item))
               
               # Buat direktori keluaran 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 direktori
               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 ini adalah 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 ini adalah file .metadata.json, salin langsung ke direktori keluaran 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("Menyalin file metadata: {}".format(sub_item))
               print("Selesai memproses direktori: {}".format(item))
   
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser(description="Gabungkan file .bson secara rekursif")
       parser.add_argument("input_root", help="Jalur ke direktori root yang berisi file .bson")
       parser.add_argument("-o", "--output_root", help="Jalur ke direktori root untuk file keluaran. Defaultnya adalah direktori 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 cadangan ke instans database.

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

   Deskripsi parameter:

   • `<mongodb-uri>`: Alamat high availability (HA) dari database yang dikelola sendiri atau instans ApsaraDB for MongoDB. URI ini berisi nama pengguna, kata sandi, alamat IP server, dan port. Untuk informasi lebih lanjut, lihat dokumentasi resmi.

   • `<db>`: Nama database yang akan dipulihkan.

   • `<collection>`: Nama koleksi yang akan dipulihkan.

   • `<xxx.bson>`: File cadangan .bson untuk memulihkan koleksi tunggal.

   • `<path/to/bson/dir>`: Direktori yang berisi file .bson yang akan dipulihkan.

FAQ