GSP1116

Visão geral

Hospedar seus próprios nós de blockchain pode ser necessário por motivos de segurança, conformidade, desempenho ou privacidade. Além disso, uma rede descentralizada, resiliente e sustentável é uma base fundamental para qualquer protocolo de blockchain. Os desenvolvedores de Web3 podem usar o Blockchain Node Engine do Google Cloud, uma solução totalmente gerenciada de hospedagem de nós para o desenvolvimento de Web3. As organizações também podem configurar e gerenciar seus próprios nós no Google Cloud. Como parceiro confiável para infraestrutura de Web3, o Google Cloud oferece uma infraestrutura segura, confiável e escalonável para hospedagem de nós. Para saber mais sobre a hospedagem de nós no Google Cloud, confira o post Introducing Blockchain Node Engine: fully managed node-hosting for Web3 development (Conheça o Blockchain Node Engine: hospedagem de nós totalmente gerenciada para o desenvolvimento de Web3, em tradução livre).

Para saber mais sobre as considerações técnicas e as decisões de arquitetura necessárias ao implantar nós de blockchain autogerenciados na nuvem, acesse o post Google Cloud for Web3.

Neste laboratório, você vai criar uma máquina virtual (VM) para implantar um nó RPC do Ethereum. Um nó RPC do Ethereum consegue receber atualizações de blockchain da rede e processar solicitações de API RPC. Você vai usar um tipo de máquina e2-standard-4 que inclui um disco de inicialização de 20 GB, 4 CPUs virtuais (vCPUs) e 16 GB de RAM. Para garantir que haja espaço suficiente para os dados da blockchain, é preciso um disco SSD de 200 GB à instância. Você vai usar o Ubuntu 20.04 para implantar dois serviços: o Geth, que é a "camada de execução", e o Lighthouse, a "camada de consenso". Esses dois serviços trabalham em conjunto para compor um nó RPC do Ethereum.

Objetivos

Neste laboratório, você vai aprender a fazer o seguinte:

• Criar uma instância do Compute Engine com um disco permanente.
• Configurar um endereço IP estático e regras de firewall de rede.
• Programar backups regulares.
• Implantar o Geth, a camada de execução do Ethereum.
• Implantar o Lighthouse, a camada de consenso do Ethereum.
• Realizar chamadas RPC do Ethereum.
• Configurar o Cloud Logging.
• Configurar o Cloud Monitoring.
• Configurar as verificações de tempo de atividade.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. À direita, você encontra o painel Configuração e acesso ao laboratório com as seguintes informações:

   • O botão Abrir console do Google Cloud
   • As credenciais temporárias (nome de usuário e senha) que você vai usar no laboratório
   • Outros dados, se necessários

   O timer do laboratório fica na parte de cima da página e mostra o tempo restante.

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página "Login" em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Login.

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

   Você também encontra o nome de usuário no painel Configuração e acesso ao laboratório.

4. Clique em Avançar.

5. Copie a Senha abaixo e cole na caixa de diálogo Olá!.

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

   Você também encontra a senha no painel Configuração e acesso ao laboratório.

6. Clique em Avançar.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, talvez receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes sem custo financeiro.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Neste laboratório, você vai usar as seguintes ferramentas:

• Ubuntu 24.04
• Geth
• Lighthouse
• Curl
• Gcloud

Tarefa 1: criar infraestrutura para a máquina virtual

Crie um endereço IP estático público, uma regra de firewall, uma conta de serviço, uma programação de snapshot e uma máquina virtual com o novo endereço IP. Esta é a infraestrutura onde o Ethereum será implantado.

Criar um endereço IP estático público

Nesta seção, você vai configurar o endereço IP público usado na máquina virtual.

1. No console do Cloud, acesse o Menu de navegação () > Rede VPC > Endereços IP.
2. Clique em Reservar endereço externo no card Endereços IP para criar o endereço IP estático.
3. Para a configuração do endereço estático, use os seguintes valores:

Propriedade	Valor (digite ou selecione)
Nome	eth-mainnet-rpc-ip
Nível de serviço de rede	Premium
Versão IP	IPv4
Tipo	Regional
Região
Anexado a	Nenhum

4. Clique em RESERVAR.

Criar uma regra de firewall

Crie regras de firewall para que a VM possa se comunicar em portas designadas.

O Geth P2P se comunica via TCP e UDP na porta 30303. O Lighthouse P2P se comunica via TCP e UDP na porta 9000. O Geth RPC usa TCP 8545.

1. No console do Cloud, acesse Menu de navegação () > Rede VPC > Firewall.
2. Clique em Criar regra de firewall na barra de ações para criar as regras de firewall.
3. Para a configuração do firewall, use o seguinte:

Propriedade	Valor (digite ou selecione)
Nome	eth-rpc-node-fw
Registros	Desligado
Rede	default
Prioridade	1000
Direção do tráfego	Entrada
Ação em caso de correspondência	Permitir
Destinos	Tags de destino especificadas
Tags de destino	eth-rpc-node (pressione Enter depois de digitar o valor)
Filtro de origem	Intervalos IPv4
Intervalos IPv4 de origem	0.0.0.0/0 (pressione Enter depois de digitar o valor)
Portas e protocolos especificados:	TCP: 30303, 9000, 8545 UDP: 30303, 9000

4. Clique em CRIAR.

Crie uma conta de serviço

Crie uma conta de serviço para a execução da VM.

1. No console do Cloud, acesse Menu de navegação () > IAM e administrador > Contas de serviço.
2. Clique em Criar conta de serviço na barra de ações para criar a conta de serviço.
3. Para a configuração da conta de serviço, use o seguinte:

Propriedade	Valor (digite ou selecione)
Nome da conta de serviço	eth-rpc-node-sa
ID da conta de serviço	eth-rpc-node-sa

4. Clique em CRIAR E CONTINUAR.
5. Adicione os seguintes papéis:

Propriedade	Valor (digite ou selecione)
Papéis	Login do SO do Compute, Service Controller, Logs Writer, Monitoring Metric Writer, Cloud Trace Agent, Compute Network User

6. Clique em CONTINUAR.
7. Clique em CONCLUÍDO.

Criar uma programação de snapshot

Nesta seção, você vai configurar a programação de snapshot usada para o disco anexado da máquina virtual, que contém os dados da blockchain. Isso fará o backup dos dados da cadeia.

1. No console do Cloud, acesse o Menu de navegação () > Compute Engine > Snapshots.
2. Clique em Criar programação de snapshot para criar a programação.
3. Para a programação de snapshot, use o seguinte:

Propriedade	Valor (digite ou selecione)
Nome	eth-mainnet-rpc-node-disk-snapshot
Região
Regional
Opções de programação	Frequência da programação: Diária, Horário de início (UTC): 18:00 - 19:00, Excluir snapshots automaticamente após: 7 dias
Regra de exclusão	Manter snapshots

4. Clique em CRIAR.

Criar uma máquina virtual

Nesta seção, você vai configurar a máquina virtual usada para a implantação do Ethereum.

1. No console do Cloud, acesse Menu de navegação () > Compute Engine > Instâncias de VM.

2. Clique em Criar instância para criar a VM.

3. Na Configuração da máquina

   Insira o valor do seguinte campo:

   Propriedade	Valor (digite ou selecione)
   Nome	eth-mainnet-rpc-node
   Região
   Zona
   Série	E2
   Tipo de máquina	e2-standard-4

4. Clique em SO e armazenamento.

   Clique em Alterar e selecione os seguintes valores:

   Propriedade	Valor(digite ou selecione)
   Sistema operacional	Ubuntu
   Versão	Ubuntu 24.04 LTS (x86/64)
   Tipo de disco de inicialização	Disco permanente SSD
   Tamanho	50 GB

   Clique em Selecionar.

   Em Discos adicionais, clique em Adicionar novo disco.

   Propriedade	Valor(digite ou selecione)
   Nome	eth-mainnet-rpc-node-disk
   Tipo de origem do disco	Disco em branco
   Tipo de disco	Disco permanente SSD
   Tamanho	200 GB (ou 2.000 GB para instalações maiores)

   Clique em Salvar.

5. Clique em Proteção de dados.

   Em "Programações de snapshot", selecione eth-mainnet-rpc-node-disk-snapshot

6. Clique em Rede.

   Propriedade	Valor (digite ou selecione)
   Tags de rede	eth-rpc-node (pressione Enter depois de digitar o valor, que corresponde à configuração do firewall)

   • Em Interfaces de rede, clique em padrão:

   • Em Placa de rede, selecione gVNIC

   • Endereço IPv4 externo: eth-mainnet-rpc-ip (selecione o endereço IP estático que foi criado)

     Clique em CONCLUÍDO.

