Execute seu próprio nó Ethereum

Última edição: , Invalid DateTime

Ver colaboradores

Editar Página

(opens in a new tab)

Exdcutar um nó próprio proporciona vários benefícios, abre novas possibilidades e ajuda a dar suporte ao ecossistema. Esta página vai ajudar você a iniciar seu próprio nó, para assim participar na validação das transações de Ethereum.

Observe que após A Fusão, dois clientes são necessários para executar um nó Ethereum; um cliente da camada de execução (EL) e um cliente da camada de consenso (CL). Esta página mostrará como instalar, configurar e conectar esses dois clientes para executar um nó Ethereum.

Pré-requisitos

Você deve entender o que é um nó Ethereum e por que é importante executar um cliente. Isso é abordado em Nós e clientes.

Se você é novo no tópico de executar um nó ou está procurando um caminho menos técnico, recomendamos primeiro verificar nossa introdução simplificada sobre como executar um nó Ethereum.

Escolhendo um método

O primeiro passo para iniciar um nó é escolher sua abordagem. Com base nos requisitos e várias possibilidades, você deve selecionar a implementação do cliente (de ambos os clientes de execução e consenso), o ambiente (hardware, sistema) e os parâmetros para as configurações do cliente.

Esta página guiará você por essas decisões e ajudará você a encontrar a maneira mais adequada para executar sua instância do Ethereum.

Para escolher entre as implementações de cliente, veja todos os clientes de execução prontos para a Rede principal disponíveis, clientes de consenso e saiba mais sobre a diversidade de clientes.

Decida se deseja executar o software em seu próprio hardware ou na nuvem, considerando os requisitos dos clientes.

Após preparar o ambiente, instale os clientes escolhidos com interface simples para iniciantes ou manualmente usando um terminal com opções avançadas.

Quando o nó estiver em execução e sincronização, você estará pronto para usá-lo, mas certifique-se de ficar de olho em sua manutenção.

(opens in a new tab)↗

Ambiente e hardware

Local ou nuvem

Os clientes Ethereum são capazes de executar em computadores de grau de consumo e não exigem nenhum hardware especial, como máquinas de mineração, por exemplo. Portanto, você tem várias opções para implantar o nó de acordo com suas necessidades. Para simplificar, vamos analisar como executar um nó em uma máquina física local e um servidor na nuvem:

• Nuvem
  • Os provedores oferecem alto tempo de atividade do servidor e endereços IP públicos estáticos
  • Obter um servidor dedicado ou virtual pode ser mais cômodo que desenvolver o seu próprio
  • A desvantagem está em ter que confiar em um terceiro: o servidor
  • Por causa do tamanho do armazenamento necessário para o nó completo, o preço de um servidor alugado pode ficar alto
• Hardware próprio
  • Um método mais confiável e soberano
  • Investimento único
  • Existe a opção para comprar máquinas pré-configuradas
  • Você tem que fisicamente preparar, manter e solucionar os problemas potenciais que surgirem

Ambas as opções têm vantagens e desvantagens, as quais foram resumidas acima. Caso estiver procurando uma solução para a nuvem, além de muitos provedores tradicionais de computação na nuvem, também existem serviços focados em executar nós. Por exemplo:

• QuikNode(opens in a new tab)↗
• Blockdaemon(opens in a new tab)↗
• Alchemy(opens in a new tab)↗

Confira também nós como serviço para obter mais opções de nós hospedados.

Hardware

No entanto, uma rede descentralizada que resiste à censura não deve depender de provedores na nuvem. Em vez disso, executar seu nó em seu próprio hardware local é mais saudável para o ecossistema. As estimativas(opens in a new tab)↗ mostram uma grande parte dos nós executados na nuvem, o que pode se tornar um único ponto de falha.

Os clientes Ethereum podem ser executados no seu computador, laptop, servidor ou até mesmo em um computador de placa única. Enquanto executar clientes em seu computador pessoal é possível. Ter uma máquina dedicada apenas para seu nó pode melhorar significativamente seu desempenho e segurança enquanto minimiza o impacto em seu computador principal.

O uso de seu próprio hardware pode ser muito fácil. Existem muitas opções simples, bem como configurações avançadas para pessoas mais técnicas. Então, vamos analisar os requisitos e meios para executar clientes Ethereum em sua máquina.

Requisitos

Os requisitos de hardware diferem de acordo com o cliente, mas geralmente não são tão altos, já que o nó só precisa ser sincronizado. Não confunda isso com mineração, que requer muito mais poder de computação. Os tempos de sincronização e desempenho, no entanto, melhoram com hardware mais potente.

