GSP1116

Présentation

L'hébergement de vos propres nœuds de blockchain peut être nécessaire pour des raisons de sécurité, de conformité, de performances ou de confidentialité. De plus, un réseau décentralisé, résilient et durable constitue le socle indispensable de tout protocole de blockchain. Les développeurs Web3 peuvent utiliser Blockchain Node Engine de Google Cloud, une solution d'hébergement de nœuds entièrement gérée pour le développement Web3. Les organisations peuvent également configurer et gérer leurs propres nœuds dans Google Cloud. En tant que partenaire de confiance pour l'infrastructure Web3, Google Cloud propose une infrastructure d'hébergement de nœuds sécurisée, fiable et évolutive. Pour en savoir plus sur l'hébergement de nœuds sur Google Cloud, consultez l'article de blog Présentation de Blockchain Node Engine : hébergement de nœuds entièrement géré pour le développement Web3.

Pour en savoir plus sur les considérations techniques et les décisions architecturales que vous devez prendre lorsque vous déployez des nœuds de blockchain autogérés dans le cloud, consultez l'article de blog Google Cloud pour le Web3.

Dans cet atelier, vous allez créer une machine virtuelle (VM) pour déployer un nœud RPC Ethereum. Un nœud RPC Ethereum est en mesure de recevoir les mises à jour de la blockchain provenant du réseau et de traiter les requêtes API RPC. Vous utilisez un type de machine e2-standard-4 avec un disque de démarrage de 20 Go, quatre processeurs virtuels (vCPU) et 16 Go de RAM. Pour vous assurer de disposer d'un espace suffisant pour les données de la blockchain, vous devez associer un disque SSD de 200 Go à l'instance. Vous utilisez Ubuntu 20.04 et déployez deux services : Geth, la "couche d'exécution", et Lighthouse, la "couche de consensus". Ces deux services fonctionnent ensemble pour former un nœud RPC Ethereum.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Créer une instance Compute Engine avec un disque persistant
• Configurer une adresse IP statique et des règles de pare-feu de réseau
• Programmer des sauvegardes régulières
• Déployer Geth, la couche d'exécution d'Ethereum
• Déployer Lighthouse, la couche de consensus d'Ethereum
• Effectuer des appels RPC Ethereum
• Configurer Cloud Logging
• Configurer Cloud Monitoring
• Configurer des tests de disponibilité

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).

