Neste tutorial, implementamos um simulador completo de Tolerância a Falhas Bizantinas Prática (PBFT) usando asyncio. Modelamos uma rede distribuída realista com passagem de mensagens assíncronas, atrasos configuráveis e nós bizantinos que intencionalmente se desviam do protocolo. Ao implementar explicitamente as fases de pré-preparo, preparo e commit, exploramos como o PBFT alcança consenso em condições adversas, respeitando o limite teórico de 3f+1. Também instrumentamos o sistema para medir a latência do consenso e as taxas de sucesso à medida que o número de nós maliciosos aumenta, permitindo-nos observar empiricamente os limites da tolerância a falhas bizantinas. Copiar Código Copiado Usar um navegador diferente import asyncio import random import time import hashlib from dataclasses import dataclass, field from typing import Dict, Set, Tuple, Optional, List import matplotlib.pyplot as plt PREPREPARE = "PREPREPARE" PREPARE = "PREPARE" COMMIT = "COMMIT" @dataclass(frozen=True) class Msg: typ: str view: int seq: int digest: str sender: int @dataclass class NetConfig: min_delay_ms: int = 5 max_delay_ms: int = 40 drop_prob: float = 0.0 reorder_prob: float = 0.0 Estabelecemos a base do simulador importando as bibliotecas necessárias e definindo os tipos de mensagem PBFT principais. Formalizamos mensagens de rede e parâmetros usando dataclasses para garantir comunicação estruturada e consistente. Também definimos constantes que representam as três fases do PBFT usadas em todo o sistema. Copiar Código Copiado Usar um navegador diferente class Network: def __init__(self, cfg: NetConfig): self.cfg = cfg self.nodes: Dict[int, "Node"] = {} def register(self, node: "Node"): self.nodes[node.nid] = node async def send(self, dst: int, msg: Msg): if random.random() < self.cfg.drop_prob: return d = random.uniform(self.cfg.min_delay_ms, self.cfg.max_delay_ms) / 1000.0 await asyncio.sleep(d) if random.random() < self.cfg.reorder_prob: await asyncio.sleep(random.uniform(0.0, 0.02)) await self.nodes[dst].inbox.put(msg) async def broadcast(self, src: int, msg: Msg): tasks = [] for nid in self.nodes.keys(): tasks.append(asyncio.create_task(self.send(nid, msg))) await asyncio.gather(*tasks) Implementamos uma camada de rede assíncrona que simula a entrega de mensagens do mundo real com atrasos, reordenamento e possíveis quedas. Registramos nós dinamicamente e usamos tarefas asyncio para transmitir mensagens pela rede simulada. Modelamos o comportamento de comunicação não determinístico que impacta diretamente o consenso.
Fonte: MarkTechPost
Publicado em 2026-02-24