...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 12 · Rețea

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.

AcompletBușorCminerDcompletEușorFminercomplet: tot lanțul, verifică totușor: doar anteteleminer: nod complet + creează blocuri
O rețea de 6 noduri: noduri complete, noduri ușoare și mineri, fiecare legat doar de câțiva vecini.
Tip de nodCe 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 blocurilorverifică că o tranzacție e într-un bloc fără să descarce tot (portofelele de pe telefon)
Miner / validatortot lanțulpe lângă ce face un nod complet, creează blocuri noi
Cât de mare e lanțul?

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

1
Un miner găsește un bloc nou și îl trimite vecinilor lui.
2
Fiecare vecin verifică blocul (hash-uri, legături, tranzacții). Dacă e valid, îl adaugă la copia lui.
3
Apoi îl trimite mai departe propriilor vecini, care fac la fel.
4
În câteva secunde blocul ajunge la toate nodurile, chiar dacă fiecare vorbește doar cu câțiva vecini.
Apasul 2Bpasul 3Cpasul 2Dpasul 1Epasul 1Fpasul 0bloc nougăsit de minerul Ffiecare nod verifică blocul și îl trimite mai departe vecinilor săi
Un bloc găsit de minerul F ajunge din vecin în vecin la toate nodurile: pasul arată după câte salturi primește fiecare nod blocul.
Un nod nu are încredere oarbă

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ă

₿Bitcoin Core

Programul de referință pentru un nod complet Bitcoin; zeci de mii de noduri îl rulează în toată lumea.

Portofelele mobile

Majoritatea folosesc noduri ușoare sau se conectează la serverele furnizorului.

Noduri acasă

Proiecte ca Umbrel sau Start9 rulează un nod complet pe un mini-PC, ca să-ți verifici singur tranzacțiile.

ΞValidatorii Ethereum

Validatorii depun câte 32 ETH ca garanție, apoi propun și atestă blocurile; în 2025 erau în jur de un milion.

Exercițiul tău

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).
max(retea, key=lambda nod: len(retea[nod])) întoarce cheia cu lista cea mai lungă.

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)")
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași în blockchain Lecția 12 · Noduri: calculatoarele rețelei
Progres 0% 0 din 17
Lecția curentă 12 / 15 Rețea