7. Clique em Segurança.

   • Em Identidade e acesso à API, SELECIONE a conta de serviço eth-rpc-node-sa.

   • Clique em CRIAR.

Clique em Verificar meu progresso para conferir o objetivo.

Criar infraestrutura para a máquina virtual

Tarefa 2: configurar e instalar na máquina virtual

Agora use o SSH para acessar a VM e execute os comandos para instalar o software.

Acessar a VM via SSH

1. No console do Cloud, acesse Menu de navegação () > Compute Engine > Instâncias de VM.
2. Na mesma linha de eth-mainnet-rpc-node, clique em SSH para abrir uma janela SSH.
3. Se aparecer a mensagem Permitir que o SSH no navegador se conecte a VMs, clique em Autorizar.

Criar um arquivo de troca na VM

Para fornecer mais RAM aos processos, você vai criar um arquivo de troca. Isso aumenta a quantidade de RAM que a VM pode usar, se necessário.

1. Para criar um arquivo de troca de 40 GB, execute o seguinte comando:

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

O primeiro comando vai levar um tempo para ser executado.

2. Atualize as permissões no arquivo de troca:

sudo chmod 0600 /swapfile

3. Defina o arquivo que será usado como uma partição de troca:

sudo mkswap /swapfile

4. Adicione a configuração do arquivo de troca ao arquivo /etc/fstab, o que permite que a unidade montada seja reconhecida após a reinicialização:

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

5. Ative o arquivo de troca:

sudo swapon -a

6. Confirme se a troca foi reconhecida:

free -g

Você verá uma mensagem com uma linha semelhante a esta:

Saída:

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

Montar o disco anexado na VM

Durante a configuração da VM, você criou um disco anexado. A VM não vai reconhecer isso automaticamente. Ela precisa ser formatada e "montada" antes de ser usada.

1. Veja o disco anexado. Você verá uma entrada para sdb com o tamanho de 200 GB:

sudo lsblk

2. Formate o disco anexado:

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

3. Crie a pasta e monte o disco anexado:

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

4. Atualize as permissões da pasta para que os processos possam ler/gravar nela:

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

5. Recupere o ID do disco da unidade montada para confirmar que ela foi montada:

sudo blkid /dev/sdb

Será exibida uma mensagem semelhante à mostrada na caixa de saída abaixo:

Saída:

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

6. Recupere o ID do disco ativado e adicione-o ao arquivo /etc/fstab. Esse arquivo garante que o drive ainda será montado se a VM for reiniciada.

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. Execute o comando df para confirmar que o disco foi montado e formatado e que o tamanho correto foi alocado:

df -h

Você verá uma mensagem com uma linha semelhante a esta, indicando o novo volume montado e o tamanho:

Saída:

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

Se você precisar redimensionar o disco mais tarde, siga estas instruções.

Clique em Verificar meu progresso para conferir o objetivo.

Criar um arquivo de troca na VM e montar o disco anexado na VM

Criar um usuário na VM

Crie um usuário para a execução dos processos.

1. Para criar um usuário chamado ethereum, execute os seguintes comandos:

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

2. Mude para o usuário ethereum:

sudo su ethereum

3. Inicie a linha de comando bash:

bash

4. Mude para a pasta inicial do usuário ethereum:

cd ~

Instalar o software Ethereum

1. Atualize o sistema operacional:

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

2. Instale softwares comuns:

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

3. Instale o agente de operações do 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. Remova o arquivo de script que foi baixado:

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

5. Crie pastas para os registros e dados de cadeia para os clientes Geth e 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. Instale o Geth pelo gerenciador de pacotes:

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

7. Confirme se o Geth está disponível e se é a versão mais recente:

geth version

Você verá uma mensagem com uma linha semelhante a esta:

Saída:

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

8. Baixe o cliente do Lighthouse. Esse script vai baixar a versão mais recente do 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. Extraia o arquivo tar do Lighthouse e remova o seguinte:

# 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. Mova o binário do Lighthouse para a pasta /usr/bin e atualize as permissões:

sudo mv lighthouse /usr/bin

11. Confirme se o Lighthouse está disponível e se é a versão mais recente:

