← Blog
10 min de lecture
|
Publié le
|
Mis à jour le

Comment configurer un nœud Ethereum (guide 2026)

Configurer un nœud Ethereum : matériel requis, Geth et Lighthouse avec systemd à copier-coller, modes de synchronisation, coûts et alternative par API.

Chapitres
C
Chaingateway Team
Experts blockchain

Relu par Maurice Sobiera

Un nœud Ethereum est un ordinateur qui fait tourner un client d’exécution et un client de consensus, garde une copie vérifiée de la blockchain et sert du JSON-RPC pour lire la chaîne et envoyer des transactions. Selon ethereum.org, un nœud complet demande au moins 16 Go de RAM et un SSD NVMe de 2 To. Ce guide en construit un avec Geth et Lighthouse.

Votre propre nœud vous donne un point d’accès JSON-RPC sans limites de débit imposées par un fournisseur, et sans qu’un tiers voie vos requêtes. Le guide part d’un serveur Ubuntu vierge et arrive à un nœud synchronisé, avec des commandes à copier-coller et les deux clients gérés par systemd. Il couvre aussi le matériel, les modes de synchronisation, les coûts d’exploitation et le moment où une API est le meilleur choix.

Qu’est-ce qu’un nœud Ethereum ?

Un nœud Ethereum est un ordinateur qui exécute un logiciel client Ethereum, stocke une copie de la blockchain, vérifie chaque bloc entrant par rapport aux règles du protocole et répond aux requêtes JSON-RPC des portefeuilles et des applications. La documentation développeur d’Ethereum décrit ce logiciel comme un client et explique le rôle des deux couches.

Depuis le Merge de septembre 2022, un nœud se compose de deux programmes qui tournent côte à côte. Le client d’exécution (Geth, Nethermind, Besu, Erigon ou Reth) détient l’état, exécute les transactions et répond aux appels JSON-RPC. Le client de consensus (Lighthouse, Prysm, Teku, Nimbus ou Lodestar) gère la preuve d’enjeu. Il suit la beacon chain et indique au client d’exécution quel bloc est la tête actuelle.

Les deux clients communiquent sur un port local authentifié (8551) et s’identifient l’un l’autre avec un secret JWT partagé. L’un sans l’autre n’est pas un nœud fonctionnel. Ce détail piège la plupart des opérateurs débutants.

Il existe trois profils de stockage.

  • Un nœud complet garde l’état récent et élague les anciennes données.
  • Un nœud d’archive garde chaque état historique. Le tableau d’ethereum.org indique 12 To ou plus pour Geth, Nethermind et Besu, et environ 2,2 à 2,5 To pour Reth et Erigon.
  • Un nœud léger ne télécharge que les en-têtes. La documentation de Geth indique que la synchronisation légère ne fonctionne pas actuellement depuis le passage à la preuve d’enjeu : ce n’est donc pas une voie d’accès praticable.

Quels sont les prérequis pour un nœud Ethereum ?

Un nœud complet demande au moins 16 Go de RAM et un SSD NVMe de 2 To. Ces chiffres viennent du guide des nœuds d’ethereum.org, qui cite aussi les recommandations matérielles de l’EIP-7870 pour la colonne recommandée. Un nœud d’archive est un autre projet, et un validateur demande plus de CPU, de RAM et de débit montant qu’un simple nœud complet.

ComposantMinimumRecommandé (EIP-7870)
CPU2+ cœurs4+ cœurs (8+ en cas de validation)
RAM16 Go (32 Go recommandés pour la stabilité)32 Go (64 Go en cas de validation)
StockageSSD NVMe de 2 ToSSD NVMe de 4 To, pas de disques sans DRAM ni QLC
Réseau25+ Mbit/s50 Mbit/s en réception, 15+ Mbit/s en émission (25+ en cas de validation)

Deux lignes méritent une explication.

Le stockage doit être du NVMe. La synchronisation écrit de petits blocs aléatoires à haut débit. La documentation de Geth avertit que les disques durs et les SSD bon marché peuvent peiner à synchroniser la chaîne. Les volumes cloud aux IOPS par défaut tombent souvent dans la même catégorie. ethereum.org ajoute que 2 To seront probablement dépassés d’ici 2027 : prévoyez la croissance.