Remarque : Ouvrez une fenêtre de navigateur en mode incognito (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• Vous disposez d'un temps limité. N'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la droite, vous trouverez le panneau Préparation et accès à l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Les identifiants temporaires (nom d'utilisateur et mot de passe) que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier, si nécessaire

   Notez que le minuteur de l'atelier se trouve en haut de la page et indique le temps restant.

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans une fenêtre en navigation privée si vous utilisez Chrome).

   L'atelier lance les ressources, puis ouvre la page "Se connecter" dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau Préparation et accès à l'atelier.

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau Préparation et accès à l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. N'utilisez pas les identifiants de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires pourront vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Dans cet atelier, vous allez utiliser les outils suivants :

• Ubuntu 24.04
• Geth
• Lighthouse
• Curl
• gcloud

Tâche 1 : Créer l'infrastructure de la machine virtuelle

Créez une adresse IP statique publique, une règle de pare-feu, un compte de service, une programmation d'instantanés et une machine virtuelle avec la nouvelle adresse IP. Il s'agit de l'infrastructure sur laquelle Ethereum est déployé.

Créer une adresse IP statique publique

Dans cette section, vous allez configurer l'adresse IP publique utilisée pour la machine virtuelle.

1. Dans la console Cloud, accédez au menu de navigation () > Réseau VPC > Adresses IP.
2. Cliquez sur Réserver une adresse IP externe sur la fiche Adresses IP pour créer l'adresse IP statique.
3. Pour configurer l'adresse statique, utilisez les éléments suivants :

Propriété	Valeur (à saisir ou sélectionner)
Nom	eth-mainnet-rpc-ip
Niveau de service réseau	Premium
Version IP	IPv4
Type	Régional
Région
associée	Aucune

4. Cliquez sur RÉSERVER.

Créer une règle de pare-feu

Créez des règles de pare-feu pour que la VM puisse communiquer sur les ports désignés.

Geth P2P communique sur TCP et UDP sur le port 30303. Lighthouse P2P communique sur TCP et UDP sur le port 9000. Geth RPC utilise le port TCP 8545.

1. Dans la console Cloud, accédez au menu de navigation () > Réseau VPC > Pare-feu.
2. Cliquez sur Créer une règle de pare-feu dans la barre d'action pour créer les règles de pare-feu.
3. Pour configurer le pare-feu, utilisez les éléments suivants :

Propriété	Valeur (à saisir ou sélectionner)
Nom	eth-rpc-node-fw
Journaux	désactivés
Réseau	par défaut
Priorité	1000
Sens du trafic	Entrée
Action en cas de correspondance	Autoriser
Cibles	Tags cibles spécifiés
Tags cibles	eth-rpc-node (appuyez sur Entrée après avoir saisi la valeur)
Filtre source	Plages IPv4
Plages IPv4 sources	0.0.0.0/0 (appuyez sur Entrée après avoir saisi la valeur)
Protocoles et ports spécifiés :	TCP : 30303, 9000, 8545 UDP : 30303, 9000

4. Cliquez sur CRÉER.

Créer un compte de service

Créez un compte de service que la VM utilisera pour fonctionner.

1. Dans la console Cloud, accédez au menu de navigation () > IAM et administration > Comptes de service.
2. Cliquez sur Créer un compte de service dans la barre d'action pour créer le compte de service.
3. Pour configurer le compte de service, utilisez les éléments suivants :

Propriété	Valeur (à saisir ou sélectionner)
Nom du compte de service	eth-rpc-node-sa
ID du compte de service	eth-rpc-node-sa

4. Cliquez sur CRÉER ET CONTINUER.
5. Ajoutez les rôles suivants :

Propriété	Valeur (à saisir ou sélectionner)
Rôles	Connexion au système d'exploitation Compute, Contrôleur du service, Rédacteur de journaux, Rédacteur de métriques de surveillance, Agent Cloud Trace, Utilisateur de réseau Compute

6. Cliquez sur CONTINUER.
7. Cliquez sur OK.

Créer une programmation d'instantanés

Dans cette section, vous allez configurer la programmation d'instantanés utilisée pour le disque associé à la machine virtuelle, qui contient les données de la blockchain. Cela sauvegardera les données de la chaîne.

1. Dans la console Cloud, accédez au menu de navigation () > Compute Engine > Instantanés.
2. Cliquez sur Créer une programmation d'instantanés pour créer la programmation d'instantanés.
3. Pour programmer des instantanés, utilisez les éléments suivants :

Propriété	Valeur (à saisir ou sélectionner)
Nom	eth-mainnet-rpc-node-disk-snapshot
Région
Régional
Options de programmation	Fréquence de programmation : Tous les jours, Heure de début (UTC) : 18h00 - 19h00, Supprimer automatiquement les instantanés après : 7
Règle de suppression	Conserver les instantanés

4. Cliquez sur CRÉER.

Créer une machine virtuelle

Dans cette section, vous allez configurer la machine virtuelle utilisée pour le déploiement d'Ethereum.

1. Dans la console Cloud, accédez au menu de navigation () > Compute Engine > Instances de VM.

2. Cliquez sur Créer une instance pour créer la VM.

3. Dans la section Configuration de la machine

   Saisissez la valeur indiquée dans le champ suivant :

   Propriété	Valeur (à saisir ou sélectionner)
   Nom	eth-mainnet-rpc-node
   Région
   Zone
   Série	E2
   Type de machine	e2-standard-4

4. Cliquez sur OS et stockage.

   Cliquez sur Modifier, puis sélectionnez les valeurs suivantes :

   Propriété	Valeur (saisir ou sélectionner)
   Système d'exploitation	Ubuntu
   Version	Ubuntu 24.04 LTS (x86/64)
   Type de disque de démarrage	Disque persistant SSD
   Taille	50 Go

   Cliquez sur Sélectionner.

   Dans Disques supplémentaires, cliquez sur Ajouter un disque.

   Propriété	Valeur (saisir ou sélectionner)
   Nom	eth-mainnet-rpc-node-disk
   Type de source du disque	Disque vide
   Type de disque	Disque persistant SSD
   Taille	200 Go (ou 2 000 Go pour les installations plus importantes)

   Cliquez sur Enregistrer.

5. Cliquez sur Protection des données.

   Pour "Programmations d'instantanés", sélectionnez eth-mainnet-rpc-node-disk-snapshot.

6. Cliquez sur Mise en réseau.

   Propriété	Valeur (à saisir ou sélectionner)
   Tags réseau	eth-rpc-node (appuyez sur Entrée après avoir saisi la valeur pour qu'elle corresponde au paramètre du pare-feu)

   • Dans Interfaces réseau, cliquez sur par défaut.

   • Sous Carte d'interface réseau, sélectionnez gVNIC.

   • Adresse IPv4 externe : eth-mainnet-rpc-ip (sélectionnez l'adresse IP statique créée précédemment)

     Cliquez sur OK.

7. Cliquez sur Sécurité.

   • Sous Identité et accès à l'API, SÉLECTIONNEZ le compte de service eth-rpc-node-sa.

   • Cliquez sur CRÉER.

Cliquez sur Vérifier ma progression pour valider l'objectif.

Créer l'infrastructure de la machine virtuelle

Tâche 2 : Configurer et installer sur la machine virtuelle

Connectez-vous maintenant à la VM via SSH et exécutez les commandes pour installer le logiciel.

Se connecter en SSH à la VM

1. Dans la console Cloud, accédez au menu de navigation () > Compute Engine > Instances de VM.
2. Sur la même ligne que eth-mainnet-rpc-node, cliquez sur SSH pour ouvrir une fenêtre SSH.
3. Si le message Autorisez la fonctionnalité SSH dans le navigateur à se connecter aux VM s'affiche, cliquez sur Autoriser.

Créer un fichier d'échange sur la VM

Pour donner de la RAM supplémentaire aux processus, vous allez créer un fichier d'échange. Cela permet d'augmenter la quantité de RAM que la VM peut utiliser si nécessaire.

1. Pour créer un fichier d'échange de 40 Go, exécutez la commande suivante :

sudo dd if=/dev/zero of=/swapfile bs=1MiB count=40KiB

Notez que l'exécution de la première commande prendra un certain temps.

2. Mettez à jour les autorisations du fichier d'échange :

sudo chmod 0600 /swapfile

3. Désignez le fichier à utiliser comme partition d'échange :

sudo mkswap /swapfile

4. Ajoutez la configuration du fichier d'échange à /etc/fstab, ce qui permet au lecteur installé d'être reconnu au redémarrage :

echo "/swapfile swap swap defaults 0 0" | sudo tee -a /etc/fstab

5. Activez le fichier d'échange :

sudo swapon -a

6. Vérifiez que l'échange a été reconnu :

free -g

Un message contenant une ligne semblable à celle-ci doit s'afficher :

Résultat :

total used free shared buff/cache available Mem: 15 0 0 0 15 15 Swap: 24 0 24

Installer le disque associé sur la VM

Lors de la configuration de la VM, vous avez créé un disque associé. La VM ne le reconnaîtra pas automatiquement. Il doit être formaté et "installé" avant de pouvoir être utilisé.

1. Affichez le disque associé. Vous devriez voir une entrée pour sdb d'une taille de 200 Go :

sudo lsblk

2. Formatez le disque associé :

sudo mkfs.ext4 -m 0 -E lazy_itable_init=0,lazy_journal_init=0,discard /dev/sdb

3. Créez le dossier et installez le disque associé :

sudo mkdir -p /mnt/disks/chaindata-disk sudo mount -o discard,defaults /dev/sdb /mnt/disks/chaindata-disk

4. Modifiez les autorisations du dossier pour que les processus puissent y lire et écrire des données :

sudo chmod a+w /mnt/disks/chaindata-disk

5. Récupérez l'ID du disque installé pour vérifier qu'il a bien été installé :

sudo blkid /dev/sdb

Un message semblable à celui affiché dans la zone de résultat ci-dessous doit s'afficher :

Résultat :

/dev/sdb: UUID="7fa9c421-0054-4555-b0ca-b470a97a3d84" TYPE="ext4"

6. Récupérez l'ID du disque installé et ajoutez-le au fichier /etc/fstab. Ce fichier permet de s'assurer que le disque reste installé même si la VM redémarre.

export DISK_UUID=$(findmnt -n -o UUID /dev/sdb) echo "UUID=$DISK_UUID /mnt/disks/chaindata-disk ext4 discard,defaults,nofail 0 2" | sudo tee -a /etc/fstab

7. Exécutez la commande df pour vérifier que le disque a été installé et formaté, et que la taille appropriée a été allouée :

df -h

Un message contenant une ligne semblable à celle-ci doit s'afficher, indiquant le nouveau volume installé et sa taille :

Résultat :

/dev/sdb 196G 28K 196G 1% /mnt/disks/chaindata-disk

Si vous devez redimensionner le disque ultérieurement, suivez ces instructions.

Cliquez sur Vérifier ma progression pour valider l'objectif.

Créer un fichier d'échange sur la VM et installer le disque associé sur la VM

Créer un utilisateur sur la VM

Créez un utilisateur pour exécuter les processus.

1. Pour créer un utilisateur nommé "ethereum", exécutez les commandes suivantes :

sudo useradd -m ethereum sudo usermod -aG sudo ethereum sudo usermod -aG google-sudoers ethereum

2. Passez à l'utilisateur "ethereum" :

sudo su ethereum

3. Démarrez la ligne de commande bash :

bash

4. Accédez au répertoire d'accueil de l'utilisateur "ethereum" :

cd ~

Installer le logiciel Ethereum

1. Mettez à jour le système d'exploitation :

sudo apt update -y sudo apt-get update -y

2. Installez le logiciel courant :

sudo apt install -y dstat jq software-properties-common

3. Installez l'agent Ops de Google Cloud :

curl -sSO https://dl.google.com/cloudagents/add-google-cloud-ops-agent-repo.sh sudo bash add-google-cloud-ops-agent-repo.sh --also-install

4. Supprimez le fichier de script qui a été téléchargé :

rm add-google-cloud-ops-agent-repo.sh

5. Créez des dossiers pour les journaux, et les données de chaîne pour les clients Geth et Lighthouse :

mkdir /mnt/disks/chaindata-disk/ethereum/ mkdir /mnt/disks/chaindata-disk/ethereum/geth mkdir /mnt/disks/chaindata-disk/ethereum/geth/chaindata mkdir /mnt/disks/chaindata-disk/ethereum/geth/logs mkdir /mnt/disks/chaindata-disk/ethereum/lighthouse mkdir /mnt/disks/chaindata-disk/ethereum/lighthouse/chaindata mkdir /mnt/disks/chaindata-disk/ethereum/lighthouse/logs

6. Installez Geth à partir du gestionnaire de paquets :

sudo add-apt-repository -y ppa:ethereum/ethereum sudo apt-get -y install ethereum

7. Vérifiez que Geth est disponible et qu'il s'agit de la dernière version :

geth version

Un message contenant une ligne semblable à celle-ci doit s'afficher :

Résultat :

Geth Version: 1.14.11-stable Git Commit: ea9e62ca3db5c33aa7438ebf39c189afd53c6bf8 Architecture: amd64 Go Version: go1.23.1 Operating System: linux GOPATH= GOROOT=

8. Téléchargez le client Lighthouse. Ce script télécharge la dernière version depuis GitHub.

# Fetch the latest release information from GitHub API RELEASE_URL="https://api.github.com/repos/sigp/lighthouse/releases/latest" LATEST_VERSION=$(curl -s $RELEASE_URL | jq -r '.tag_name') # Download the latest release using curl DOWNLOAD_URL=$(curl -s $RELEASE_URL | jq -r '.assets[] | select(.name | endswith("x86_64-unknown-linux-gnu.tar.gz")) | .browser_download_url') curl -L "$DOWNLOAD_URL" -o "lighthouse-${LATEST_VERSION}-x86_64-unknown-linux-gnu.tar.gz"

9. Extrayez le fichier tar de Lighthouse et supprimez-le :

# Extract the tar file tar -xvf "lighthouse-${LATEST_VERSION}-x86_64-unknown-linux-gnu.tar.gz" # Remove the tar file rm "lighthouse-${LATEST_VERSION}-x86_64-unknown-linux-gnu.tar.gz"

10. Déplacez le binaire Lighthouse vers le dossier /usr/bin et mettez à jour les autorisations :

sudo mv lighthouse /usr/bin

11. Vérifiez que Lighthouse est disponible et qu'il s'agit de la dernière version :

lighthouse --version

Un message contenant une ligne semblable à celle-ci doit s'afficher (notez que le numéro de version peut être différent) :

Résultat :

Lighthouse v5.3.0-d6ba8c3 BLS library: blst-portable BLS hardware acceleration: true SHA256 hardware acceleration: false Allocator: jemalloc Profile: maxperf Specs: mainnet (true), minimal (false), gnosis (true)

12. Créez le secret JWT partagé. Ce secret JWT est utilisé comme mécanisme de sécurité qui limite les personnes autorisées à appeler le point de terminaison RPC du client d'exécution.

cd ~ mkdir ~/.secret openssl rand -hex 32 > ~/.secret/jwtsecret chmod 440 ~/.secret/jwtsecret

Cliquez sur Vérifier ma progression pour valider l'objectif.

Créer un utilisateur sur la VM et installer le logiciel Ethereum

Tâche 3 : Démarrer les clients d'exécution et de consensus Ethereum

Ethereum dispose de deux clients : Geth (la couche d'exécution) et Lighthouse (la couche de consensus). Ils s'exécutent en parallèle et fonctionnent ensemble. Geth établira ensuite un point de terminaison authrpc et un port que Lighthouse appellera. Ce point de terminaison est protégé par un jeton de sécurité commun enregistré localement. Lighthouse se connecte à Geth à l'aide du point de terminaison d'exécution et du jeton de sécurité.

Pour savoir comment Geth se connecte au client de consensus, consultez la documentation sur la connexion aux clients de consensus. Pour en savoir plus sur la façon dont Lighthouse se connecte au client d'exécution, consultez la documentation "Merge Migration - Lighthouse Book".

Démarrer Geth

La commande suivante démarre le client d'exécution Geth.

1. Commencez par vous authentifier dans gcloud. Dans la session SSH, exécutez la commande suivante :

gcloud auth login

Appuyez sur ENTRÉE lorsque l'invite "Voulez-vous continuer (Oui/Non) ?" s'affiche.

2. Ouvrez le lien affiché dans un nouvel onglet.

3. Cliquez sur votre nom d'utilisateur actif (), puis sur "Autoriser".

4. Lorsque l'invite Saisissez le code de validation suivant dans la gcloud CLI sur la machine depuis laquelle vous souhaitez vous connecter s'affiche, cliquez sur le bouton "Copier", puis revenez à la session SSH et collez le code dans l'invite Enter authorization code : (Saisissez le code d'autorisation).

5. Définissez la variable d'environnement de l'adresse IP externe :

export CHAIN=eth export NETWORK=mainnet export EXT_IP_ADDRESS_NAME=$CHAIN-$NETWORK-rpc-ip export EXT_IP_ADDRESS=$(gcloud compute addresses list --filter=$EXT_IP_ADDRESS_NAME --format="value(address_range())")

6. Exécutez la commande suivante pour démarrer Geth en tant que processus en arrière-plan. Dans cet atelier, vous allez utiliser le mode de synchronisation "snap", qui est un nœud léger. Pour effectuer la synchronisation en tant que nœud complet, utilisez "full" comme mode de synchronisation. Vous pouvez exécuter cette commande directement sur la ligne de commande ou l'enregistrer d'abord dans un fichier .sh avant de la lancer. Vous pouvez également le configurer pour qu'il s'exécute en tant que service avec systemd.

nohup geth --datadir "/mnt/disks/chaindata-disk/ethereum/geth/chaindata" \ --http.corsdomain "*" \ --http \ --http.addr 0.0.0.0 \ --http.port 8545 \ --http.corsdomain "*" \ --http.api admin,debug,web3,eth,txpool,net \ --http.vhosts "*" \ --gcmode full \ --cache 2048 \ --mainnet \ --metrics \ --metrics.addr 127.0.0.1 \ --syncmode snap \ --authrpc.vhosts="localhost" \ --authrpc.port 8551 \ --authrpc.jwtsecret=/home/ethereum/.secret/jwtsecret \ --txpool.accountslots 32 \ --txpool.globalslots 8192 \ --txpool.accountqueue 128 \ --txpool.globalqueue 2048 \ --nat extip:$EXT_IP_ADDRESS \ &> "/mnt/disks/chaindata-disk/ethereum/geth/logs/geth.log" &

Cliquez sur Vérifier ma progression pour valider l'objectif.

Démarrer Geth en tant que processus en arrière-plan et utiliser le mode de synchronisation "snap"

7. Pour afficher l'identifiant de processus, exécutez la commande suivante :

ps -A | grep geth

8. Consultez les journaux pour vérifier que le processus a démarré correctement :

tail -f /mnt/disks/chaindata-disk/ethereum/geth/logs/geth.log

Un message semblable à celui affiché dans la zone de résultat ci-dessous doit s'afficher : Le client Geth ne poursuivra pas son exécution tant qu'il ne sera pas associé à un client de consensus.

Résultat :

Looking for peers peercount=1 tried=27 static=0 Post-merge network, but no beacon client seen. Please launch one to follow the chain!

9. Appuyez sur Ctrl+C pour quitter la surveillance des journaux.

Démarrer Lighthouse

Vous allez maintenant démarrer le client de consensus Lighthouse.

1. Exécutez la commande suivante pour lancer Lighthouse en tant que processus en arrière-plan. Vous pouvez exécuter cette commande directement sur la ligne de commande ou l'enregistrer d'abord dans un fichier .sh avant de la lancer. Vous pouvez également le configurer pour qu'il s'exécute en tant que service avec systemd.

nohup lighthouse bn \ --network mainnet \ --http \ --metrics \ --datadir /mnt/disks/chaindata-disk/ethereum/lighthouse/chaindata \ --execution-jwt /home/ethereum/.secret/jwtsecret \ --execution-endpoint http://localhost:8551 \ --checkpoint-sync-url https://sync-mainnet.beaconcha.in \ &> "/mnt/disks/chaindata-disk/ethereum/lighthouse/logs/lighthouse.log" &

2. Pour afficher l'identifiant de processus, exécutez la commande suivante :

ps -A | grep lighthouse

3. Consultez le fichier journal pour vérifier si le processus a démarré correctement. L'affichage peut prendre quelques minutes :

tail -f /mnt/disks/chaindata-disk/ethereum/lighthouse/logs/lighthouse.log

Un message semblable au suivant s'affiche :

Résultat :

INFO Syncing INFO Synced INFO New block received

4. Appuyez sur Ctrl+C pour quitter la surveillance des journaux.

5. Consultez à nouveau le journal Geth pour vous assurer que les journaux sont générés correctement.

tail -f /mnt/disks/chaindata-disk/ethereum/geth/logs/geth.log

Un message semblable à celui affiché dans la zone de résultat ci-dessous doit s'afficher :

Résultat :

Syncing beacon headers

Vérifier que le nœud a été synchronisé avec la blockchain

Déterminez si le nœud est toujours en cours de synchronisation. Celle-ci peut prendre un certain temps. Notez qu'il n'est pas nécessaire d'attendre la synchronisation du nœud pour terminer l'atelier. Le résultat devrait afficher l'état de synchronisation au format JSON plutôt que false. Il existe deux façons de connaître l'état de la synchronisation : avec Geth ou par un appel RPC.

1. Exécutez la commande Geth ci-dessous pour vérifier si le nœud est toujours en cours de synchronisation. Le résultat "false" signifie que le nœud est entièrement synchronisé avec le réseau, mais il est probable que la synchronisation se poursuive pendant cet atelier.

geth attach /mnt/disks/chaindata-disk/ethereum/geth/chaindata/geth.ipc

2. Dans la console Geth, exécutez la commande suivante :

eth.syncing

Le résultat qui s'affiche doit ressembler à ceci :

Résultat :

#If not synced: { currentBlock: 5186007, healedBytecodeBytes: 0, healedBytecodes: 0, healedTrienodeBytes: 0, healedTrienodes: 0, healingBytecode: 0, healingTrienodes: 0, highestBlock: 16193909, startingBlock: 0, syncedAccountBytes: 2338698797, syncedAccounts: 9417189, syncedBytecodeBytes: 302598044, syncedBytecodes: 58012, syncedStorage: 42832820, syncedStorageBytes: 9263550660 } #If synced: false

3. Saisissez exit pour quitter la console Geth.
4. Exécutez la commande curl suivante pour vérifier si le nœud est toujours en cours de synchronisation. L'outil de ligne de commande "jq" mettra en forme le résultat JSON de la commande curl. Le résultat "false" signifie qu'il est synchronisé avec le réseau.

curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","id":67}' http://localhost:8545 | jq

Résultat :

#If not synced: { "jsonrpc": "2.0", "id": 67, "result": { "currentBlock": "0x4d70e9", "healedBytecodeBytes": "0x0", "healedBytecodes": "0x0", "healedTrienodeBytes": "0x0", "healedTrienodes": "0x0", "healingBytecode": "0x0", "healingTrienodes": "0x0", "highestBlock": "0xf71975", "startingBlock": "0x0", "syncedAccountBytes": "0x8b65b62d", "syncedAccounts": "0x8fb1e5", "syncedBytecodeBytes": "0x1209479c", "syncedBytecodes": "0xe29c", "syncedStorage": "0x28d93b4", "syncedStorageBytes": "0x2282690c4" } } #If synced: {"jsonrpc":"2.0","id":67,"result":false}

5. Exécutez la commande curl suivante pour vérifier si le nœud est accessible à l'aide de l'adresse IP externe :

curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","id":67}' http://$EXT_IP_ADDRESS:8545 | jq

Résultat :

#If not synced: { "jsonrpc": "2.0", "id": 67, "result": { "currentBlock": "0x4d70e9", "healedBytecodeBytes": "0x0", "healedBytecodes": "0x0", "healedTrienodeBytes": "0x0", "healedTrienodes": "0x0", "healingBytecode": "0x0", "healingTrienodes": "0x0", "highestBlock": "0xf71975", "startingBlock": "0x0", "syncedAccountBytes": "0x8b65b62d", "syncedAccounts": "0x8fb1e5", "syncedBytecodeBytes": "0x1209479c", "syncedBytecodes": "0xe29c", "syncedStorage": "0x28d93b4", "syncedStorageBytes": "0x2282690c4" } } #If synced: {"jsonrpc":"2.0","id":67,"result":false}

Tâche 4 : Configurer Cloud Operations

Google Cloud propose plusieurs services d'exploitation pour gérer votre nœud Ethereum. Cette section explique comment configurer Cloud Logging, Prometheus géré, Cloud Monitoring et les alertes Cloud.

Configurer Cloud Logging

Par défaut, Geth et Lighthouse enregistrent les données dans leur fichier journal déclaré. Vous devez importer les données de journal dans Cloud Logging. Cloud Logging propose de puissantes fonctionnalités de recherche, et vous pouvez créer des alertes pour des messages de journal spécifiques.

1. Mettez à jour les autorisations du fichier de configuration Ops Cloud pour pouvoir le modifier :

sudo chmod 666 /etc/google-cloud-ops-agent/config.yaml

2. Configurez l'agent Ops Cloud pour envoyer des données de journaux à Cloud Logging. Modifiez le fichier "/etc/google-cloud-ops-agent/config.yaml" pour inclure cette configuration de l'agent Ops. Ce fichier de configuration définit les fichiers journaux Geth et Lighthouse à importer dans Cloud Logging :

sudo cat << EOF >> /etc/google-cloud-ops-agent/config.yaml logging: receivers: syslog: type: files include_paths: - /var/log/messages - /var/log/syslog ethGethLog: type: files include_paths: ["/mnt/disks/chaindata-disk/ethereum/geth/logs/geth.log"] record_log_file_path: true ethLighthouseLog: type: files include_paths: ["/mnt/disks/chaindata-disk/ethereum/lighthouse/logs/lighthouse.log"] record_log_file_path: true journalLog: type: systemd_journald service: pipelines: logging_pipeline: receivers: - syslog - journalLog - ethGethLog - ethLighthouseLog EOF

3. Une fois l'enregistrement effectué, exécutez ces commandes pour redémarrer l'agent et prendre en compte les modifications :

sudo systemctl stop google-cloud-ops-agent sudo systemctl start google-cloud-ops-agent sudo systemctl status google-cloud-ops-agent

4. Appuyez sur Ctrl+C pour quitter l'écran d'état.
5. Si l'état indique une erreur, utilisez cette commande pour afficher plus de détails :

sudo journalctl -xe | grep "google_cloud_ops_agent_engine"

6. Consultez Cloud Logging pour confirmer que les messages de journal s'affichent dans la console. Dans la console Cloud, accédez au menu de navigation (), cliquez sur Afficher tous les produits, puis, sous Observabilité, cliquez sur Journalisation. Dans le menu de gauche, cliquez sur Explorateur de journaux. Des messages semblables aux suivants devraient s'afficher :

Configurer Prometheus géré

Comme nous avons démarré les clients geth et lighthouse avec le flag --metrics, les deux clients généreront des métriques sur le port HTTP. Ces métriques peuvent être stockées dans une base de données de séries temporelles comme Prometheus et être utilisées pour fournir des données à des tableaux de bord Grafana pertinents. En temps normal, vous devriez installer Prometheus sur la VM, mais une simple configuration de l'agent Ops Cloud permet de capturer les métriques et de les stocker dans le service Prometheus géré de Google Cloud.

1. Dans la ligne de commande de la VM, vérifiez que le point de terminaison des métriques Geth est actif.

curl http://localhost:6060/debug/metrics/prometheus

Résultat :

...... # TYPE vflux_server_clientEvent_deactivated gauge vflux_server_clientEvent_deactivated 0 # TYPE vflux_server_clientEvent_disconnected gauge vflux_server_clientEvent_disconnected 0 # TYPE vflux_server_inactive_count gauge vflux_server_inactive_count 0

2. Sur la ligne de commande de la VM, vérifiez que le point de terminaison des métriques Lighthouse est actif.

curl http://localhost:5054/metrics

Résultat :

...... gossipsub_heartbeat_duration_bucket{le="300.0"} 5679573 gossipsub_heartbeat_duration_bucket{le="350.0"} 5679573 gossipsub_heartbeat_duration_bucket{le="400.0"} 5679573 gossipsub_heartbeat_duration_bucket{le="450.0"} 5679573 gossipsub_heartbeat_duration_bucket{le="+Inf"} 5679573 ......

3. Configurez l'agent Ops Cloud pour envoyer les données de métriques à Prometheus géré. Modifiez le fichier "/etc/google-cloud-ops-agent/config.yaml" pour inclure cette configuration de l'agent Ops. Ce fichier de configuration définit le point de terminaison des métriques Geth et Lighthouse à importer dans Prometheus géré :

sudo cat << EOF >> /etc/google-cloud-ops-agent/config.yaml metrics: receivers: prometheus: type: prometheus config: scrape_configs: - job_name: 'geth_exporter' scrape_interval: 10s metrics_path: /debug/metrics/prometheus static_configs: - targets: ['localhost:6060'] - job_name: 'lighthouse_exporter' scrape_interval: 10s metrics_path: /metrics static_configs: - targets: ['localhost:5054'] service: pipelines: prometheus_pipeline: receivers: - prometheus EOF

4. Une fois l'enregistrement effectué, exécutez ces commandes pour redémarrer l'agent et prendre en compte les modifications :

sudo systemctl stop google-cloud-ops-agent sudo systemctl start google-cloud-ops-agent sudo systemctl status google-cloud-ops-agent

5. Appuyez sur Ctrl+C pour quitter l'écran d'état.
6. Si l'état indique une erreur, utilisez cette commande pour afficher plus de détails :

sudo journalctl -xe | grep "google_cloud_ops_agent_engine"

7. Consultez Cloud Logging pour vérifier que les métriques s'affichent dans la console. Dans la console Cloud, accédez au menu de navigation (), cliquez sur Afficher tous les produits, puis sous Observabilité, cliquez sur Surveillance. Dans le menu de gauche, cliquez sur Explorateur de métriques.

8. Sélectionnez l'option <> PromQL. Dans le champ de requête, saisissez une métrique Lighthouse gossipsub_heartbeat_duration_bucket. Cliquez sur EXÉCUTER LA REQUÊTE. Vous devriez obtenir des résultats semblables à ceux-ci :

Vous pouvez faire de même pour une métrique Geth (par exemple, rpc_duration_eth_blockNumber_success_count) afin de vérifier que les métriques Geth sont affichées.

Afficher Cloud Monitoring

Cloud Monitoring devrait déjà être actif pour votre machine virtuelle.

1. Dans la console Cloud, accédez au menu de navigation () > Compute Engine > Instances de VM.
2. Cliquez sur la VM eth-mainnet-rpc-node.
3. Cliquez sur l'onglet OBSERVABILITÉ.
4. Toutes les sections doivent afficher un graphique présentant différentes métriques de la VM.

5. Explorez les différents sous-menus et périodes pour découvrir les types de métriques capturées directement depuis la VM.

Configurer le canal de notification

Configurez un canal de notification auquel les alertes seront envoyées :

1. Dans la console Cloud, accédez au menu de navigation (), cliquez sur Afficher tous les produits, puis sous Observabilité, cliquez sur Surveillance. Dans le menu de gauche, cliquez sur Alertes.
2. Cliquez sur MODIFIER LES CANAUX DE NOTIFICATION.
3. Sous Adresse e-mail, cliquez sur AJOUTER.
4. Saisissez l'adresse e-mail et le nom à afficher de la personne qui doit recevoir les notifications.
5. Cliquez sur Enregistrer.

Configurer des alertes de métriques

Configurez des alertes basées sur les métriques des VM :

1. Dans le menu de gauche, sous la section Détecter, cliquez sur Alertes.
2. Cliquez sur CRÉER UNE RÈGLE.
3. Cliquez sur SÉLECTIONNER UNE MÉTRIQUE.
4. Cliquez sur Instance de VM > Disque > Utilisation du disque, puis sur Appliquer.
5. Ajoutez des filtres :

Propriété	Valeur (à saisir ou sélectionner)
appareil	/dev/sdb
état	utilisé

6. Cliquez sur SUIVANT.
7. Saisissez la valeur de seuil : 90 %.

8. Cliquez sur SUIVANT, puis sélectionnez les valeurs suivantes :

Propriété	Valeur (à saisir ou sélectionner)
Utiliser le canal de notification	Sélectionner
Canaux de notification	Sélectionner le canal de notification créé précédemment
Notifier en cas de fermeture d'un incident	Cocher
Délai pour la fermeture automatique de l'incident	2 jours
Documentation	Vérifier l'espace disque de la VM
Nom	VM - Alerte d'espace disque - Utilisation à 90 %

9. Cliquez sur SUIVANT.
10. Cliquez sur CRÉER UNE RÈGLE.

Configurer des tests de disponibilité

Configurez des tests de disponibilité pour le point de terminaison HTTP :

1. Dans le menu de gauche, sous la section Détecter, cliquez sur Tests de disponibilité.
2. Cliquez sur CRÉER UN TEST DE DISPONIBILITÉ.
3. Configurez le test de disponibilité avec les valeurs suivantes :

Propriété	Valeur (à saisir ou sélectionner)
Protocole	HTTP
Type de ressource	URL
Nom d'hôte	[Adresse IP externe de votre instance]
Chemin	/
Développer les autres options de ciblage
Mode de requête	GET
Port	8545
Cliquer sur "Continuer"	accepter les valeurs par défaut
Cliquer sur "Continuer"	accepter les valeurs par défaut
Choisir un canal de notification	Sélectionner le canal de notification créé précédemment
Titre	eth-mainnet-rpc-node-uptime-check

4. Cliquez sur TEST (le résultat doit être "200 OK").
5. Cliquez sur CRÉER.

Cliquez sur Vérifier ma progression pour valider l'objectif.

Configurer Cloud Operations

Félicitations !

Dans cet atelier, vous avez créé une instance Compute Engine avec un disque persistant, configuré une adresse IP statique, configuré des règles de pare-feu de réseau, programmé des sauvegardes, déployé les clients Ethereum Geth et Lighthouse, testé la configuration avec des appels RPC Ethereum, configuré Cloud Logging et Cloud Monitoring, et configuré des tests de disponibilité.

Étapes suivantes et informations supplémentaires

Consultez ces ressources pour poursuivre votre parcours Ethereum :

• Pour en savoir plus sur le client Ethereum (couche d'exécution), consultez Geth.
• Pour en savoir plus sur le client Ethereum (couche de consensus), consultez Lighthouse.
• Pour en savoir plus sur Ethereum en général, consultez Ethereum.
• Pour en savoir plus sur Google Cloud pour le Web3, consultez le site Web Google Cloud pour le Web3.
• Pour en savoir plus sur Blockchain Node Engine pour Google Cloud, consultez la page Blockchain Node Engine.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 27 juillet 2026

Dernier test de l'atelier : 27 juillet 2026

Copyright 2026 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.