Noduri: calculatoarele rețelei
Un blockchain nu stă pe un server, ci pe mii de calculatoare numite noduri, fiecare cu o copie a lanțului. În această lecție vezi ce tipuri de noduri există, cum sunt conectate între ele și cum ajunge un bloc nou la toată lumea. Apoi modelezi rețeaua în Python ca dicționar de vecini.
Ce este un nod
Un nod (node) este orice calculator care rulează programul rețelei (de exemplu Bitcoin Core) și comunică cu alte noduri. Nu există un nod „șef”: toate sunt egale (peer-to-peer, de la egal la egal). Fiecare nod este conectat direct doar la câțiva vecini (peers), iar mesajele ajung la restul trecând din vecin în vecin.
| Tip de nod | Ce păstrează | Ce face |
|---|---|---|
| Nod complet (full node) | tot lanțul, de la geneză | verifică fiecare bloc și fiecare tranzacție după reguli, le transmite mai departe |
| Nod ușor (light / SPV) | doar antetele blocurilor | verifică că o tranzacție e într-un bloc fără să descarce tot (portofelele de pe telefon) |
| Miner / validator | tot lanțul | pe lângă ce face un nod complet, creează blocuri noi |
Un nod complet Bitcoin are nevoie de sute de GB de spațiu (peste 600 GB în 2025) și de câteva zile pentru prima sincronizare. De aceea telefoanele folosesc noduri ușoare.
Rețeaua ca dicționar de vecini
O rețea se descrie natural ca un dicționar: cheia este numele nodului, valoarea este lista vecinilor lui. Structura se numește listă de adiacență și o vei folosi des în modulul despre rețele.
retea = {
"A": ["B", "C", "D"],
"B": ["A", "C"],
"C": ["A", "B", "D", "E"],
}
print("Vecinii lui A:", retea["A"])
print("C are", len(retea["C"]), "vecini")
print("B e vecin cu C?", "C" in retea["B"])Vecinii lui A: ['B', 'C', 'D'] C are 4 vecini B e vecin cu C? True
Legăturile sunt în ambele sensuri: dacă A e vecin cu B, și B e vecin cu A. De aceea, când aduni lungimile tuturor listelor, fiecare legătură apare de două ori:
retea = {"A": ["B", "C"], "B": ["A"], "C": ["A", "D"], "D": ["C"]}
conexiuni = 0
for nod in retea:
conexiuni += len(retea[nod])
print("Legături (fiecare numărată de 2 ori):", conexiuni)
print("Legături reale:", conexiuni // 2)Legături (fiecare numărată de 2 ori): 6 Legături reale: 3
Cum ajunge un bloc nou la toți
Un nod complet nu acceptă un bloc doar pentru că l-a primit de la un vecin: îl verifică singur. Un bloc invalid se oprește la primul nod onest.
Numărăm nodurile după tip
Cu un dicționar de frecvențe numeri câte noduri sunt din fiecare tip (același tipar ca la solduri: get(cheie, 0) + 1):
tipuri = {"A": "complet", "B": "ușor", "C": "miner", "D": "complet", "E": "ușor"}
numar = {}
for nod, tip in tipuri.items():
numar[tip] = numar.get(tip, 0) + 1
for tip in sorted(numar):
print(tip, numar[tip])complet 2 miner 1 ușor 2
Greșeli frecvente
- „Fiecare nod e conectat cu toate celelalte.” Nu: cu doar câțiva vecini (Bitcoin Core face implicit în jur de 10 conexiuni de ieșire). Mesajele circulă din vecin în vecin.
- „Minerii sunt singurele noduri importante.” Nodurile complete verifică regulile; un miner care încalcă regulile are blocurile respinse de ele.
- Legătură scrisă doar într-un sens în dicționar (A are vecinul B, dar B nu are vecinul A). Rețelele noastre sunt neorientate: scrie legătura în ambele liste.
- **max(retea)** întoarce cheia cea mai mare alfabetic, nu nodul cu cei mai mulți vecini. Ai nevoie de key=.
Noduri în lumea reală
Programul de referință pentru un nod complet Bitcoin; zeci de mii de noduri îl rulează în toată lumea.
Majoritatea folosesc noduri ușoare sau se conectează la serverele furnizorului.
Proiecte ca Umbrel sau Start9 rulează un nod complet pe un mini-PC, ca să-ți verifici singur tranzacțiile.
Validatorii depun câte 32 ETH ca garanție, apoi propun și atestă blocurile; în 2025 erau în jur de un milion.
Rețeaua din figură este dată ca dicționar de vecini. Afișează pentru fiecare nod, în ordinea din dicționar, o linie de forma A: 3 vecini. Apoi găsește nodul cu cei mai mulți vecini și afișează Cel mai conectat: C (4 vecini).
- Parcurge dicționarul retea și afișează numărul de vecini al fiecărui nod cu len.
- Găsește nodul cu cei mai mulți vecini (cu o buclă sau cu max(retea, key=...)).
- Afișează Cel mai conectat: X (N vecini).
Soluția exercițiului
retea = {
"A": ["B", "C", "D"],
"B": ["A", "C"],
"C": ["A", "B", "D", "E"],
"D": ["A", "C", "F"],
"E": ["C", "F"],
"F": ["D", "E"],
}
for nod, vecini in retea.items():
print(f"{nod}: {len(vecini)} vecini")
cel_mai = max(retea, key=lambda nod: len(retea[nod]))
print(f"Cel mai conectat: {cel_mai} ({len(retea[cel_mai])} vecini)") 