Antes de instalar qualquer cliente, certifique-se de que seu computador tem recursos suficientes para executá-lo. Você pode encontrar os requisitos mínimos e recomendados abaixo.

O gargalo para seu hardware é, em sua maioria, o espaço em disco. Sincronizar a cadeia de blocos Ethereum é muito intensivo em entrada/saída e requer muito espaço. É melhor ter uma unidade de estado sólido (SSD) com centenas de GBs de espaço livre para economizar, mesmo após a sincronização.

O tamanho do banco de dados e a velocidade da sincronização inicial dependem do cliente escolhido, sua configuração e estratégia de sincronização.

Verifique também que sua conexão de Internet não seja limitada devido a um limite de largura de banda(opens in a new tab)↗. É recomendado usar uma conexão ilimitada para que a sincronização inicial e os dados transmitidos à rede possam exceder seu limite.

Sistema operacional {#operating-system}

Todos os clientes suportam os principais sistemas operacionais: Linux, MacOS e Windows. Isso significa que você pode executar seu nó em computadores ou servidores regulares com o sistema operacional (SO) que melhor atenda às suas necessidades. Certifique-se, porém, de que seu sistema operacional está atualizado para evitar possíveis problemas e vulnerabilidades de segurança.

Requisitos mínimos {#minimum-requirements}

• CPU com mais de 2 núcleos
• 8 GB RAM
• 700 GB de espaço livre em disco
• • de 10 MBit/s de largura de banda

Especificações recomendadas {#recommended-hardware}

• CPU rápida com mais de 4 núcleos
• • de 16 GB de RAM
• SSD rápido com + de 1 TB
• • de 25 MBit/s de largura de banda

O modo de sincronização e o cliente que você escolher afetará os requisitos de espaço, mas estimamos o espaço em disco necessário para cada cliente abaixo.

• Nota: Erigon não oferece sincronização rápida, mas a limpeza completa é possível (~ 500 Gb)

Para clientes de consenso, o requisito de espaço também depende da implementação do cliente e dos recursos habilitados (por exemplo, validador slasher), mas geralmente contam com outros 200 Gb necessários para dados de beacon. Com um grande número de validadores, a carga de largura de banda também cresce. Você pode encontrar detalhes sobre os requisitos do cliente de consenso nesta análise(opens in a new tab)↗.

Soluções "Plug-and-play"

A opção mais fácil para executar um nó com seu próprio hardware é usando ferramentas plug-and-play. Máquinas pré-configuradas de fornecedores oferecem a experiência mais direta: pedir, conectar, executar. Tudo é pré-configurado e roda automaticamente com um guia intuitivo e painel de controle para monitorar e controlar o software.

• DappNode(opens in a new tab)↗
• Avado(opens in a new tab)↗

Ethereum em um computador de placa única

Uma maneira fácil e barata de executar um nó Ethereum é usar um computador de placa única, mesmo com uma arquitetura ARM como o Raspberry Pi. Ethereum no ARM(opens in a new tab)↗ fornece imagens fáceis de executar de múltipla execução e cliente de consenso para Raspberry Pi e outras placas ARM.

Dispositivos pequenos, acessíveis e eficientes como esses são ideais para executar um nó em casa, mas tenha em mente o seu desempenho limitado.

Executando seu nó

A configuração real do cliente pode ser feita com programas automatizados ou manualmente, configurando o software do cliente diretamente.

Para usuários menos avançados, a abordagem recomendada é usar um programa, software que o orienta na instalação e automatiza o processo de configuração do cliente. No entanto, se você tiver alguma experiência de usar um terminal, as etapas para configuração manual devem ser simples de seguir.

Guia de configuração

Vários projetos de fácil utilização visam melhorar a experiência de configuração de um cliente. Esses programas fornecem instalação e configuração automática de cliente, com alguns até oferecendo uma interface gráfica para configuração guiada e monitoramento de clientes.

Abaixo estão alguns projetos que podem ajudá-lo a instalar e controlar clientes apenas com alguns cliques:

• DappNode(opens in a new tab)↗ – O DappNode não vem apenas com uma máquina de um fornecedor. O software, o programa atual e o centro de controle com muitos recursos podem ser usados em hardware arbitrário.
• eth-docker(opens in a new tab)↗ – Configuração automatizada usando Docker focada em participação fácil e segura, requer conhecimento básico de terminal e Docker, recomendado para usuários um pouco mais avançados.
• Stereum(opens in a new tab)↗ – Inicialização para instalar clientes em um servidor remoto via conexão SSH com um guia de configuração GUI, centro de controle e muitas outras funcionalidades.
• NiceNode(opens in a new tab)↗ – Programa com uma experiência de usuário simples para executar um nó em seu computador. Basta escolher os clientes e iniciá-los com alguns cliques. Ainda em desenvolvimento.

Configuração manual do cliente

A outra opção é baixar, verificar e configurar o software cliente manualmente. Mesmo que alguns clientes ofereçam uma interface gráfica, uma configuração manual ainda requer habilidades básicas com o terminal, mas oferece muito mais versatilidade.

Conforme explicado anteriormente, configurar seu próprio nó Ethereum exigirá executar um par de clientes de consenso e execução. Alguns clientes podem incluir um cliente leve de outro tipo e sincronizar sem a necessidade de qualquer outro software. No entanto, a verificação sem confiança completa requer ambas as implementações.

Obtendo o software do cliente

Primeiro, você precisa obter o software de cliente de execução e de cliente de consenso de sua preferência.

Você pode simplesmente baixar um aplicativo executável ou um pacote de instalação que se adapte ao seu sistema operacional e arquitetura. Sempre verifique as assinaturas e as somas de verificação dos pacotes baixados. Alguns clientes também oferecem repositórios ou imagens do Docker para instalação e atualizações mais fáceis. Todos os clientes são de código aberto, portanto, você também pode construí-los a partir do código-fonte. Isso é um método mais avançado, mas em alguns casos pode ser necessário.

Instruções para instalar cada cliente são fornecidas na documentação associada nas listas de clientes acima.

Aqui estão as páginas de lançamento dos clientes, nas quais você pode encontrar seus binários pré-construídos ou instruções sobre instalação:

Clientes de execução {#execution-clients}

• Besu(opens in a new tab)↗
• Erigon(opens in a new tab)↗ (não fornece um binário pré-construído, precisa ser compilado)
• Geth(opens in a new tab)↗
• Nethermind(opens in a new tab)↗

Também vale a pena notar que a diversidade de clientes é um problema na camada de execução. Recomenda-se que os leitores considerem a execução de um cliente de execução minoritário.

Clientes de consenso {#consensus-clients}

• Lighthouse(opens in a new tab)↗
• Lodestar(opens in a new tab)↗ (não fornece um binário pré-construído, apenas uma imagem do Docker ou para ser construído a partir da fonte)
• Nimbus(opens in a new tab)↗
• Prysm(opens in a new tab)↗
• Teku(opens in a new tab)↗

A diversidade de cliente é fundamental para nós de consenso executando validadores. Se a maioria dos validadores está executando a implementação de um único cliente, a segurança da rede está em risco. Portanto, é recomendável considerar a escolha de um cliente minoritário.

Veja o uso mais recente do cliente de rede(opens in a new tab)↗ e saiba mais sobre a diversidade do cliente.

Verificando o software {#verifying-the-software}

Ao baixar o software da Internet, é recomendável verificar sua integridade. Esta etapa é opcional, mas especialmente com uma peça de infraestrutura crucial como o cliente Ethereum. É importante estar ciente dos possíveis vetores de ataque e evitá-los. Se você baixou um binário pré-construído, você precisa confiar nele e arriscar que um invasor possa trocar o executável por um malicioso.

Os desenvolvedores assinam binários liberados com suas chaves PGP para que você possa verificar criptograficamente que está executando exatamente o software que eles criaram. Você só precisa obter as chaves públicas usadas pelos desenvolvedores, que podem ser encontradas nas páginas de lançamento do cliente ou na documentação. Após baixar a versão do cliente e sua assinatura, você pode usar uma implementação PGP, por exemplo. GnuPG(opens in a new tab)↗ para verificá-los facilmente. Confira um tutorial sobre como verificar software de código aberto usando gpg em linux(opens in a new tab)↗ ou Windows/MacOS(opens in a new tab)↗.

Outra forma de verificação é garantir que o hash, uma impressão digital criptográfica exclusiva, do software que você baixou corresponde ao fornecido pelos desenvolvedores. Isso é ainda mais fácil do que usar o PGP, e alguns clientes oferecem apenas essa opção. Basta executar a função de hash no software baixado e compará-lo com o da página de lançamento. Por exemplo:

1sha256sum teku-22.6.1.tar.gz
2
39b2f8c1f8d4dab0404ce70ea314ff4b3c77e9d27aff9d1e4c1933a5439767dde
4

Configuração do cliente

Depois de instalar, baixar ou compilar o software cliente, você estará pronto para executá-lo. Isso só significa que ele tem de ser executado com a configuração adequada. Os clientes oferecem opções de configuração variadas, que podem habilitar vários recursos.

Vamos começar com opções que podem influenciar significativamente o desempenho do cliente e o uso de dados. Os modos de sincronização representam diferentes métodos de download e validação de dados da cadeia de blocos. Antes de iniciar o nó, você deve decidir que rede e modo de sincronização deve ser usado. As coisas mais importantes a considerar são o espaço em disco e o tempo de sincronização que o cliente precisará. Preste atenção aos documentos do cliente para determinar qual modo de sincronização é o padrão. Se isso não lhe convêm, escolha outro com base no nível de segurança, nos dados disponíveis e no custo. Além do algoritmo de sincronização, você pode também definir a limpeza de diferentes tipos de dados antigos. A limpeza habilita a exclusão de dados desatualizados, por exemplo, remoção de nós de árvore do estado que são inacessíveis de blocos recentes.

Outras opções básicas de configuração são, por exemplo, escolher uma rede – Rede principal ou redes de teste, habilitando o ponto de extremidade HTTP para RPC ou WebSockets, etc. Você pode encontrar todos os recursos e opções na documentação do cliente. Várias configurações de cliente podem ser definidas executando o cliente com os marcadores correspondentes diretamente na CLI ou no arquivo de configuração. Cada cliente é um pouco diferente; consulte sempre sua documentação oficial ou a página de ajuda para obter detalhes sobre opções de configuração.

Para fins de teste, você pode preferir executar um cliente em uma das redes de testes. Veja a visão geral das redes suportadas.

Exemplos de execução de clientes de execução com configuração básica podem ser encontrados na próxima seção.

Iniciando a execução do cliente

Antes de iniciar o software cliente do Ethereum, faça uma última verificação de que seu ambiente está pronto. Por exemplo, verifique se:

• Há espaço em disco suficiente, considerando a rede escolhida e o modo de sincronização.
• A memória e a CPU não são interrompidas por outros programas.
• O sistema operacional é atualizado para a versão mais recente.
• O sistema tem a hora e a data corretas.
• Seu roteador e seu firewall aceitam conexões nas portas de escuta. Por padrão, os clientes do Ethereum usam uma porta de escuta (TCP) e uma porta de descoberta (UDP), ambas na porta 30303 por padrão.

Execute seu cliente primeiro em uma rede de testes para garantir que tudo esteja funcionando corretamente.

Você precisa declarar no início alguma configuração de cliente que não seja a padrão. Você pode usar sinalizadores ou o arquivo de configuração para declarar sua configuração preferida. O conjunto de recursos e a sintaxe de configuração de cada cliente diferem. Confira a documentação do seu cliente para ver as especificações.

Os clientes de execução e consenso se comunicam por meio de um terminal autenticado especificado na API Engine(opens in a new tab)↗. Para se conectar a um cliente de consenso, o cliente de execução deve gerar um jwtsecret(opens in a new tab)↗ em um caminho conhecido. Por razões de segurança e estabilidade, os clientes devem ser executados na mesma máquina e ambos os clientes devem conhecer esse caminho, pois ele é usado para autenticar uma conexão RPC local entre eles. O cliente de execução também deve definir uma porta de escuta para APIs autenticadas.

Esse token é gerado automaticamente pelo software cliente, mas, em alguns casos, você pode precisar fazer isso sozinho. Você pode gerá-lo usando OpenSSL(opens in a new tab)↗:

1openssl rand -hex 32 > jwtsecret
2

Iniciando a execução do cliente

Esta seção guiará você na inicialização dos clientes de execução. Serve apenas como exemplo de configuração básica, que iniciará o cliente com estas configurações:

• Especifica a rede para conectar, rede principal nos nossos exemplos
  • Em vez disso, você pode escolher uma das redes de teste para testes preliminares de sua configuração
• Define o diretório de dados, no qual todos os dados, incluindo a cadeia de blocos, serão armazenados
  • Certifique-se de substituir o caminho por um real, por exemplo, apontando para sua unidade externa
• Habilita interfaces para comunicação com o cliente
  • Incluindo JSON RPC e API Engine para comunicação com o cliente de consenso
• Define o caminho para jwtsecret para a API autenticada
  • Certifique-se de substituir o caminho de exemplo por um real que possa ser acessado pelos clientes, por exemplo, /tmp/jwtsecret

Por favor, tenha em mente que este é apenas um exemplo básico, que todas as outras configurações serão definidas como padrão. Preste atenção na documentação de cada cliente para aprender sobre valores padrão, configurações e funcionalidades. Para mais funcionalidades, por exemplo, para executar validadores, monitoramento, etc., consulte a documentação do cliente específico.

Observe que as barras invertidas \ nos exemplos são apenas para fins de formatação; marcadores de configuração podem ser definidos em uma única linha.

Executando o Besu

Este exemplo inicia o Besu na rede priincipal, armazena dados da cadeia de blocos no formato padrão em /data/ethereum, habilita o JSON RPC e a Engine RPC para conectar ao cliente de consenso. A API Engine é autenticada com o token jwtsecret e somente chamadas de localhost são permitidas.

1besu --network=mainnet \
2    --data-path=/data/ethereum \
3    --rpc-http-enabled=true \
4    --engine-rpc-enabled=true \
5    --engine-host-allowlist="*" \
6    --engine-jwt-enabled=true \
7    --engine-jwt-secret=/path/to/jwtsecret
8

O Besu também vem com uma opção de lançador o qual fará uma série de perguntas e gerará o arquivo de configuração. Execute o inicializador interativo usando:

1besu --Xlauncher
2

A documentação do Besu(opens in a new tab)↗ contém opções adicionais e detalhes de configuração.

Executando o Erigon

Este exemplo inicia o Erigon na rede principal, armazena dados da cadeia de blocos em /data/ethereum, habilita o JSON RPC, define quais namespaces são permitidos e habilita a autenticação, para conectar o cliente de consenso, definido pelo caminho jwtsecret.

1erigon --chain mainnet \
2    --datadir /data/ethereum \
3    --http --http.api=engine,eth,web3,net \
4    --authrpc.jwtsecret=/path/to/jwtsecret
5

Erigon, por padrão, executa uma sincronização completa com um HDD de 8 GB, o que resultará em mais de 2TB de dados de arquivo. Verifique se o datadir está apontando para o disco com espaço livre suficiente ou olha para o parâmetro --prune que pode ajustar diferentes tipos de dados. Verifique o --help do Erigon para saber mais.

Executando o Geth

Este exemplo inicia o Geth na rede principal, armazena os dados da cadeia de blocos em /data/ethereum, habilita o JSON RPC e define quais namespaces são permitidos. Ele também habilita a autenticação para conectar o cliente de consenso, que requer o caminho para jwtsecret e também a opção que define quais conexões são permitidas, em nosso exemplo apenas de localhost.

1geth --mainnet \
2    --datadir "/data/ethereum" \
3    --http --http.api="eth,web3,net" \
4    --authrpc.vhosts="localhost" \
5    --authrpc.jwtsecret=/path/to/jwtsecret
6

Verifique a documentação para todas as opções de configuração(opens in a new tab)↗ e, saiba mais sobre Geth executando um cliente de consenso(opens in a new tab)↗.

Executando o Nethermind

O Nethermind oferece várias opções de instalação(opens in a new tab)↗. O pacote vem com vários binários, incluindo um Inicializador com configuração guiada, que ajudará você a criar a configuração interativamente. Como alternativa, você encontra o Executor, que é o próprio executável e pode executá-lo com os sinalizadores de configuração. JSON RPC é habilidado por padrão.

1Nethermind.Runner --config mainnet \
2    --datadir /data/ethereum \
3    --JsonRpc.JwtSecretFile=/path/to/jwtsecret
4

Os documentos do Nethermind oferecem um guia completo(opens in a new tab)↗ sobre como executar o Nethermind com o cliente de consenso.

Um cliente de execução iniciará suas funções principais, pontos de extremidade escolhidos e começará a procurar por pares. Depois de conseguir descobrir os pares, o cliente inicia a sincronização. O cliente de execução vai aguardar uma conexão do cliente de consenso. Os dados atuais da cadeia de blocos estarão disponíveis assim que o cliente for sincronizado com sucesso com o estado atual.

Iniciando um cliente de consenso

O cliente de consenso deve ser iniciado com a configuração de porta correta para estabelecer uma conexão RPC local para o cliente de execução. Os clientes de consenso têm de ser executados com a porta do cliente de execução exposta como argumento de configuração.

O cliente de consenso também precisa do caminho para o jwt-secret do cliente de execução para autenticar a conexão RPC entre eles. Semelhante aos exemplos de execução acima, cada cliente de consenso tem um parâmetro de configuração que usa o caminho do arquivo do token jwt como argumento. Isso deve ser consistente com o caminho jwtsecret fornecido ao cliente de execução.

Se você planeja executar um validador, certifique-se de adicionar um marcador de configuração especificando o endereço Ethereum do destinatário da taxa. Aqui é que as recompensas do ether para o validador se acumulam. Cada cliente de consenso tem uma opção, por exemplo. --suggested-fee-recipient=0xabcd1, que recebe um endereço Ethereum como argumento.

Ao iniciar um Beacon Node em uma rede de testes, você pode economizar um tempo de sincronização significativo usando um ponto de extremidade público para sincronização de ponto de verificação(opens in a new tab)↗.

Executando um cliente de consenso

Executando o Lighthouse

Antes de executar o Lighthouse, saiba mais sobre como instalá-lo e configurá-lo no Livro do Lighthouse(opens in a new tab)↗.

1lighthouse beacon_node
2    --network mainnet \
3    --datadir /data/ethereum \
4    --http \
5    --execution-endpoint http://127.0.0.1:8551 \
6    --execution-jwt /path/to/jwtsecret \
7

Executando o Lodestar

Instale o software Lodestar compilando-o ou baixando a imagem do Docker. Saiba mais na documentação(opens in a new tab)↗ e no guia de configuração(opens in a new tab)↗ mais abrangente.

1lodestar beacon \
2    --rootDir="/data/ethereum" \
3    --network=mainnet \
4    --eth1.enabled=true \
5    --execution.urls="http://127.0.1:8551" \
6    --jwt-secret="/path/to/jwtsecret"
7

Executando o Nimbus

Nimbus vem com ambos os clientes de consenso e de execução. Ele pode ser executado em vários dispositivos, até mesmo com poder de computação muito modesto. Após instalar as dependências e o próprio Nimbus(opens in a new tab)↗, você pode executar seu cliente de consenso:

1nimbus_beacon_node \
2    --network=mainnet \
3    --web3-url=http://127.0.0.1:8551 \
4    --rest \
5    --jwt-secret="/path/to/jwtsecret"
6

Executando o Prysm

O Prysm vem com um script que permite uma fácil instalação automática. Os detalhes podem ser encontrados nos documentos do Prysm(opens in a new tab)↗.

1./prysm.sh beacon-chain \
2    --mainnet
3    --datadir /data/ethereum  \
4    --execution-endpoint=http://localhost:8551  \
5    --jwt-secret=/path/to/jwtsecret
6

Executando o Teku

1teku --network mainnet \
2    --data-path "/data/ethereum" \
3    --ee-endpoint http://localhost:8551 \
4    --ee-jwt-secret-file "/path/to/jwtsecret" \
5

Quando um cliente de consenso se conecta ao cliente de execução para ler o contrato de depósito e identificar validadores, ele também se conecta a outros pares do Beacon Node e começa a sincronizar os espaços de consenso do gênesis. Quando o Beacon Node atinge a época atual, a API do Beacon se torna utilizável para seus validadores. Saiba mais sobre APIs do Beacon Node(opens in a new tab)↗.

Adicionando validadores

Um cliente de consenso serve como um Beacon Node para os validadores se conectarem. Cada cliente de consenso tem seu próprio software de validador descrito em detalhes em sua respectiva documentação.

Executar seu próprio validador permite a participação individual(opens in a new tab)↗, o método mais impactante e confiável para dar suporte à rede Ethereum. No entanto, isso requer um depósito de 32 ETH. Para executar um validador em seu próprio nó com uma quantidade menor, um pool descentralizado com operadores de nós sem permissão, como Rocket Pool(opens in a new tab)↗, poderá lhe interessar.

A maneira mais fácil de começar com a participação e a geração de chaves de validação é usar a Plataforma de lançamento de participação da rede de testes Goerli(opens in a new tab)↗, que permite testar sua configuração executando nós no Goerli(opens in a new tab)↗. Quando você estiver pronto para a Rede principal, você poderá repetir essas etapas usando a Plataforma de lançamento de participação da rede de testes Goerli(opens in a new tab)↗.

Consulte a página de participação para obter uma visão geral sobre as opções de participação.

Usando o nó

Os clientes de execução oferecem pontos de extremidade da API RPC que você pode usar para enviar transações, interagir ou implantar contratos inteligentes na rede Ethereum de várias maneiras:

• Chamando-os manualmente com um protocolo adequado (por exemplo, usando curl)
• Anexando um console (exemplo geth attach)
• Implementá-los em aplicações usando bibliotecas do Web3, por exemplo, web3.py(opens in a new tab)↗, ethers(opens in a new tab)↗

Diferentes clientes têm diferentes implementações dos pontos de extremidade RPC. Mas existe um JSON-RPC padrão que você pode usar com cada cliente. Para uma visão geral leia os documentos JSON-RPC. Aplicativos que precisam de informações da rede Ethereum podem usar esse RPC. Por exemplo, a popular carteira MetaMask permite você conectar-se ao seu próprio endpoint RPC(opens in a new tab)↗, que tem fortes benefícios de privacidade e segurança.

Todos os clientes de consenso expõem uma API Beacon(opens in a new tab)↗, que pode ser usada para verificar o status do cliente de consenso ou baixar blocos e dados de consenso enviando solicitações usando ferramentas como Curl(opens in a new tab)↗. Mais informações sobre isso podem ser encontradas na documentação de cada cliente de consenso.

Comunicação com o RPC

A porta padrão para o cliente de execução JSON-RPC é 8545, mas você pode modificar as portas dos pontos de extremidade locais na configuração. Por padrão, a interface RPC só pode ser acessada no host local do seu computador. Para torná-lo acessível remotamente, você pode expô-lo ao público alterando o endereço para 0.0.0.0. Isso o tornará acessível pela rede local e endereços IP públicos. Na maioria dos casos, você também precisará configurar o encaminhamento de porta no seu roteador.

Aborde a exposição de portas à Internet com cuidado, pois isso permitirá que qualquer pessoa na Internet controle seu nó. Atores maliciosos podem acessar seu nó para derrubar seu sistema ou roubar seus fundos, se você estiver usando seu cliente como uma carteira.

Uma forma de contornar isso é evitar que métodos RPC potencialmente nocivos sejam modificáveis. Por exemplo, com Geth, você pode declarar métodos modificáveis com uma configuração: --http.api web3,eth,txpool.

O acesso à interface RPC pode ser estendido por meio do desenvolvimento de APIs da camada de fronteira ou aplicativos de servidor Web, como o Nginx, e conectando-os ao endereço e porta local do seu cliente. O aproveitamento de uma camada intermediária também pode permitir que os desenvolvedores configurem um certificado para conexões seguras https para a interface RPC.

Configurar um servidor Web, um proxy ou face a uma API Rest externa não é a única maneira de fornecer acesso ao ponto de extremidade RPC do seu nó. Outra maneira de preservar a privacidade para configurar um ponto de extremidade publicamente acessível é hospedar o nó em seu próprio serviço onion Tor(opens in a new tab)↗. Isso permitirá que você se comunique com o RPC fora da sua rede local sem um endereço público estático de IP ou portas abertas. No entanto, usar esta configuração só pode permitir que o ponto de extremidade RPC seja acessível através da rede Tor, que não é suportada por todos os aplicativos e pode resultar em problemas de conexão.

Para fazer isso, você precisa criar seu próprio serviço onion(opens in a new tab)↗. Confira a documentação(opens in a new tab)↗ sobre a configuração do serviço onion para hospedar o seu próprio. Você pode apontá-lo para um servidor Web com proxy para a porta RPC ou apenas diretamente para o RPC.

Por fim, e uma das formas mais populares de fornecer acesso a redes internas é através de uma conexão VPN. Dependendo do seu caso de uso e da quantidade de usuários que precisam de acesso ao seu nó, uma conexão VPN segura pode ser uma opção. OpenVPN(opens in a new tab)↗ é uma VPN SSL completa que implementa a extensão de rede segura da camada OSI 2 ou 3 usando o protocolo SSL/TLS padrão da indústria, suporta métodos flexíveis de autenticação de cliente com base em certificados, cartões inteligentes e/ou credenciais de usuário/senha e permite políticas de controle de acesso específicas de usuário ou grupo usando regras de firewall aplicadas à interface virtual VPN.

Operando o nó

Você deve monitorar regularmente seu nó para garantir que ele esteja funcionando corretamente. Você pode precisar fazer manutenção ocasional.

Mantendo o nó online

Seu nó não precisa estar online o tempo todo, mas você deve mantê-lo online o máximo possível para mantê-lo sincronizado com a rede. Você pode desligar ele para reiniciá-lo, mas lembre-se de que:

• O encerramento pode levar alguns minutos se o estado recente ainda estiver sendo gravado no disco.
• Encerramentos forçados podem danificar o banco de dados, exigindo que você ressincronize todo o nó.
• Seu cliente ficará dessincronizado com a rede e precisará ser ressincronizado quando você o reiniciar. Embora o nó possa começar a sincronizar de onde foi o último encerramento, o processo pode demorar dependendo de quanto tempo ele esteve offline.

Isso não se aplica a nós validadores da camada de consenso. Colocar seu nó offline afetará todos os serviços dependentes dele. Se você estiver rodando um nó para fins de participação, então você deve tentar minimizar o tempo de inatividade tanto quanto for possível.

Criando serviços de clientes

Considere criar um serviço para executar seus clientes automaticamente na inicialização. Por exemplo, em servidores Linux, uma boa prática seria criar um serviço, por exemplo, com systemd, que executa o cliente com a configuração adequada, sob um usuário com privilégios limitados e reinicia automaticamente.

Atualizando clientes

Você precisa manter seu software cliente atualizado com os mais recentes patches de segurança, recursos e EIPs. Especialmente antes de bifurcações permanentes, verifique se você está executando as versões corretas do cliente.

Antes de atualizações importantes da rede, a EF publica uma postagem em seu blog(opens in a new tab)↗. Você pode assinar esses anúncios(opens in a new tab)↗ para receber uma notificação no seu e-mail quando o seu nó precisar de uma atualização.

Atualizar clientes é muito simples. Cada cliente tem instruções específicas em sua documentação, mas o processo geralmente é apenas baixar a versão mais recente e reiniciar o cliente com o novo executável. O cliente deve continuar de onde parou, mas com as atualizações aplicadas.

Cada implementação de cliente tem uma cadeia de caracteres de versão legível por humanos usada no protocolo ponto a ponto, mas também é acessível a partir da linha de comando. Essa cadeia de caracteres de versão permite que os usuários verifiquem se estão executando a versão correta e possibilita exploradores de blocos e outras ferramentas analíticas interessadas em quantificar a distribuição de clientes específicos na rede. Consulte a documentação do cliente individual para obter mais informações sobre cadeias de caracteres de versão.

Executando serviços adicionais

Executar seu próprio nó permite que você use serviços que exigem acesso direto ao cliente RPC do Ethereum. Estes são serviços construídos em cima do Ethereum, como soluções de camada 2, back-end para carteiras, exploradores de blocos, ferramentas de desenvolvimento e outras infraestruturas Ethereum.

Monitorando o nó

Para monitorar adequadamente seu nó, considere coletar métricas. Os clientes fornecem pontos de extremidade de métricas para que você possa obter dados abrangentes sobre seu nó. Use ferramentas como InfluxDB(opens in a new tab)↗ ou Prometheus(opens in a new tab)↗ para criar bancos de dados que você pode transformar em visualizações e gráficos em softwares como Grafana(opens in a new tab)↗. Existem muitas configurações para usar este software e diferentes painéis do Grafana para você visualizar seu nó e a rede como um todo. Por exemplo, confira tutorial sobre como monitorar o Geth.

Como parte de seu monitoramento, certifique-se de ficar de olho no desempenho de sua máquina. Durante a sincronização inicial do seu nó, o software cliente pode sobrecarregar muito a CPU e a RAM. Além do Grafana, você pode usar as ferramentas que seu sistema operacional oferece, como htop ou uptime para fazer isso.

Leitura adicional

• Guias de participação do Ethereum(opens in a new tab)↗ - Somer Esat, atualizado com frequência
• Guia | Como configurar um validador para participação do Ethereum na rede principal(opens in a new tab)↗ – CoinCashew, atualizado regularmente
• Guias do ETHStaker sobre como executar validadores em redes de teste(opens in a new tab)↗ – ETHStaker, atualizado regularmente
• Guias de Participação do Ethereum(opens in a new tab)↗ – Somer Esat, atualizado regularmente
• FAQ sobre A Fusão para operadores de nós(opens in a new tab)↗ - julho de 2022
• Analisando os requisitos de hardware para ser um nó totalmente validado no Ethereum(opens in a new tab)↗ – Albert Palau, 24 de setembro de 2018
• Executando nós completos Ethereum: Um guia para os pouco motivados(opens in a new tab)↗ – Justin Leroux, 7 de novembro de 2019
• Executando um nó Ethereum(opens in a new tab)↗ – ETHHub, atualizado com frequência
• Executando um nó Hyperledger Besu na Rede principal do Ethereum: benefícios, requisitos e configurações(opens in a new tab)↗ – Felipe Faraggi, 7 de maio de 2020
• Implantando o cliente Nethermind do Ethereum com uma pilha de monitoramento(opens in a new tab)↗ – Nethermind.eth, 8 de julho de 2020

Tópicos relacionados

• Nós e clientes
• Blocos
• Redes