lighthouse --version

Você vai receber uma mensagem com uma linha semelhante a esta, mas o número da versão pode ser diferente:

Saída:

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. Crie o secret JWT compartilhado. Esse secret JWT é usado como um mecanismo de segurança que restringe quem pode chamar o endpoint RPC do cliente de execução.

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

Clique em Verificar meu progresso para conferir o objetivo.

Criar um usuário na VM e instalar o software Ethereum

Tarefa 3: iniciar os clientes de execução e consenso do Ethereum

O Ethereum tem dois clientes: Geth, a camada de execução, e Lighthouse, a camada de consenso. Eles são executados em paralelo e funcionam juntos. Em seguida, o Geth vai estabelecer um endpoint e uma porta authrpc que o Lighthouse chamará. Esse endpoint é protegido por um token de segurança comum salvo localmente. O Lighthouse se conecta ao Geth usando o endpoint de execução e o token de segurança.

Para saber como o Geth se conecta ao cliente de consenso, leia a documento Connecting to Consensus Clients (Como se conectar a clientes de consenso, em tradução livre). Para saber mais sobre como o Lighthouse se conecta ao cliente de execução, acesse o documento Merge Migration - Lighthouse Book (Migração do Merge - Livro do Lighthouse, em tradução livre).

Iniciar o Geth

O comando a seguir inicia o cliente de execução Geth.

1. Primeiro, autentique na gcloud. Na sessão SSH, execute o seguinte:

gcloud auth login

Pressione ENTER assim que aparecer a mensagem "Quer continuar (S/N)?"

2. Vá até o link que aparece em uma nova guia.

3. Clique no nome de usuário ativo () e, em seguida, em "Permitir".

4. Assim que aparecer a mensagem Insira o código de verificação a seguir na CLI gcloud da máquina em que quer fazer login, clique no botão "Copiar", volte à sessão SSH e cole o código onde aparece a mensagem Inserir código de autorização:.

5. Defina a variável de ambiente do endereço IP externo:

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. Execute o comando a seguir para iniciar o Geth como um processo em segundo plano. Neste laboratório, você vai usar o modo de sincronização "snap", que é um nó leve. Para sincronizar como um nó completo, use "full" como o modo de sincronização. É possível executar esse comando diretamente na linha de comando ou salvá-lo em um arquivo .sh antes da execução. Você também pode configurá-lo para ser executado como um serviço com o 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" &

Clique em Verificar meu progresso para conferir o objetivo.

Iniciar o Geth como um processo em segundo plano e usar o modo de sincronização de snap

7. Para ver o ID do processo, execute este comando:

ps -A | grep geth

8. Verifique os registros para saber se o processo foi iniciado corretamente:

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

Será exibida uma mensagem semelhante à mostrada na caixa de saída abaixo: O cliente Geth não vai continuar até que seja pareado com um cliente de consenso.

Saída:

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. Digite Ctrl+C para sair do monitoramento de registros.

Iniciar o Lighthouse

Agora você vai iniciar o cliente de consenso do Lighthouse.

1. Execute o comando a seguir para iniciar o Lighthouse como um processo em segundo plano. É possível executar esse comando diretamente na linha de comando ou salvá-lo em um arquivo .sh antes da execução. Você também pode configurá-lo para ser executado como um serviço com o 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. Para ver o ID do processo, execute o seguinte comando:

ps -A | grep lighthouse

3. Verifique o arquivo de registro para ver se o processo foi iniciado corretamente. Isso pode levar alguns minutos para aparecer:

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

Você verá uma mensagem semelhante a esta:

Saída:

INFO Syncing INFO Synced INFO New block received

4. Digite Ctrl+C para sair do monitoramento de registros.

5. Verifique o registro do Geth novamente para confirmar se os registros estão sendo gerados corretamente.

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

Será exibida uma mensagem semelhante à mostrada na caixa de saída abaixo:

Saída:

Syncing beacon headers

Verifique se o nó foi sincronizado com o blockchain

Determine se o nó ainda está sincronizando. A sincronização do nó vai levar algum tempo. (Não é preciso esperar o nó sincronizar para concluir o laboratório. É esperado que a saída mostre o JSON do status de sincronização em vez de false. Existem duas maneiras de verificar o status de sincronização: pelo Geth ou por uma chamada RPC.

1. Execute o comando Geth a seguir para verificar se o nó ainda está sincronizando. Uma saída "false" significa que ele está totalmente sincronizado com a rede, mas é provável que a sincronização ainda esteja em andamento durante este laboratório.

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

2. No console do Geth, execute o comando abaixo:

eth.syncing

O resultado será semelhante ao seguinte:

Saída:

#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. Digite exit para sair do console do Geth.
4. Execute o comando curl a seguir para verificar se o nó ainda está sincronizando. A ferramenta de linha de comando "jq" vai formatar a saída JSON do comando curl. A saída "false" significa que ele está sincronizado com a rede.

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

Saída:

#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. Execute o comando curl a seguir para verificar se o nó está acessível pelo endereço IP externo:

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

Saída:

#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}

Tarefa 4: configurar as operações do Cloud

O Google Cloud tem vários serviços de operação para gerenciar seu nó do Ethereum. Nesta seção, vamos conferir como configurar o Cloud Logging, o Managed Prometheus, o Cloud Monitoring e o Cloud Alerts.

Configurar o Cloud Logging

Por padrão, o Geth e o Lighthouse vão registrar no arquivo de registro declarado. Você quer transferir os dados de registro para o Cloud Logging. O Cloud Logging tem recursos de pesquisa avançados, e é possível criar alertas para mensagens de registro específicas.

1. Atualize as permissões do arquivo de configuração do Cloud Ops para que você possa atualizá-lo:

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

2. Configurar o agente de operações do Cloud para enviar dados de registro ao Cloud Logging. Atualize o arquivo "/etc/google-cloud-ops-agent/config.yaml" para incluir esta configuração do Agente de operações. Esse arquivo de configuração define os arquivos de registro do Geth e do Lighthouse para importação no 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. Depois de salvar, execute estes comandos para reiniciar o agente e aplicar as mudanças:

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

4. Pressione Ctrl+C para sair da tela de status.
5. Se houver um erro no status, use este comando para ver mais detalhes:

sudo journalctl -xe | grep "google_cloud_ops_agent_engine"

6. Verifique o Cloud Logging para confirmar que as mensagens de registro estão aparecendo no console. No console do Cloud, acesse o Menu de navegação (), clique em Ver todos os produtos e, em Observabilidade, clique em Logging. No menu à esquerda, clique em Análise de registros. Você verá mensagens semelhantes a estas:

Configurar o Prometheus gerenciado

Como iniciamos os clientes geth e lighthouse com a flag --metrics, ambos vão gerar métricas na porta HTTP. É possível armazenar essas métricas em um banco de dados de séries temporais, como o Prometheus, e usá-las para alimentar painéis informativos do Grafana. Normalmente, você precisaria instalar o Prometheus na VM, mas uma pequena configuração no agente de operações do Cloud permite capturar as métricas e armazená-las no serviço Managed Prometheus no Google Cloud.

1. Na linha de comando da VM, confirme se o endpoint de métricas do Geth está ativo.

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

Saída:

...... # 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. Na linha de comando da VM, confirme se o endpoint de métricas do Lighthouse está ativo.

curl http://localhost:5054/metrics

Saída:

...... 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. Configure o Agente de operações do Cloud para enviar os dados de métricas ao Managed Prometheus. Atualize o arquivo "/etc/google-cloud-ops-agent/config.yaml" para incluir esta configuração do Agente de operações. Este arquivo de configuração define os endpoints de métricas do Geth e do Lighthouse para importação no Managed Prometheus:

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. Depois de salvar, execute estes comandos para reiniciar o agente e aplicar as mudanças:

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

5. Pressione Ctrl+C para sair da tela de status.
6. Se houver um erro no status, use este comando para ver mais detalhes:

sudo journalctl -xe | grep "google_cloud_ops_agent_engine"

7. Confira o Cloud Logging para confirmar se as métricas estão aparecendo no console. No console do Cloud, acesse o Menu de navegação (), clique em Ver todos os produtos e, em Observabilidade, clique em Monitoring. No menu à esquerda, clique em Metrics Explorer.

8. Selecione a opção <> PromQL. Na caixa de consulta, insira uma métrica do Lighthouse gossipsub_heartbeat_duration_bucket. Clique em EXECUTAR CONSULTA. Os resultados serão semelhantes a este:

Você pode fazer o mesmo com uma métrica do Geth (por exemplo, rpc_duration_eth_blockNumber_success_count) para confirmar que as métricas dele estão sendo exibidas.

Ver o Cloud Monitoring

O Cloud Monitoring já deve estar ativo na sua máquina virtual.

1. No console do Cloud, acesse Menu de navegação () > Compute Engine > Instâncias de VM.
2. Clique na VM eth-mainnet-rpc-node.
3. Clique na guia OBSERVABILIDADE.
4. Todas as seções precisam exibir um gráfico com diferentes métricas da VM.

5. Acesse os diferentes submenus e períodos para conferir os tipos de métricas capturadas diretamente da VM.

Configurar o canal de notificação

Configure um canal de notificação para o envio dos alertas:

1. No console do Cloud, acesse o Menu de navegação (), clique em Ver todos os produtos e, em Observabilidade, clique em Monitoring. No menu à esquerda, clique em Alertas.
2. Clique em EDITAR CANAIS DE NOTIFICAÇÃO.
3. Em E-mail, clique em ADICIONAR.
4. Digite o Endereço de e-mail e o Nome de exibição da pessoa que vai receber as notificações.
5. Clique em Salvar.

Configurar alertas de métricas

Configure alertas com base nas métricas da VM:

1. No menu à esquerda, na seção Detectar, clique em Alertas.
2. Clique em CRIAR POLÍTICA.
3. Clique em SELECIONAR UMA MÉTRICA.
4. Clique em Instância de VM > Disco > Uso do disco e clique em Aplicar.
5. Adicione filtros:

Propriedade	Valor (digite ou selecione)
dispositivo	/dev/sdb
estado	usado

6. Clique em PRÓXIMA.
7. Insira o valor do limite: 90%

8. Clique em PRÓXIMO e selecione os seguintes valores:

Propriedade	Valor (digite ou selecione)
Usar canal de notificação	selecionar
Canais de notificação	Selecione o canal de notificação criado
Notificar sobre o fechamento de incidentes	verificar
Duração do fechamento automático de incidentes	2 dias
Documentação	Verificar o espaço em disco da VM
Nome	VM – Alerta de espaço em disco – 90% de uso

9. Clique em PRÓXIMA.
10. Clique em CRIAR POLÍTICA.

Configurar as verificações de tempo de atividade

Configure as verificações de tempo de atividade para o endpoint HTTP:

1. No menu à esquerda, na seção Detectar, clique em Verificações de tempo de atividade.
2. Clique em CRIAR VERIFICAÇÃO DE TEMPO DE ATIVIDADE.
3. Configure a verificação de tempo de atividade com os valores a seguir:

Propriedade	Valor (digite ou selecione)
Protocolo	HTTP
Tipo de recurso	URL
Nome do host	[IP externo da sua instância]
Caminho	/
Expandir mais opções de segmentação
Método de solicitação	GET
Porta	8545
Clique em "Continuar"	aceitar padrões
Clique em "Continuar"	aceitar padrões
Escolher o canal de notificação	Selecione o canal de notificação criado
Título	eth-mainnet-rpc-node-uptime-check

4. Clique em TESTAR (deve retornar o status de sucesso 200 OK).
5. Clique em CRIAR.

Clique em Verificar meu progresso para conferir o objetivo.

Configurar as operações do Cloud

Parabéns.

Neste laboratório, você criou uma instância do Compute Engine com um disco permanente, configurou um endereço IP estático e regras de firewall de rede, programou backups, implantou os clientes Ethereum Geth e Lighthouse, testou a configuração com chamadas RPC do Ethereum e configurou o Cloud Logging, o Monitoring e as verificações de tempo de atividade.

Próximas etapas/Saiba mais

Confira estes recursos para continuar sua jornada no Ethereum:

• Para saber mais sobre o cliente Ethereum (camada de execução), consulte o Geth.
• Para saber mais sobre o cliente Ethereum (camada de consenso), consulte Lighthouse.
• Para saber mais sobre o Ethereum, consulte Ethereum.
• Para saber mais sobre o Google Cloud para Web3, consulte o site do Google Cloud para Web3.
• Para saber mais sobre o Blockchain Node Engine para Google Cloud, consulte a página do Blockchain Node Engine.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 27 de julho de 2026

Laboratório testado em 27 de julho de 2026

Copyright 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.