কেস স্টাডি: ডিস্ট্রিবিউটেড ফাইল স্টোরেজ ডিজাইন করা

১ · রিকোয়ারমেন্ট

২ · ডিজাইন — চাংকিং ও রেপ্লিকেশন

বড় ফাইল (কল্পনা করুন কয়েক গিগাবাইট) একক নোডে সংরক্ষণ করলে সেই নোডই একটি সিঙ্গেল পয়েন্ট অফ ফেইলিওর হয়ে যায়, এবং সম্পূর্ণ ফাইল একটি ডিস্কে আঁটতেও নাও পারে। সমাধান — ফাইলকে ফিক্সড-সাইজ চাংকChunkএকটি বড় ফাইলকে ভাগ করা ফিক্সড-সাইজ অংশ (যেমন ৬৪ MB) — স্বাধীনভাবে বিভিন্ন স্টোরেজ নোডে বিতরণ ও রেপ্লিকেট করা যায়। -এ (বাস্তবে যেমন ৬৪ MB) ভেঙে অনেকগুলো স্টোরেজ নোডে বিতরণ করা — এতে সমান্তরাল আপলোড/ডাউনলোড সম্ভব হয় এবং কোনো একক নোডের সাইজ-সীমা সমস্যা হয় না।

ডিউরেবিলিটির জন্য প্রতিটি চাংক একাধিক (সাধারণত ৩টি) নোডে রেপ্লিকেট করা হয় (L16-এর রেপ্লিকেশন নীতি), আদর্শভাবে ভিন্ন ফেইলিওর ডোমেইনে (ভিন্ন র‍্যাক/ডেটা সেন্টার) — যাতে একটি নোড, র‍্যাক বা এমনকি পুরো ডেটা সেন্টার হারালেও কোনো চাংক সম্পূর্ণভাবে হারিয়ে না যায়। একটি আলাদা, ছোট মেটাডেটা সার্ভিস ট্র্যাক রাখে কোন ফাইলের কোন চাংক কোন কোন নোডে আছে (GFS-এর NameNode বা HDFS-এর মেটাডেটা-সার্ভারের মতো) — এই মেটাডেটা নিজেই তুলনামূলক ছোট, তাই আলাদাভাবে স্কেল করা হয়।

৩ · ডিপ ডাইভ — চাংকিং, রেপ্লিকেশন ও পুনর্গঠন

নিচের কোড একটি ফাইল (একটি স্ট্রিং, বাইট ডেটার প্রতিনিধিত্ব হিসেবে) ফিক্সড-সাইজ চাংকে ভাগ করে, প্রতিটি চাংক একটি সিমুলেটেড ৬-নোড পুলের ৩টি (ডিটারমিনিস্টিক, র‍্যান্ডম নয়) নোডে বরাদ্দ করে, এবং একটি চাংকের একটি রেপ্লিকা "ডাউন" থাকা অবস্থায়ও reconstruct() ফাইলটি সঠিকভাবে পুনর্গঠন করে দেখায়।

CHUNK_SIZE = 12
NUM_REPLICAS = 3
node_pool = [f"node-{i}" for i in range(6)]   # ৬টি সিমুলেটেড স্টোরেজ নোড

original_file = "ABCL-TECH-DISTRIBUTED-FILE-STORAGE-DEMO-0123456789-END"
chunks = [original_file[i:i + CHUNK_SIZE] for i in range(0, len(original_file), CHUNK_SIZE)]

def replicas_for_chunk(chunk_index, num_replicas=NUM_REPLICAS):
    # ডিটারমিনিস্টিক অ্যাসাইনমেন্ট — একই চাংক-ইনডেক্স সবসময় একই নোডে যায়
    n = len(node_pool)
    return [node_pool[(chunk_index + offset) % n] for offset in range(num_replicas)]

chunk_assignment = {i: replicas_for_chunk(i) for i in range(len(chunks))}

# প্রতিটি নোডের স্টোরেজ সিমুলেট করা: node -> {chunk_index: chunk_data}
storage = {node: {} for node in node_pool}
for i, chunk in enumerate(chunks):
    for node in chunk_assignment[i]:
        storage[node][i] = chunk

print(f"মোট চাংক সংখ্যা: {len(chunks)}")
for i in range(len(chunks)):
    print(f"  চাংক {i} = {chunks[i]!r}  -> রেপ্লিকা: {chunk_assignment[i]}")

def reconstruct(down_node=None, down_chunk_index=None):
    parts = []
    for i in range(len(chunks)):
        data = None
        for node in chunk_assignment[i]:
            if node == down_node and i == down_chunk_index:
                continue   # এই নির্দিষ্ট চাংকের জন্য এই রেপ্লিকাটি "ডাউন"
            if i in storage[node]:
                data = storage[node][i]
                break
        parts.append(data)
    return "".join(parts)

# সিমুলেশন: চাংক ০-এর প্রথম রেপ্লিকা নোড ডাউন
failed_node = chunk_assignment[0][0]
reconstructed = reconstruct(down_node=failed_node, down_chunk_index=0)

print(f"\nচাংক ০-এর রেপ্লিকা '{failed_node}' ডাউন সিমুলেট করা হলো।")
print(f"মূল ফাইল       : {original_file!r}")
print(f"পুনর্গঠিত ফাইল : {reconstructed!r}")
print("পুনর্গঠন সঠিক:", reconstructed == original_file)
assert reconstructed == original_file, "পুনর্গঠন ব্যর্থ!"

৪ · ট্রেড-অফ

৩x রেপ্লিকেশন সরল ও দ্রুত পুনরুদ্ধার দেয়, কিন্তু স্টোরেজ খরচ আসল ডেটার ৩ গুণ। একটি বিকল্প — ইরেজার কোডিংErasure Codingডেটাকে রিডানডেন্সিসহ একাধিক ফ্র্যাগমেন্টে ভাগ করার কৌশল, যেখানে মূল ডেটা মোট ফ্র্যাগমেন্টের একটি উপসেট থেকেই পুনর্গঠন করা যায় — পূর্ণ রেপ্লিকেশনের তুলনায় কম স্টোরেজ ওভারহেডে একই রকম ডিউরেবিলিটি দেয়। — যা পূর্ণ রেপ্লিকেশনের কাছাকাছি ডিউরেবিলিটি অনেক কম স্টোরেজ ওভারহেডে দেয়, কিন্তু পুনর্গঠনের সময় বাড়তি কম্পিউটেশন লাগে (এনকোডিং গণিতে না গিয়ে শুধু ধারণা হিসেবে উল্লেখযোগ্য)। এছাড়া মেটাডেটা সার্ভিস নিজেই একটি গুরুত্বপূর্ণ সিঙ্গেল পয়েন্ট — এটি ছোট হলেও এর নিজস্ব হাই-অ্যাভেইলেবিলিটি ডিজাইন (L37-এর ফেইলওভার নীতি) দরকার, কারণ মেটাডেটা হারালে চাংক জীবিত থাকলেও কোন চাংক কোথায় তা জানা অসম্ভব হয়ে যায়।