Phân mảnh RDBMS, DHT và Hệ sinh thái NoSQL

Trong phát triển phần mềm truyền thống, Cơ sở Dữ liệu Quan hệ (RDBMS) với mô hình giao dịch ACID thường được coi là giải pháp mặc định. Thế nhưng, Jonas Bonér đã chỉ ra hai rào cản chí mạng khi hệ thống mở rộng lên hàng triệu người dùng:

Bên cạnh đó, việc mở rộng quy mô ghi (Write Scalability) cho một RDBMS tập trung là bất khả thi do chi phí duy trì khóa giao dịch phân tán toàn cục. Để mở rộng RDBMS, kỹ sư bắt buộc phải áp dụng kỹ thuật Sharding (Phân mảnh).

Sharding là sự kết hợp có cấu trúc giữa hai nguyên lý:

Để khắc phục nhược điểm của phép chia modulo khi thêm/bớt máy chủ, các hệ thống phân tán sử dụng Bảng Băm Phân tán (Distributed Hash Table - DHT) dựa trên thuật toán Băm Nhất quán (Consistent Hashing) (tiêu biểu là giao thức Chord và Pastry):

Trong Consistent Hashing, cả máy chủ (nodes) và dữ liệu (keys) đều được ánh xạ lên cùng một vòng tròn băm 32-bit hoặc 128-bit. Mỗi dữ liệu thuộc quyền quản lý của nút kế tiếp đầu tiên theo chiều kim đồng hồ.

• Virtual Nodes (Nút ảo): Mỗi nút vật lý được gán hàng trăm nút ảo trên vòng băm để đảm bảo dữ liệu được phân bố đồng đều, tránh hiện tượng nút mang tải quá lệch.
• Định tuyến O(log N): Bằng cách duy trì bảng ngón tay (Finger Table) trỏ tới các nút ở khoảng cách lũy thừa, bất kỳ nút nào cũng có thể tìm thấy nút đích chỉ trong O(log N) bước nhảy.

Trên nền tảng phân tán của DHT, hệ sinh thái NoSQL phân tách thành hai nhánh kiến trúc lịch sử:

Mẫu cài đặt thuật toán Consistent Hashing với kỹ thuật Virtual Nodes trong Python:

import hashlib
import bisect

class ConsistentHashRing:
    def __init__(self, replicas=3):
        self.replicas = replicas  # Virtual nodes để phân bổ đều
        self.ring = []            # Danh sách hash đã sắp xếp
        self.node_map = {}        # Hash -> Node name

    def _hash(self, key):
        return int(hashlib.md5(key.encode('utf-8')).hexdigest(), 16)

    def add_node(self, node):
        for i in range(self.replicas):
            vnode_key = f"{node}#vnode{i}"
            h = self._hash(vnode_key)
            bisect.insort(self.ring, h)
            self.node_map[h] = node

    def get_node(self, key):
        if not self.ring:
            return None
        h = self._hash(key)
        idx = bisect.bisect_right(self.ring, h)
        if idx == len(self.ring):
            idx = 0  # Quay vòng về đầu (Ring)
        return self.node_map[self.ring[idx]]

ring = ConsistentHashRing(replicas=100)
ring.add_node("Server-1")
ring.add_node("Server-2")
ring.add_node("Server-3")

print("User 1042 thuộc server:", ring.get_node("user_1042"))
print("User 8821 thuộc server:", ring.get_node("user_8821"))

• Nền tảng Thiết kế Hệ thống và Các Đánh đổi Cốt lõi — Scale Up vs Scale Out và tranh chấp tài nguyên.
• Định lý CAP, Mô hình ACID và BASE — Phân tích sự đánh đổi CP vs AP trong Bigtable và Dynamo.
• Các Mô hình và Topo Sao chép Dữ liệu — Sao chép phân đoạn shard để đảm bảo HA.
• Các Chiến lược Bộ nhớ Đệm Phân tán — Lưới dữ liệu phân tán (Data Grids) tăng tốc truy vấn cho NoSQL/RDBMS.