The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Design Patterns in Distributed Systems

Next ►
►

Introduction

Distributed systems are complex architectures where components located on networked computers communicate and coordinate their actions by passing messages. Design patterns in distributed systems help manage this complexity by providing reusable solutions to common problems. This section will cover key design patterns that are particularly useful in distributed systems.

Key Concepts

  1. Scalability: The ability of a system to handle increased load by adding resources.
  2. Fault Tolerance: The capability of a system to continue operating properly in the event of the failure of some of its components.
  3. Consistency: Ensuring that all nodes in a distributed system have the same data at any given time.
  4. Latency: The time it takes for a message to travel from one node to another.
  5. Partitioning: Dividing a database into pieces that can be managed and accessed independently.

Common Design Patterns in Distributed Systems

  1. Leader Election Pattern

Purpose: To ensure that one node in a distributed system acts as the leader to coordinate tasks.

How it works:

  • Nodes in the system communicate to elect a leader.
  • The leader is responsible for managing tasks and coordinating actions.
  • If the leader fails, a new leader is elected.

Example:

import random
import time

class Node:
    def __init__(self, id):
        self.id = id
        self.is_leader = False

    def elect_leader(self, nodes):
        highest_id = max(node.id for node in nodes)
        for node in nodes:
            if node.id == highest_id:
                node.is_leader = True
                print(f"Node {node.id} is elected as the leader.")
            else:
                node.is_leader = False

# Example usage
nodes = [Node(i) for i in range(5)]
random.shuffle(nodes)
nodes[0].elect_leader(nodes)

  1. Replication Pattern

Purpose: To improve fault tolerance and availability by duplicating data across multiple nodes.

How it works:

  • Data is copied to multiple nodes.
  • If one node fails, data can still be accessed from another node.
  • Consistency mechanisms ensure that all copies of the data are the same.

Example:

class DataNode:
    def __init__(self, id):
        self.id = id
        self.data = {}

    def replicate_data(self, key, value, nodes):
        for node in nodes:
            node.data[key] = value
            print(f"Data {key}:{value} replicated to Node {node.id}")

# Example usage
nodes = [DataNode(i) for i in range(3)]
nodes[0].replicate_data('key1', 'value1', nodes)

  1. Sharding Pattern

Purpose: To improve scalability by partitioning data across multiple nodes.

How it works:

  • Data is divided into shards, each managed by a different node.
  • Each shard contains a subset of the data.
  • Requests are routed to the appropriate shard based on the data.

Example:

class Shard:
    def __init__(self, id):
        self.id = id
        self.data = {}

    def add_data(self, key, value):
        self.data[key] = value
        print(f"Data {key}:{value} added to Shard {self.id}")

class ShardManager:
    def __init__(self, num_shards):
        self.shards = [Shard(i) for i in range(num_shards)]

    def get_shard(self, key):
        shard_id = hash(key) % len(self.shards)
        return self.shards[shard_id]

# Example usage
shard_manager = ShardManager(3)
shard = shard_manager.get_shard('key1')
shard.add_data('key1', 'value1')

  1. Circuit Breaker Pattern

Purpose: To prevent cascading failures in a distributed system by stopping the flow of requests to a failing service.

How it works:

  • Monitors the number of failures in a service.
  • If failures exceed a threshold, the circuit breaker trips, and requests are not sent to the failing service.
  • After a timeout period, the circuit breaker allows a limited number of test requests to check if the service has recovered.

Example:

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.failure_count = 0
        self.state = 'CLOSED'
        self.last_failure_time = None

    def call(self, func):
        if self.state == 'OPEN':
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = 'HALF-OPEN'
            else:
                raise Exception("Circuit is open")

        try:
            result = func()
            self.failure_count = 0
            self.state = 'CLOSED'
            return result
        except Exception as e:
            self.failure_count += 1
            if self.failure_count >= self.failure_threshold:
                self.state = 'OPEN'
                self.last_failure_time = time.time()
            raise e

# Example usage
def unreliable_service():
    if random.random() < 0.5:
        raise Exception("Service failure")
    return "Service success"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=5)

for _ in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(result)
    except Exception as e:
        print(e)
    time.sleep(1)

Practical Exercises

Exercise 1: Implementing Leader Election

Task: Modify the Node class to handle leader failure and re-election.

Exercise 2: Data Replication

Task: Extend the DataNode class to handle data consistency checks.

Exercise 3: Sharding with Load Balancing

Task: Implement a load balancer that distributes requests evenly across shards.

Exercise 4: Circuit Breaker with Retry Logic

Task: Enhance the CircuitBreaker class to include retry logic for failed requests.

Conclusion

Design patterns in distributed systems are essential for building scalable, fault-tolerant, and efficient architectures. By understanding and applying these patterns, developers can address common challenges and improve the robustness of their distributed applications. In the next section, we will explore how to select the right pattern for specific scenarios.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved