En aquest tema, explorarem els algorismes de consens, que són fonamentals per garantir la consistència i la coordinació en sistemes distribuïts. Aquests algorismes permeten que múltiples nodes en un sistema distribuït arribin a un acord sobre un valor o estat compartit, fins i tot en presència de fallades.
Objectius d'Aprenentatge
Al final d'aquest tema, hauràs de ser capaç de:
- Comprendre el concepte de consens en sistemes distribuïts.
- Conèixer els principals algorismes de consens.
- Identificar els desafiaments associats amb la implementació de consens en sistemes distribuïts.
- Aplicar algorismes de consens en escenaris pràctics.
- Introducció al Consens
Què és el Consens?
El consens és el procés pel qual un conjunt de nodes en un sistema distribuït arriben a un acord sobre un valor o estat compartit. Això és crucial per garantir la consistència i la coordinació en sistemes on els nodes poden fallar o comunicar-se de manera imperfecta.
Importància del Consens
- Consistència: Assegura que tots els nodes tinguin la mateixa visió de l'estat del sistema.
- Coordinació: Permet que els nodes treballin junts de manera coherent.
- Tolerància a Fallades: Permet que el sistema continuï funcionant correctament fins i tot si alguns nodes fallen.
- Principals Algorismes de Consens
2.1 Paxos
Descripció
Paxos és un dels algorismes de consens més coneguts i utilitzats. Va ser proposat per Leslie Lamport i és conegut per la seva robustesa i capacitat de tolerar fallades.
Components
- Proposers: Proposen valors.
- Acceptors: Accepten o rebutgen valors proposats.
- Learners: Aprenen el valor que ha estat acceptat.
Funcionament
- Fase de Preparació: Un proposer envia una sol·licitud de preparació als acceptors.
- Fase de Promesa: Els acceptors responen amb una promesa de no acceptar propostes anteriors.
- Fase de Proposta: El proposer envia una proposta amb un valor.
- Fase d'Acceptació: Els acceptors responen si accepten la proposta.
- Fase d'Aprenentatge: Els learners aprenen el valor acceptat.
Exemple de Codi
class Paxos:
def __init__(self):
self.promised_id = None
self.accepted_id = None
self.accepted_value = None
def prepare(self, proposal_id):
if self.promised_id is None or proposal_id > self.promised_id:
self.promised_id = proposal_id
return True
return False
def accept(self, proposal_id, value):
if self.promised_id is None or proposal_id >= self.promised_id:
self.promised_id = proposal_id
self.accepted_id = proposal_id
self.accepted_value = value
return True
return False2.2 Raft
Descripció
Raft és un algorisme de consens dissenyat per ser més comprensible que Paxos. Va ser proposat per Diego Ongaro i John Ousterhout.
Components
- Leaders: Coordinen el procés de consens.
- Followers: Segueixen les instruccions del líder.
- Candidates: Nodes que es postulen per ser líders.
Funcionament
- Elecció de Líder: Els nodes voten per elegir un líder.
- Replicació de Logs: El líder envia entrades de log als followers.
- Confirmació: Els followers confirmen la recepció de les entrades de log.
Exemple de Codi
class RaftNode:
def __init__(self):
self.state = 'follower'
self.current_term = 0
self.voted_for = None
self.log = []
def request_vote(self, candidate_id, term):
if term > self.current_term:
self.current_term = term
self.voted_for = candidate_id
return True
return False
def append_entries(self, term, leader_id, entries):
if term >= self.current_term:
self.current_term = term
self.state = 'follower'
self.log.extend(entries)
return True
return False
- Desafiaments en la Implementació del Consens
3.1 Fallades de Nodes
Els nodes poden fallar en qualsevol moment, i els algorismes de consens han de ser capaços de manejar aquestes fallades sense comprometre la consistència.
3.2 Latència de Xarxa
La latència de xarxa pot retardar la comunicació entre nodes, afectant el temps necessari per arribar a un consens.
3.3 Particions de Xarxa
Les particions de xarxa poden dividir el sistema en subgrups de nodes que no poden comunicar-se entre si, complicant el procés de consens.
- Exercicis Pràctics
Exercici 1: Implementació de Paxos
Implementa una versió simplificada de l'algorisme Paxos en Python. Assegura't de manejar les fases de preparació, promesa, proposta i acceptació.
Exercici 2: Simulació de Raft
Simula l'elecció de líder en un sistema Raft amb tres nodes. Implementa la lògica de votació i replicació de logs.
Solucions
Solució a l'Exercici 1
class SimplePaxos:
def __init__(self):
self.promised_id = None
self.accepted_id = None
self.accepted_value = None
def prepare(self, proposal_id):
if self.promised_id is None or proposal_id > self.promised_id:
self.promised_id = proposal_id
return True
return False
def accept(self, proposal_id, value):
if self.promised_id is None or proposal_id >= self.promised_id:
self.promised_id = proposal_id
self.accepted_id = proposal_id
self.accepted_value = value
return True
return False
# Exemple d'ús
paxos = SimplePaxos()
print(paxos.prepare(1)) # True
print(paxos.accept(1, 'valor1')) # True
print(paxos.prepare(2)) # True
print(paxos.accept(2, 'valor2')) # TrueSolució a l'Exercici 2
class RaftNode:
def __init__(self, node_id):
self.node_id = node_id
self.state = 'follower'
self.current_term = 0
self.voted_for = None
self.log = []
def request_vote(self, candidate_id, term):
if term > self.current_term:
self.current_term = term
self.voted_for = candidate_id
return True
return False
def append_entries(self, term, leader_id, entries):
if term >= self.current_term:
self.current_term = term
self.state = 'follower'
self.log.extend(entries)
return True
return False
# Simulació
node1 = RaftNode(1)
node2 = RaftNode(2)
node3 = RaftNode(3)
# Node 1 es postula com a líder
print(node2.request_vote(1, 1)) # True
print(node3.request_vote(1, 1)) # True
# Node 1 es converteix en líder i envia entrades de log
print(node2.append_entries(1, 1, ['entrada1'])) # True
print(node3.append_entries(1, 1, ['entrada1'])) # TrueResum
En aquest tema, hem après sobre els algorismes de consens, incloent-hi Paxos i Raft, que són fonamentals per garantir la consistència i la coordinació en sistemes distribuïts. Hem explorat els components i el funcionament d'aquests algorismes, així com els desafiaments associats amb la seva implementació. Finalment, hem practicat la implementació d'aquests algorismes amb exercicis pràctics.
En el següent tema, explorarem la replicació de dades, que és una tècnica clau per millorar la disponibilitat i la tolerància a fallades en sistemes distribuïts.
Curs d'Arquitectures Distribuïdes
Mòdul 1: Introducció als Sistemes Distribuïts
- Conceptes Bàsics de Sistemes Distribuïts
- Models de Sistemes Distribuïts
- Avantatges i Desafiaments dels Sistemes Distribuïts