Modèles de cohérence des données

In distributed systems, data is often copied and stored on multiple servers. Data consistency refers to ensuring that all these copies of data are the same at any given time.

Think of it like having multiple copies of a book. If you update one copy, how quickly and reliably do all other copies get that same update?

The CAP Theorem is a fundamental concept in distributed systems. It states that a distributed data store can only guarantee two out of three properties at any given time:

• Consistency (all nodes see the same data at the same time)
• Availability (every request receives a response, without guarantee of it being the latest write)
• Partition Tolerance (the system continues to operate despite network failures)

When designing systems, we often make trade-offs, especially between Consistency and Availability.

Strong consistency means that after a data write operation is completed, any subsequent read operation is guaranteed to see that updated data.

It's like everyone watching a live broadcast – they all see the same thing at the exact same moment. There's no delay in information spreading.

A classic example of where strong consistency is crucial is in banking transactions.

• When you transfer money, your account balance must immediately reflect the change.
• The recipient's account must also immediately show the received funds.
• Any delay or inconsistency could lead to serious financial errors.

Databases like traditional SQL databases (e.g., PostgreSQL, MySQL) often provide strong consistency.

Eventual consistency means that if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value.

It implies a delay. Think of a news story that slowly spreads across different news outlets. Some might have it sooner, but eventually, everyone gets the same story.

Eventual consistency is common in systems where high availability and performance are prioritized over immediate data accuracy across all nodes.

• Social Media Feeds: If you 'like' a post, it might take a few seconds for that 'like' count to update for all your friends.
• DNS (Domain Name System): When a website's IP address changes, it takes time for this update to propagate globally.

NoSQL databases like Cassandra and DynamoDB often leverage eventual consistency.

Choosing strong consistency comes with certain trade-offs:

• Pros: Data is always accurate and up-to-date, making it easier to reason about data.
• Cons: Higher latency due to coordination between nodes, reduced availability during network partitions, and more complex scaling.

It's like having a single, authoritative source of truth that all systems must check with before proceeding.

Eventual consistency also has its own set of advantages and challenges:

• Pros: High availability and fault tolerance, lower latency reads and writes, easier to scale horizontally.
• Cons: Reads might return stale data, developers need to handle potential data conflicts and reconciliation logic.

It allows systems to operate independently, improving performance, but requires careful design to manage temporary inconsistencies.

While strong and eventual consistency are the most common, other models exist:

• Causal Consistency: If event A caused event B, then every node that sees B must also see A. However, unrelated events can be seen in different orders.
• Read-your-writes Consistency: A user is guaranteed to read their own latest write, even if other users might not see it yet.

These models offer different balances between consistency and performance.

The best consistency model depends entirely on your application's specific requirements:

• If data accuracy and integrity are paramount (e.g., financial transactions, inventory counts), strong consistency is often preferred.
• If high availability, low latency, and massive scale are more critical, and temporary inconsistencies are acceptable (e.g., social media feeds, IoT sensor data), eventual consistency might be a better choice.

It's a crucial design decision that impacts system architecture and user experience.

Consider a system that tracks the number of views on a popular video. Which consistency model would typically be chosen if prioritizing high availability and responsiveness, even if the view count isn't immediately 100% accurate across all users globally?

We've explored data consistency, a vital concept in distributed system design. You learned about:

• Strong Consistency: All data replicas are identical at all times, crucial for financial systems.
• Eventual Consistency: Replicas eventually converge, offering higher availability and scalability for systems like social media feeds.
• The CAP Theorem: The fundamental trade-off between Consistency, Availability, and Partition Tolerance.

Choosing the right consistency model is a key decision based on your application's specific needs and priorities.