L’espace disque est le goulet d’étranglement. Le tableau d’ethereum.org indique 500 Go ou plus pour une base Geth ou Nethermind synchronisée en snap et 800 Go ou plus pour Besu. Le client de consensus demande encore environ 200 Go pour les données beacon. La documentation de Geth indique que la base grossit d’environ 14 Go par semaine avec la taille de cache par défaut, à la date de septembre 2022. Vérifiez la taille de votre propre répertoire de données après la première synchronisation au lieu de vous fier à un chiffre publié.

Le trafic compte aussi. ethereum.org recommande une connexion illimitée, car la synchronisation initiale et les données que votre nœud diffuse peuvent dépasser un plafond. Linux, macOS et Windows fonctionnent tous. Toutes les commandes ci-dessous supposent Ubuntu 24.04, un choix courant pour les serveurs.

Quelles sont les façons de faire tourner un nœud ?

Vous n’êtes pas obligé de tout assembler à la main. Les boîtiers prêts à l’emploi comme DappNode et Avado sont des machines préconfigurées avec un tableau de bord : achetez-en une, branchez-la, suivez l’assistant. Les cartes ARM fonctionnent aussi. Ethereum on ARM fournit des images de plusieurs clients d’exécution et de consensus pour Raspberry Pi et d’autres cartes ARM. Des lanceurs automatisent la voie manuelle : eth-docker (basé sur Docker, connaissances du terminal requises), Stereum (installe les clients sur un serveur distant par SSH avec une interface graphique), NiceNode (choisir un client, démarrer en quelques clics) et Sedge (un assistant en ligne de commande de Nethermind qui génère une configuration Docker).

Cloud ou local ? Un VPS suffit pour le développement. ethereum.org souligne qu’une grande part des nœuds tourne déjà chez des fournisseurs cloud, ce qui est un point de défaillance unique pour le réseau. Si la résistance à la censure fait partie de votre motivation, utilisez du matériel qui vous appartient.

Le reste de ce guide réalise l’installation manuelle. C’est elle qui apprend le plus, et tout ce que vous apprenez se transpose aux lanceurs.

Pas à pas : Geth + Lighthouse sur Ubuntu

1. Préparer le serveur

Terminal window
sudo apt update && sudo apt upgrade -y
sudo useradd --no-create-home --shell /usr/sbin/nologin geth
sudo useradd --no-create-home --shell /usr/sbin/nologin lighthouse
sudo mkdir -p /var/lib/geth /var/lib/lighthouse
sudo chown geth:geth /var/lib/geth
sudo chown lighthouse:lighthouse /var/lib/lighthouse

Ouvrez les ports peer-to-peer et rien d’autre :

Terminal window
sudo ufw allow 30303 comment 'geth p2p'
sudo ufw allow 9000 comment 'lighthouse p2p'
sudo ufw allow 9001/udp comment 'lighthouse quic'

Les ports 8545 (JSON-RPC) et 8551 (engine API) restent fermés vers l’extérieur. Les deux écoutent sur localhost dans les unités ci-dessous.

2. Installer Geth

Terminal window
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt update
sudo apt install -y ethereum
geth version

3. Installer Lighthouse

Lighthouse est livré sous forme de binaire statique. Cet extrait récupère toujours la dernière version :

