Sharding dan Replikasi Data

As your application grows, a single database might struggle to handle all the data and traffic. This can lead to slow performance and even system crashes.

To build truly scalable and reliable systems, we need advanced strategies to manage data across multiple machines. This lesson explores two key techniques: sharding and replication.

Imagine a giant library with millions of books. If all books are on one shelf, finding a specific one is hard and slow. Sharding is like splitting that library into many smaller, manageable sections, each on its own shelf.

• It's a database partitioning technique.
• Data is divided into smaller, independent "shards".
• Each shard is a complete database instance.

Sharding helps overcome the limitations of a single database server. It provides several crucial benefits:

• Horizontal Scalability: Add more machines (shards) as data grows.
• Improved Performance: Queries run faster on smaller datasets.
• Reduced Load: Distributes read/write operations across multiple servers.
• Increased Throughput: Handle more concurrent requests.

When you shard a database, you need a way to decide which piece of data goes into which shard. This is done using a shard key (or partition key).

The shard key is a column (or set of columns) in your table that determines how data is distributed. For example, user IDs could be used to shard user data across different servers.

Different methods exist for distributing data:

• Range-based Sharding: Data is partitioned based on a range of values (e.g., users with IDs 1-1000 on shard A, 1001-2000 on shard B).
• Hash-based Sharding: A hash function is applied to the shard key, and the result determines the shard (e.g., hash(userID) % numShards).
• Directory-based Sharding: A lookup table (directory) maps the shard key to the appropriate shard.

While sharding helps with scaling, what if a single shard fails? That's where data replication comes in. Replication means creating multiple copies of your data and storing them on different servers.

This ensures your system remains available even if one server goes down, providing fault tolerance and high availability.

A common replication pattern is Master-Replica (or Primary-Secondary). Here's how it works:

• One server is the master (primary) database, handling all write operations.
• Multiple replica (secondary) databases receive copies of the data from the master.
• Replicas typically handle read operations, distributing the read load.

Replication can be synchronous (data written to all replicas before confirming) or asynchronous (master confirms write before replicas receive it).

In a Multi-Master setup, multiple database instances can accept write operations. This offers even higher availability and can improve write performance in geographically distributed systems.

However, it introduces complexities like conflict resolution, as concurrent writes to the same data on different masters need to be reconciled.

Sharding and replication are often used together to build highly scalable and resilient systems. Each shard can itself be a replicated set of databases (e.g., a master with multiple replicas).

This combination ensures that:

• Data is distributed horizontally (sharding).
• Each distributed piece of data is highly available and fault-tolerant (replication).

While powerful, sharding and replication introduce complexities:

• Increased Operational Complexity: Managing multiple database instances is harder.
• Data Rebalancing: Redistributing data when adding/removing shards can be tricky.
• Distributed Transactions: Ensuring consistency across multiple shards can be challenging (a topic for advanced lessons).
• Shard Key Choice: A poor shard key can lead to "hot spots" (one shard overloaded).

In this lesson, we explored two critical techniques for advanced data storage:

• Sharding: Dividing a large database into smaller, independent pieces (shards) to achieve horizontal scalability and improve performance.
• Replication: Creating multiple copies of data on different servers to ensure high availability, fault tolerance, and distribute read loads.

Together, these strategies are fundamental to building robust, high-performance systems that can handle massive amounts of data and traffic.