Terminal window
LH=$(curl -s https://api.github.com/repos/sigp/lighthouse/releases/latest | grep -m1 '"tag_name"' | cut -d '"' -f 4)
curl -LO "https://github.com/sigp/lighthouse/releases/download/${LH}/lighthouse-${LH}-x86_64-unknown-linux-gnu.tar.gz"
tar xzf "lighthouse-${LH}-x86_64-unknown-linux-gnu.tar.gz"
sudo mv lighthouse /usr/local/bin/
lighthouse --version

Vérifiez le téléchargement. Chaque page de version liste des sommes de contrôle SHA-256 et une signature PGP : lancez sha256sum et comparez, ou importez la clé de Sigma Prime et utilisez gpg --verify. Les binaires remplacés sont un vrai vecteur d’attaque, et la vérification prend une minute.

4. Créer le secret JWT

Terminal window
sudo mkdir -p /var/lib/jwt
openssl rand -hex 32 | sudo tee /var/lib/jwt/jwt.hex > /dev/null

Les deux clients lisent ce fichier. S’ils voient des secrets différents, ils refusent de communiquer (voir le dépannage).

5. Unité systemd pour Geth

Créez /etc/systemd/system/geth.service :

[Unit]
Description=Geth execution client (mainnet)
After=network-online.target
Wants=network-online.target
[Service]
User=geth
Group=geth
Type=simple
Restart=always
RestartSec=5
TimeoutStopSec=600
ExecStart=/usr/bin/geth \
--mainnet \
--syncmode snap \
--datadir /var/lib/geth \
--http --http.addr 127.0.0.1 --http.port 8545 \
--http.api eth,net,web3,txpool \
--authrpc.addr 127.0.0.1 --authrpc.port 8551 \
--authrpc.vhosts localhost \
--authrpc.jwtsecret /var/lib/jwt/jwt.hex
[Install]
WantedBy=multi-user.target

TimeoutStopSec=600 est important : Geth écrit l’état sur disque à l’arrêt, et le tuer trop tôt est la façon classique de corrompre la base.

6. Unité systemd pour Lighthouse

Créez /etc/systemd/system/lighthouse.service :

[Unit]
Description=Lighthouse consensus client (mainnet)
After=network-online.target geth.service
Wants=network-online.target
[Service]
User=lighthouse
Group=lighthouse
Type=simple
Restart=always
RestartSec=5
ExecStart=/usr/local/bin/lighthouse bn \
--network mainnet \
--datadir /var/lib/lighthouse \
--execution-endpoint http://127.0.0.1:8551 \
--execution-jwt /var/lib/jwt/jwt.hex \
--checkpoint-sync-url https://mainnet.checkpoint.sigp.io \
--http
[Install]
WantedBy=multi-user.target

L’URL de checkpoint sync permet à Lighthouse de démarrer depuis un état finalisé récent au lieu de rejouer la beacon chain depuis la genèse, ce qui est bien plus rapide. Vous faites confiance à ce point d’accès pour votre point de départ. Si cela vous gêne, comparez le checkpoint avec un second point d’accès public.

7. Démarrer et surveiller

Terminal window
sudo systemctl daemon-reload
sudo systemctl enable --now geth lighthouse
journalctl -fu geth

Geth journalise d’abord les téléchargements d’en-têtes, puis un flux sans fin de lignes « Imported new chain segment ». Lighthouse signale des slots synchronisés en quelques minutes. Vérifiez la progression de la synchronisation :

Terminal window
curl -s -X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' \
http://127.0.0.1:8545

{"result":false} signifie que la synchronisation est complète. Pendant la synchronisation, vous obtenez à la place un objet de progression.

Combien de temps dure la synchronisation ?

Lighthouse avec checkpoint sync démarre depuis un état finalisé récent et comble les blocs historiques en arrière-plan. Geth en mode snap sync (le mode par défaut) télécharge l’état actuel auprès des peers et reconstruit localement l’arbre d’état. La durée dépend surtout de votre disque et de votre bande passante, et le journal de Geth affiche des estimations de durée pour le téléchargement de l’état. La phase finale est le « state heal », qu’on ne peut pas suivre, car l’étendue des erreurs n’est connue qu’une fois l’état régénéré. Si elle dure des jours sans se terminer, votre disque est trop lent. Voir le dépannage.

Après la synchronisation initiale, les choses se calment. Geth 1.14.0 a fait passer le schéma d’état par défaut de hash à path, selon ses notes de version. Les anciens guides mettent en garde contre une base qui grossit jusqu’à ce que vous l’élaguiez hors ligne : cela vaut pour l’ancienne disposition fondée sur le hash. Geth 1.17 peut aussi supprimer l’historique d’avant le Merge avec --history.chain postmerge, comme le montrent les notes de version v1.17.1. Cela libère de l’espace disque s’il devient serré.

Quel mode de synchronisation choisir ?

Le drapeau --syncmode de l’unité Geth décide quelle part de la chaîne vous vérifiez vous-même et combien d’espace disque vous payez. Il existe trois modes, et le bon dépend des questions auxquelles le nœud doit répondre.

Le snap sync est le mode par défaut, et celui que ce guide utilise. Selon la documentation des modes de synchronisation de Geth, Geth part d’un bloc récent, télécharge l’état auprès des peers, puis répare l’arbre d’état. Le résultat est un nœud complet opérationnel bien plus tôt qu’avec une synchronisation bloc par bloc depuis la genèse.

La synchronisation complète (--syncmode full) ré-exécute chaque bloc depuis la genèse au lieu de télécharger l’état. Le résultat final sur disque est la même base élaguée, mais la synchronisation dure bien plus longtemps que le snap sync. Vous la choisissez pour une seule raison : vous refusez de faire confiance au téléchargement de l’état et voulez recalculer tout l’historique sur votre propre machine. C’est une position de recherche, pas une exigence d’exploitation.

Le mode archive se situe sur un autre axe : --gcmode archive en plus d’une synchronisation complète garde chaque état intermédiaire au lieu de l’élaguer. Seul un nœud d’archive répond à « quel était ce solde au bloc 15 000 000 » ou exécute des traces profondes sans recalcul, ce dont ont besoin les indexeurs, les outils fiscaux et les plateformes d’analyse. D’après le tableau d’ethereum.org, un nœud d’archive complet demande 12 To ou plus sur Geth, Nethermind et Besu. Erigon et Reth stockent l’historique autrement et indiquent environ 2,5 To et 2,2 To. Geth v1.16.0 a ajouté un mode archive expérimental fondé sur path. Selon les notes de version, l’historique complet de l’état du mainnet y demande environ 1,9 To (sans les index de transactions et de logs), et il ne garde par défaut que les 90 000 derniers blocs d’historique.

ModeDisque (estimation ethereum.org)Synchronisation initialeRequêtes d’état historique
Snap (par défaut)500 Go ou plus sur GethLa plus rapide des modes Geth128 derniers blocs seulement
FullMême taille élaguéeBien plus lente que snap128 derniers blocs seulement
Archive sur Geth (hash), Nethermind, Besu12 To ou plusLa plus lenteOui
Archive sur Erigon ou Reth2,2 à 2,5 To ou plusNon indiquéeOui

Pour un back-end de paiement, le snap sync répond à tout : soldes actuels, nouveaux blocs, reçus de transaction. L’archive sert le jour où vous devez reconstituer le passé.

Quels clients faire tourner ?

Geth avec Lighthouse est un bon choix par défaut, et sa popularité est justement le piège. La page d’ethereum.org sur la diversité des clients explique le risque. Un bug dans un client de consensus utilisé par plus de 33 pour cent des nœuds pourrait empêcher la couche de consensus de finaliser. Un bug critique dans un client qui détient une majorité des deux tiers pourrait scinder la chaîne et la faire finaliser de façon erronée, et les validateurs sur la mauvaise chaîne risquent le slashing.

Pour les parts actuelles des clients, consultez clientdiversity.org plutôt que de vous fier à un chiffre dans un guide. La répartition change, et ethereum.org indique qu’idéalement aucun client ne dépasse 33 pour cent. Le réseau gagne en sécurité chaque fois qu’un opérateur choisit un client minoritaire. L’opérateur y perd peu, car tous les clients d’exécution parlent le même JSON-RPC et tous les clients de consensus la même API beacon.

ClientCoucheLangage
GethExécutionGo
NethermindExécutionC#
BesuExécutionJava
RethExécutionRust
ErigonExécutionGo
LighthouseConsensusRust
PrysmConsensusGo
TekuConsensusJava
NimbusConsensusNim

Pour un premier nœud, l’association de ce guide convient. Pour un deuxième nœud, ou tout usage professionnel, choisissez une association minoritaire, comme Nethermind avec Teku ou Reth avec Nimbus. L’installation ci-dessus se transpose presque à l’identique. Chaque association demande le même secret JWT et le même câblage de l’engine API. Seuls les binaires, les drapeaux et les répertoires de données changent.

Combien coûte un nœud Ethereum ?

Le coût dépend de votre matériel propre ou d’un serveur loué. Cette section donne donc le calcul plutôt que des prix. Les prix changent chaque mois et varient selon les pays.

Matériel propre : une machine de la classe des prérequis (4 à 8 cœurs, 32 Go de RAM, 2 à 4 To de NVMe) est un achat unique. Le coût d’exploitation est l’électricité. Multipliez la puissance moyenne de la machine en kilowatts par 720 heures et par votre tarif au kWh. Une machine qui consomme 50 W coûte 0,05 kW × 720 h = 36 kWh par mois, que vous multipliez par votre prix de l’électricité. Ajoutez la connexion Internet que vous payez déjà.

Serveur loué : 2 To de NVMe, c’est plus que ce que proposent beaucoup d’offres VPS, vous finirez donc peut-être avec un serveur dédié. ethereum.org note que le prix d’un serveur loué peut grimper à cause du stockage requis. Les instances cloud à IOPS provisionnés coûtent en général plus cher que la machine dédiée équivalente : comparez donc des devis pour la même taille de disque.

Votre temps : la première installation prend un après-midi avec ce guide. Ensuite, vous mettez à jour les clients et regardez les journaux de temps en temps. Si vous facturez votre temps, ajoutez cette ligne au total.

Surveillance et contrôles de santé

Trois questions couvrent la santé d’un nœud : le processus tourne-t-il, est-il synchronisé, a-t-il des peers. systemd répond à la première avec systemctl is-active geth lighthouse. Les deux autres ont des points d’accès sur les deux couches :

Terminal window
# execution: peer count as hex; eth_syncing from step 7 covers sync state
curl -s -X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' \
http://127.0.0.1:8545
# consensus: HTTP 200 = synced, 206 = still syncing
curl -s -o /dev/null -w '%{http_code}\n' \
http://127.0.0.1:5052/eth/v1/node/health

L’API REST de Lighthouse écoute sur le port 5052 grâce au drapeau --http déjà présent dans l’unité. Le point d’accès /eth/v1/node/health encode l’état de synchronisation dans le code de statut HTTP, ce qui en fait une sonde naturelle pour les scripts et les répartiteurs de charge. /eth/v1/node/syncing renvoie la distance en slots si vous voulez le chiffre. Une tâche cron qui lance ces contrôles plus df -h /var/lib/geth et envoie un e-mail en cas d’anomalie constitue une surveillance complète pour un nœud personnel.

Pour des tableaux de bord, ajoutez --metrics à Geth (point d’accès Prometheus sur le port 6060) et --metrics à Lighthouse (port 5054), gardez les deux sur localhost et importez les tableaux de bord Grafana que les deux projets publient. Quoi que vous construisiez, définissez d’abord deux alertes : une utilisation du disque au-dessus de 85 pour cent, et une hauteur de bloc figée pendant dix minutes. Ces deux alertes attrapent presque toutes les vraies pannes avant vos utilisateurs.

Maintenance et mises à jour

Les mises à jour des clients ne sont pas optionnelles. Les hard forks exigent de nouveaux logiciels, et un nœud en ancienne version cesse tout simplement de suivre la chaîne au bloc du fork. Abonnez-vous aux flux de versions de Geth et de Lighthouse sur GitHub et au blog de l’Ethereum Foundation.

La procédure reste courte. Geth installé depuis le PPA se met à jour avec sudo apt upgrade et sudo systemctl restart geth, puis geth version confirme. Lighthouse est un binaire unique : refaites le téléchargement de l’étape 3, remplacez /usr/local/bin/lighthouse, redémarrez l’unité. Lisez les notes de version avant de redémarrer. Des drapeaux sont parfois renommés, et un drapeau renommé dans une unité systemd donne un service qui refuse de démarrer à 2 h du matin.

Prévoyez aussi la croissance du disque. La documentation de Geth donne environ 14 Go par semaine pour la taille de cache par défaut, un chiffre de septembre 2022. Mesurez votre propre croissance sur quelques semaines avec du. Sur un disque de 2 To, vous pouvez libérer de l’espace en élaguant l’historique d’avant le Merge (voir le dépannage) ou en resynchronisant. Avec 4 To, la croissance devient une ligne budgétaire annuelle au lieu d’un problème trimestriel. Le nœud n’a pas besoin d’être en ligne à chaque seconde, mais plus il reste hors ligne, plus il lui faut de temps pour rattraper son retard.

Un nœud complet n’est pas un validateur

Les 32 ETH dont tout le monde a entendu parler relèvent du staking, pas de l’exploitation d’un nœud. Le nœud de ce guide n’a besoin d’aucun ETH. Il valide les blocs au sens où il les vérifie, ce qui coûte du matériel, pas une mise.

Un validateur est un troisième programme à côté des deux clients : il détient des clés de signature, produit des attestations et des blocs, et gagne des récompenses pour cela, avec une adresse de destinataire des frais configurée pour les revenus. Les 32 ETH sont une garantie que le protocole peut slasher en cas de faute prouvée. L’exigence opérationnelle change aussi. Un nœud RPC qui passe un week-end hors ligne rattrape son retard le lundi, alors qu’un validateur hors ligne perd de petites pénalités à chaque epoch.

Avec moins de 32 ETH, les protocoles de staking mutualisé sont la porte d’entrée. Un simple nœud complet ne rapporte rien. Vous le faites tourner pour l’indépendance et la confidentialité, pour le développement, ou comme base sur laquelle un validateur s’appuiera plus tard.

Sécurité : la disposition des ports est la politique

Tout le modèle de sécurité de cette installation se lit dans les règles de pare-feu de l’étape 1. Les ports 30303 et 9000/9001 sont ouverts, car le peer-to-peer a besoin d’inconnus. Les ports 8545 et 8551 écoutent sur 127.0.0.1, car rien hors de la machine n’a affaire là. Le secret JWT authentifie l’engine API sur 8551, mais voyez-y une seconde couche, pas une raison d’exposer le port.

Un port 8545 ouvert est la pire erreur, car le serveur JSON-RPC n’a pas d’authentification. La documentation de sécurité de Geth demande aux opérateurs de bloquer tout le trafic vers le port RPC, sauf depuis des machines explicitement de confiance. Elle avertit que les espaces de noms exposés augmentent le risque de demandes de signature parasites. Gardez --http.api sur les quatre espaces de noms de l’unité. Laissez admin, debug et personal désactivés sur toute machine dont le port RPC pourrait un jour être joignable.

Quand d’autres machines ont un besoin légitime du RPC, passez par un tunnel au lieu d’exposer : WireGuard ou un tunnel SSH pour vous, nginx ou Caddy avec TLS et une liste d’IP autorisées pour une petite équipe. Les clients tournent déjà comme utilisateurs système sans connexion (étape 1) : un processus client compromis n’a donc pas de compte shell à hériter. Ajoutez unattended-upgrades pour les correctifs du système, et la partie ennuyeuse de la sécurité du serveur se règle seule.

Dépannage

Lighthouse ne joint pas Geth (« Unable to connect to execution endpoint »)

Soit Geth est arrêté (systemctl status geth), soit les secrets JWT diffèrent. Confirmez que les deux unités pointent vers le même chemin jwt.hex. En cas de doute, régénérez le secret une fois et redémarrez les deux services.

Geth reste bloqué sur « State heal in progress » pendant des jours

La phase de state heal poursuit la tête de la chaîne, et un disque aux faibles performances d’écriture aléatoire ne la rattrape jamais. Mesurez les lectures et écritures aléatoires de 4 ko avec fio et comparez le résultat avec les listes de disques vers lesquelles renvoie la documentation de Geth. Les SSD SATA et les volumes cloud par défaut sont les suspects habituels. La solution est un vrai stockage NVMe : aucun drapeau ne sauve un disque lent.

Le nombre de peers reste à zéro

Le port 30303 (TCP et UDP) est bloqué ou non redirigé par votre NAT. Vérifiez aussi l’horloge système : timedatectl doit montrer une synchronisation NTP active, car une horloge décalée casse les handshakes de peers côté consensus.

Le disque se remplit

Trouvez d’abord où ça grossit : du -h --max-depth=2 /var/lib/geth. Un répertoire de données créé avant Geth 1.14.0 garde l’ancienne disposition fondée sur le hash, car le nouveau défaut ne s’applique qu’aux bases neuves. La solution propre est une resynchronisation, après laquelle l’état reste élagué automatiquement. L’élagage de l’historique d’avant le Merge (--history.chain postmerge, Geth 1.17) libère plus d’espace, et le magasin ancien peut passer sur un disque moins cher via --datadir.ancient.

Geth signale une corruption de la base après un crash

Une coupure de courant, un kill -9 ou un arrêt par l’OOM en pleine écriture laisse au démarrage suivant des lignes de journal sur une corruption ou des données manquantes. Parfois un redémarrage répare. Si le journal boucle, cessez de réparer et resynchronisez : écartez le répertoire de données, repartez de zéro et laissez le snap sync tout reconstruire, ce qui est en général plus rapide que toute tentative de récupération. La prévention est déjà dans l’unité : TimeoutStopSec=600 laisse à Geth le temps d’écrire, et un systemctl stop propre est la seule façon dont le processus devrait se terminer.

L’OOM killer arrête Geth

journalctl -k | grep -i oom confirme le soupçon. Le --cache de Geth vaut 4 Go par défaut depuis la v1.17.2, et l’usage réel peut dépasser ce réglage pendant la synchronisation. Ajoutez Lighthouse et le système d’exploitation, et une machine de 16 Go peut manquer de mémoire. Définissez --cache 2048 sur les petites machines et gardez un fichier d’échange comme tampon : lent vaut mieux que tué, car un Geth tué n’écrit rien et ouvre la voie à la corruption décrite plus haut.

Dois-je faire tourner mon propre nœud ou utiliser une API ?

Cela dépend de la charge de travail. Chaingateway vend l’alternative par API : cette comparaison indique donc où chaque option convient.

Le nœud l’emporte quand vous avez besoin de JSON-RPC brut, lourd et soutenu : requêtes d’archive, traçage, surveillance de la mempool, ou confidentialité et résistance à la censure maximales. Un nœud a un coût fixe et aucun comptage de requêtes : il devient donc moins cher qu’une offre RPC facturée à la requête dès que votre volume est assez élevé. Utilisez le calcul de coût ci-dessus pour trouver ce seuil avec vos propres prix. C’est aussi une bonne façon d’apprendre comment fonctionne Ethereum.

L’API l’emporte quand le nœud ne serait qu’un moyen, ce qui, pour la plupart des entreprises, signifie les paiements. Un nœud synchronisé vous donne eth_sendRawTransaction et les logs d’événements. Il ne vous donne pas d’adresses de dépôt par client, de notifications à l’arrivée d’un paiement ERC-20, de gestion de clés ni de logique de nouvelle tentative. C’est du logiciel applicatif que vous devriez construire et exploiter par-dessus le nœud.

L’API Ethereum de Chaingateway est cette couche manquante : créer et importer des adresses (POST /api/v2/ethereum/addresses/import), envoyer des tokens ERC-20 (POST /api/v2/ethereum/transactions/erc20) et recevoir des webhooks signés en HMAC pour les dépôts entrants. Les livraisons échouées atterrissent dans une liste interrogeable (GET /api/v2/ethereum/webhooks/notifications/failed) et peuvent être renvoyées par le point d’accès de nouvelle tentative.

Le seuil de rentabilité est de l’arithmétique : coût du serveur plus vos heures de construction et d’exploitation, contre un forfait de la page des tarifs. Pour les flux de paiement, comptez les heures de construction de la détection de dépôts et de la gestion des clés. Pour une consommation de RPC brut, le nœud a l’avantage.

Commencez avec le quickstart et le guide des webhooks. L’essai gratuit de 7 jours sans carte ni KYC suffit pour tester un flux de dépôt de bout en bout (inscrivez-vous ici).

Vous faites tourner d’autres chaînes ? Consultez les guides pour BNB Smart Chain et TRON.

Questions fréquentes

Un ordinateur qui conserve sa propre copie vérifiée de la blockchain Ethereum et vous permet de lire la chaîne et d’envoyer des transactions sans demander la permission à personne. Techniquement, ce sont deux programmes qui coopèrent : un client d’exécution et un client de consensus.

ethereum.org indique un SSD NVMe de 2 To comme minimum pour un nœud complet et 4 To comme recommandation dans l’EIP-7870. Une base Geth synchronisée en snap demande plusieurs centaines de Go ou plus, plus environ 200 Go pour les données beacon du client de consensus, et elle grossit avec le temps.

Oui, si la carte respecte les prérequis. ethereum.org note que les clients peuvent tourner sur un ordinateur monocarte, et Ethereum on ARM fournit des images pour Raspberry Pi et d’autres cartes ARM. Il faut quand même 16 Go de RAM et un disque NVMe rapide. Attendez-vous à une première synchronisation plus lente et à peu de marge pour de fortes charges RPC.

Non. Les récompenses vont aux validateurs, qui exigent 32 ETH mis en jeu en plus d’un nœud en fonctionnement, ou la participation à un pool de staking. Un simple nœud complet contribue à la santé du réseau et vous donne un accès sans confiance, mais ne rapporte rien.

Pour un nombre de peers correct, redirigez le port 30303 pour Geth et 9000/9001 pour Lighthouse. Sans cela, le nœud se synchronise quand même, mais plus lentement. N’exposez jamais 8545 ou 8551 sur Internet.

Comment nous rédigeons ces articles

Prêt à le construire vous-même ? Obtenir votre clé API — essai de 7 jours, sans carte bancaire — ou consultez API Ethereum pour la référence complète des endpoints.

C
Chaingateway Team
Experts blockchain

L'équipe Chaingateway s'attache à simplifier l'intégration blockchain pour les développeurs du monde entier.