CoinCashew
English
Search…
⌃K
Links

Guide | (Legacy) How to setup a validator on ETH2 testnet

Become a validator and help secure eth2, a proof-of-stake blockchain. Anyone with 32 ETH can join.
As of August 28 2021, testnet PYRMONT is no longer supported.
This guide is for historical references only.
If you would like to test, practice on testnet GOERLI.
Mainnet guide. Always test and practice on testnet first.

🏁
0. Prerequisites

👩💻
Skills for operating a eth2 validator and beacon node

As a validator for eth2, you will typically have the following abilities:
  • operational knowledge of how to set up, run and maintain a eth2 beacon node and validator continuously
  • a long term commitment to maintain your validator 24/7/365
  • basic operating system skills

👨💻
Experience required to be a successful validator

🎗
Minimum Setup Requirements

  • Operating system: 64-bit Linux (i.e. Ubuntu 20.04 LTS Server or Desktop)
  • Processor: Dual core CPU, Intel Core i5–760 or AMD FX-8100 or better
  • Memory: 8GB RAM
  • Storage: 128GB SSD
  • Internet: Broadband internet connection with speeds at least 1 Mbps.
  • Power: Reliable electrical power.
  • ETH balance: at least 32 goerli ETH and some ETH for deposit transaction fees
  • Wallet: Metamask installed
  • Operating system: 64-bit Linux (i.e. Ubuntu 20.04 LTS Server or Desktop)
  • Processor: Quad core CPU, Intel Core i7–4770 or AMD FX-8310 or better
  • Memory: 16GB RAM or more
  • Storage: 2TB SSD or more
  • Internet: Broadband internet connections with speeds at least 10 Mbps without data limit.
  • Power: Reliable electrical power with uninterruptible power supply (UPS)
  • ETH balance: at least 32 goerli ETH and some ETH for deposit transaction fees
  • Wallet: Metamask installed
💡
For examples of actual staking hardware builds, check out RocketPool's hardware guide.
Pro Validator Tip: Highly recommend you begin with a brand new instance of an OS, VM, and/or machine. Avoid headaches by NOT reusing testnet keys, wallets, or databases for your validator.
If you need ideas or a reminder on how to secure your validator, refer to

🛠
Setup Ubuntu

If you need to install Ubuntu Server, refer to
or Ubuntu Desktop,

🎭
Setup Metamask

If you need to install Metamask, refer to

🧩
High Level Validator Node Overview

At the end of this guide, you will build a machine that hosts three main components: a validator client, a beacon chain client and an eth1 node.
Validator client - Responsible for producing new blocks and attestations in the beacon chain and shard chains.
Beacon chain client - Responsible for managing the state of the beacon chain, validator shuffling, and more.
Eth1 node - Supplies incoming validator deposits from the eth1 mainnet chain to the beacon chain client.
Note: Teku and Nimbus combines both clients into one process.
How eth2 fits together featuring Leslie the eth2 Rhino, the mascot named after American computer scientist Leslie Lamport

🌱
1. Obtain testnet ETH

Every 32 ETH you own allows you to make 1 validator. You can run thousands of validators with your beacon node. However on testnet, please only run 1 or 2 validators to keep the activation queue reasonably quick.
Join the ethstaker Discord and send a request for ETH in the -request-goerli-eth channel
!send <your metamask goerli network ETH address>
Otherwise, visit the
🚰
Goerli Authenticated Faucet.

👩💻
2. Signup to be a validator at the Launchpad

  1. 1.
    Install dependencies, the ethereum foundation deposit tool and generate your two sets of key pairs.
Each validator will have two sets of key pairs. A signing key and a withdrawal key. These keys are derived from a single mnemonic phrase. Learn more about keys.
You have the choice of downloading the pre-built ethereum foundation deposit tool or building it from source. Alternatively, if you have a Ledger Nano X/S or Trezor Model T, you're able to generate deposit files with keys managed by a hardware wallet.

How to generate validator keys with Ledger Nano X/S and Trezor Model T

Allnodes has created an easy to use tool to connect a Ledger Nano X/S and Trezor Model T and generate the deposit json files such that the withdrawal credentials remain secured by the hardware wallet. This tool can be used by any validator or staker.
  1. 1.
    Connect your hardware wallet to your PC/laptop
  2. 2.
    If using a Ledger Nano X/S, open the "ETHEREUM" ledger app (if missing, install from Ledger Live)
  3. 4.
    Select network > Gorli (Pyrmont) Testnet
  4. 5.
    Select your wallet > then CONTINUE
6. From the dropdown, select your eth address with at least 32 ETH to fund your validators
7. On your hardware wallet, sign the ETH signature message to login to allnodes.com
8. Again on your hardware wallet, sign another message to verify your eth2 withdrawal credentials
Double check that your generated deposit data file contains the same string as in withdrawal credentials and that this string includes your Ethereum address (starting after 0x)
9. Enter the amount of nodes (or validators you want)
10. Finally, enter a KEYSTORE password to encrypt the deposit json files. Keep this password safe and offline.
11. Confirm password and click GENERATE
Install dependencies.
sudo apt update
sudo apt install python3-pip git -y
Download source code and install.
cd $HOME
git clone https://github.com/ethereum/eth2.0-deposit-cli.git eth2deposit-cli
cd eth2deposit-cli
sudo ./deposit.sh install
Make a new mnemonic.
./deposit.sh new-mnemonic --chain pyrmont
Advanced option: Custom eth1 withdrawal address, often used for 3rd party staking.
# Add the following
--eth1_withdrawal_address <eth1 address hex string>
# Example
./deposit.sh new-mnemonic --chain pyrmont --eth1_withdrawal_address 0x1...x
If this field is set and valid, the given Eth1 address will be used to create the withdrawal credentials. Otherwise, it will generate withdrawal credentials with the mnemonic-derived withdrawal public key in EIP-2334 format.
Download eth2deposit-cli.
cd $HOME
wget https://github.com/ethereum/eth2.0-deposit-cli/releases/download/v1.2.0/eth2deposit-cli-256ea21-linux-amd64.tar.gz
Verify the SHA256 Checksum matches the checksum on the releases page.
echo "825035b6d6c06c0c85a38f78e8bf3e9df93dfd16bf7b72753b6888ae8c4cb30a *eth2deposit-cli-ed5a6d3-linux-amd64.tar.gz" | shasum -a 256 --check
Example valid output:
eth2deposit-cli-256ea21-linux-amd64.tar.gz: OK
Only proceed if the sha256 check passes with OK!
Extract the archive.
tar -xvf eth2deposit-cli-256ea21-linux-amd64.tar.gz
mv eth2deposit-cli-256ea21-linux-amd64 eth2deposit-cli
rm eth2deposit-cli-256ea21-linux-amd64.tar.gz
cd eth2deposit-cli
Make a new mnemonic.
./deposit new-mnemonic --chain pyrmont
Advanced option: Custom eth1 withdrawal address, often used for 3rd party staking.
# Add the following
--eth1_withdrawal_address <eth1 address hex string>
# Example
./deposit.sh new-mnemonic --chain pyrmont --eth1_withdrawal_address 0x1...x
If this field is set and valid, the given Eth1 address will be used to create the withdrawal credentials. Otherwise, it will generate withdrawal credentials with the mnemonic-derived withdrawal public key in EIP-2334 format.
🔥
[ Optional ] Pro Security Tip: Run the eth2deposit-cli tool and generate your mnemonic seed for your validator keys on an air-gapped offline machine booted from usb.
You will learn how to boot up a windows PC into an airgapped Tails operating system.
The Tails OS is an amnesic operating system, meaning it will save nothing and leave no tracks behind each time you boot it.

Part 0 - Prerequisites

You need:
  • 2 storage mediums (can be USB stick, SD cards or external hard drives)
  • One of them must be > 8GB
  • Windows or Mac computer
  • 30 minutes or longer depending on your download speed

Part 1 - Download Tails OS

Download the official image from the Tails website. Might take a while, go grab a coffee.
Make sure you follow the guide on the Tails website to verify your download of Tails.

Part 2 - Download and install the software to transfer your Tails image on your USB stick

For Windows, use one of
For Mac, download Etcher

Part 3 - Making your bootable USB stick

Run the above software. This is an example how it looks like on Mac OS with etcher, but other software should be similar.
Select the Tails OS image that you downloaded as the image. Then select the USB stick (the larger one).
Then flash the image to the larger USB stick.

Part 4 - Download and verify the eth2-deposit-cli

You can refer to the other tab on this guide on how to download and verify the eth2-deposit-cli.
Copy the file to the other USB stick.

Part 5 - Reboot your computer and into Tails OS

After you have done all the above, you can reboot. If you are connected by a LAN cable to the internet, you can disconnect it manually.
Plug in the USB stick that has your Tails OS.
On Mac, press and hold the Option key immediately upon hearing the startup chime. Release the key after Startup Manager appears.
On Windows, it depends on your computer manufacturer. Usually it is by pressing F1 or F12. If it doesn't work, try googling "Enter boot options menu on [Insert your PC brand]"
Choose the USB stick that you loaded up with Tails OS to boot into Tails.

Part 6 - Welcome to Tails OS

You can boot with all the default settings.

Part 7 - Run the eth2-deposit-cli

Plug in your other USB stick with the eth2-deposit-cli file.
You can then open your command line and navigate into the directory containing the file. Then you can continue the guide from the other tab.
Make a new mnemonic.
./deposit.sh new-mnemonic --chain pyrmont
If you ran this command directly from your non-Tails USB stick, the validator keys should stay on it. If it hasn't, copy the directory over to your non-Tails USB stick.
****
🔥
Make sure you have saved your validator keys directory in your other USB stick (non Tails OS) before you shutdown Tails. Tails will delete everything saved on it after you shutdown..
🎉
Congrats on learning how to use Tails OS to make an air gapped system. As a bonus, you can reboot into Tails OS again and connect to internet to surf the dark web or clear net safely!
Alternatively, follow this ethstaker.cc exclusive for the low down on making a bootable usb.

Part 1 - Create a Ubuntu 20.04 USB Bootable Drive

2. If using eth2deposit-cli, follow the prompts and pick a KEYSTORE password. This password encrypts your keystore files. Write down your mnemonic and keep this safe and offline.
****
🚧
Do not send real mainnet ETH during this process!
🛑
Use only goerli ETH.
You should have both your Eth1 node and Beacon Chain node synced before your validator becomes active. If they are not, you may incur penalties until they are synced. You may want to complete steps 3 and 4 BEFORE initiating your deposit to avoid these penalties.
3. Follow the steps at https://pyrmont.launchpad.ethereum.org while skipping over the steps you already just completed. Study the eth2 phase 0 overview material. Understanding eth2 is the key to success!
****
🐳
Batch Depositing Tip: If you have many deposits to make for many validators, consider using Abyss.finance's eth2depositor tool. This greatly improves the deposit experience as multiple deposits can be batched into one transaction, thereby saving gas fees and saving your fingers by minimizing Metamask clicking.
Make sure to switch to GÖRLI network.
4. Back on the launchpad website, upload yourdeposit_data-#########.json found in the validator_keys directory.
5. Connect to the launchpad with your Metamask wallet, review and accept terms.
6. Confirm the transaction(s). There's one deposit transaction of 32 ETH for each validator.
Your transaction is sending and depositing your ETH to the pyrmont ETH2 deposit contract address.
Check, double-check, triple-check that the pyrmont Eth2 deposit contract address is correct.
****
🔥
Critical Crypto Reminder: Keep your mnemonic, keep your ETH.
🚀
  • Write down your mnemonic seed offline. Not email. Not cloud.
  • Multiple copies are better. Best stored in a metal seed.
  • The withdrawal keys will be generated from this mnemonic in the future.
  • Make offline backups, such as to a USB key, of your validator_keys directory.

🛸
3. Install a ETH1 node

Ethereum 2.0 requires a connection to Ethereum 1.0 in order to monitor for 32 ETH validator deposits. Hosting your own Ethereum 1.0 node is the best way to maximize decentralization and minimize dependency on third parties such as Infura.
The subsequent steps assume you have completed the best practices security guide.
🛑
Do not run your processes as ROOT user.
😱
Your choice of either OpenEthereum, Geth, Besu, Nethermind or Infura.
Geth
Besu
Nethermind
OpenEthereum (Parity)
Minimum Hardware Setup (Infura)
Geth - Go Ethereum is one of the three original implementations (along with C++ and Python) of the Ethereum protocol. It is written in Go, fully open source and licensed under the GNU LGPL v3.
🧬
Install from the repository
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update -y
sudo apt-get install ethereum -y
Setup and configure systemd
Run the following to create a unit file to define your eth1.service configuration.
Simply copy/paste the following.
cat > $HOME/eth1.service << EOF
[Unit]
Description = geth eth1 service
Wants = network-online.target
After = network-online.target
[Service]
User = $(whoami)
ExecStart = /usr/bin/geth --http --goerli --metrics --pprof
Restart = on-failure
RestartSec = 3
TimeoutSec = 300
[Install]
WantedBy = multi-user.target
EOF
Nimbus Specific Configuration: Add the following flag to the ExecStart line.
--ws
Move the unit file to /etc/systemd/system and give it permissions.
sudo mv $HOME/eth1.service /etc/systemd/system/eth1.service
sudo chmod 644 /etc/systemd/system/eth1.service
Run the following to enable auto-start at boot time.
sudo systemctl daemon-reload
sudo systemctl enable eth1
Start geth
sudo systemctl start eth1
Hyperledger Besu is an open-source Ethereum client designed for demanding enterprise applications requiring secure, high-performance transaction processing in a private network. It's developed under the Apache 2.0 license and written in Java.
🧬
Install java dependency
sudo apt-get update
sudo apt install openjdk-18-jdk -y
🌜
Download and unzip Besu
Review the latest release at https://github.com/hyperledger/besu/releases
cd
wget -O besu.tar.gz https://dl.bintray.com/hyperledger-org/besu-repo/besu-20.10.1.tar.gz
tar -xvf besu.tar.gz
rm besu.tar.gz
mv besu* besu
Setup and configure systemd
Run the following to create a unit file to define your eth1.service configuration.
Simply copy/paste the following.
cat > $HOME/eth1.service << EOF
[Unit]
Description = besu eth1 service
Wants = network-online.target
After = network-online.target
[Service]
User = $(whoami)
ExecStart = $(echo $HOME)/besu/bin/besu --metrics-enabled --rpc-http-enabled --network=goerli --data-path="$HOME/.besu_goerli"
Restart = on-failure
RestartSec = 3
[Install]
WantedBy = multi-user.target
EOF
Move the unit file to /etc/systemd/system and give it permissions.
sudo mv $HOME/eth1.service /etc/systemd/system/eth1.service
sudo chmod 644 /etc/systemd/system/eth1.service
Run the following to enable auto-start at boot time.
sudo systemctl daemon-reload
sudo systemctl enable eth1
Start besu
sudo systemctl start eth1
Nethermind is a flagship Ethereum client all about performance and flexibility. Built on .NET core, a widespread, enterprise-friendly platform, Nethermind makes integration with existing infrastructures simple, without losing sight of stability, reliability, data integrity, and security.
Install dependencies
sudo apt-get update
sudo apt-get install curl libsnappy-dev libc6-dev jq libc6 unzip -y
🌜
Download and unzip Nethermind
Automatically download the latest linux release, un-zip and cleanup.
mkdir $HOME/nethermind
chmod 775 $HOME/nethermind
cd $HOME/nethermind
curl -s https://api.github.com/repos/NethermindEth/nethermind/releases/latest | jq -r ".assets[] | select(.name) | .browser_download_url" | grep linux | xargs wget -q --show-progress
unzip -o nethermind*.zip
rm nethermind*linux*.zip
Setup and configure systemd
Run the following to create a unit file to define your eth1.service configuration.
Simply copy/paste the following.
cat > $HOME/eth1.service << EOF
[Unit]
Description = nethermind eth1 service
Wants = network-online.target
After = network-online.target
[Service]
User = $(whoami)
ExecStart = $(echo $HOME)/nethermind/Nethermind.Runner --config goerli --baseDbPath $HOME/.nethermind_goerli --Metrics.Enabled true --JsonRpc.Enabled true --Sync.DownloadBodiesInFastSync true --Sync.DownloadReceiptsInFastSync true --Sync.AncientBodiesBarrier 11052984 --Sync.AncientReceiptsBarrier 11052984
Restart = on-failure
RestartSec = 3
[Install]
WantedBy = multi-user.target
EOF
Move the unit file to /etc/systemd/system and give it permissions.
sudo mv $HOME/eth1.service /etc/systemd/system/eth1.service
sudo chmod 644 /etc/systemd/system/eth1.service
Run the following to enable auto-start at boot time.
sudo systemctl daemon-reload
sudo systemctl enable eth1
Start Nethermind
sudo systemctl start eth1
Note about Metric Error messages: You will see these until prometheus pushergateway is setup in section 6. Error in MetricPusher: System.Net.Http.HttpRequestException: Connection refused
OpenEthereum will no longer be supported post London hard fork. Gnosis, maintainers of OpenEthereum, suggest users migrate to their new Erigon Ethererum client.
OpenEthereum - It's **** goal is to be the fastest, lightest, and most secure Ethereum client using the Rust programming language. OpenEthereum is licensed under the GPLv3 and can be used for all your Ethereum needs.
Install dependencies
sudo apt-get update
sudo apt-get install curl jq unzip -y
🤖
Install OpenEthereum
Automatically download the latest linux release, un-zip, add execute permissions and cleanup.
mkdir $HOME/openethereum
cd $HOME/openethereum
curl -s https://api.github.com/repos/openethereum/openethereum/releases/latest | jq -r ".assets[] | select(.name) | .browser_download_url" | grep linux | xargs wget -q --show-progress
unzip -o openethereum*.zip
chmod +x openethereum
rm openethereum*.zip
Setup and configure systemd
Run the following to create a unit file to define your eth1.service configuration.
Simply copy/paste the following.
cat > $HOME/eth1.service << EOF
[Unit]
Description = openethereum eth1 service
Wants = network-online.target
After = network-online.target
[Service]
User = $(whoami)
ExecStart = $(echo $HOME)/openethereum/openethereum --chain goerli --metrics --metrics-port=6060
Restart = on-failure
RestartSec = 3
[Install]
WantedBy = multi-user.target
EOF
Nimbus Specific Configuration: Add the following flag to the ExecStart line.
--ws-origins=all
Move the unit file to /etc/systemd/system and give it permissions.
sudo mv $HOME/eth1.service /etc/systemd/system/eth1.service
sudo chmod 644 /etc/systemd/system/eth1.service
Run the following to enable auto-start at boot time.
sudo systemctl daemon-reload
sudo systemctl enable eth1
Start OpenEthereum
sudo systemctl start eth1
Infura is suitable for limited disk space setups. Always run your own full eth1 node when possible.
Sign up for an API access key at https://infura.io/
  1. 1.
    Sign up for a free account.
  2. 2.
    Confirm your email address.
  3. 3.
    Visit your dashboard https://infura.io/dashboard
  4. 4.
    Create a project, give it a name.
  5. 5.
    Select Goerli as the ENDPOINT
  6. 6.
    Follow the specific configuration for your eth2 client found below.
Alternatively use a free testnet Ethereum node such as Chainstack at https://ethereumnodes.com/

Nimbus Specific Configuration

  1. 1.
    When creating your systemd's unit file, update the --web-url parameter with this endpoint.
  2. 2.
    Copy the websocket endpoint. Starts with wss://
  3. 3.
    Save this for step 4, configuring your eth2 node.
#example
--web3-url=<your wss:// infura endpoint>

Teku Specific Configuration

  1. 1.
    After creating the teku.yaml located in /etc/teku/teku.yaml, update the --eth1-endpoint parameter with this endpoint.
  2. 2.
    Copy the http endpoint. Starts with http://
  3. 3.
    Save this for step 4, configuring your eth2 node.
#example
eth1-endpoint: <your https:// infura endpoint>

Lighthouse Specific Configuration

  1. 1.
    When creating your beacon chain systemd unit file, add the --eth1-endpoint parameter with this endpoint.
  2. 2.
    Copy the https endpoint. Starts with https://
  3. 3.
    Save this for step 4, configuring your eth2 node.
#example
--eth1-endpoint=<your https:// infura endpoint>

Prysm Specific Configuration

  1. 1.
    When creating your beacon chain systemd unit file, update the --http-web3provider parameter with this endpoint.
  2. 2.
    Copy the https endpoint. Starts with https://
  3. 3.
    Save this for step 4, configuring your eth2 node.
#example
--http-web3provider=<your https:// infura endpoint>
Syncing an eth1 node can take up to 1 week. On high-end machines with gigabit internet, expect syncing to take less than a day.
Your eth1 node is fully sync'd when these events occur.
  • OpenEthereum: Imported #<block number>
  • Geth: Imported new chain segment
  • Besu: Imported #<block number>
  • Nethermind: No longer syncing Old Headers

🛠
Helpful eth1.service commands

​​
🗒
To view and follow eth1 logs
journalctl -u eth1 -f
🗒
To stop eth1 service
sudo systemctl stop eth1

🌜
4. Configure a ETH2 beacon chain node and validator

Your choice of Lighthouse, Nimbus, Teku, Prysm, or Lodestar.
Lighthouse
Nimbus
Teku
Prysm
Lodestar
Lighthouse is an Eth2.0 client with a heavy focus on speed and security. The team behind it, Sigma Prime, is an information security and software engineering firm who have funded Lighthouse along with the Ethereum Foundation, Consensys, and private individuals. Lighthouse is built in Rust and offered under an Apache 2.0 License.

4.1. Install rust dependency

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Enter '1' to proceed with the default install.
Update your environment variables.
echo export PATH="$HOME/.cargo/bin:$PATH" >> ~/.bashrc
source ~/.bashrc
Install rust dependencies.
sudo apt install -y git gcc g++ make cmake pkg-config libssl-dev

💡
4.2. Build Lighthouse from source

mkdir ~/git
cd ~/git
git clone https://github.com/sigp/lighthouse.git
cd lighthouse
git fetch --all && git checkout stable && git pull
make
In case of compilation errors, run the following sequence.
rustup update
cargo clean
make
This build process may take a few minutes.
Verify lighthouse was installed properly by checking the version number.
lighthouse --version

🎩
4.3. Import validator key

When you import your keys into Lighthouse, your validator signing key(s) are stored in the $HOME/.lighthouse/pyrmont/validators folder.
Run the following command to import your validator keys from the eth2deposit-cli tool directory.
Enter your keystore password to import accounts.
lighthouse account validator import --network pyrmont --directory=$HOME/eth2deposit-cli/validator_keys
Verify the accounts were imported successfully.
lighthouse account_manager validator list --network pyrmont
WARNING: DO NOT USE THE ORIGINAL KEYSTORES TO VALIDATE WITH ANOTHER CLIENT, OR YOU WILL GET SLASHED.

🔥
4.4. Configure port forwarding and/or firewall

Specific to your networking setup or cloud provider settings, ensure your validator's firewall ports are open and reachable.
  • Lighthouse beacon chain requires port 9000 for tcp and udp
  • eth1 node requires port 30303 for tcp and udp
Port Forwarding Tip: You'll need to forward and open ports to your validator. Verify it's working with https://www.yougetsignal.com/tools/open-ports/ or https://canyouseeme.org/ .

4.5. Start the beacon chain

🍰
Benefits of using systemd for your beacon chain
  1. 1.
    Auto-start your beacon chain when the computer reboots due to maintenance, power outage, etc.
  2. 2.
    Automatically restart crashed beacon chain processes.
  3. 3.
    Maximize your beacon chain up-time and performance.
🛠
Setup Instructions
Run the following to create a unit file to define yourbeacon-chain.service configuration.
cat > $HOME/beacon-chain.service << EOF
# The eth2 beacon chain service (part of systemd)
# file: /etc/systemd/system/beacon-chain.service
[Unit]
Description = eth2 beacon chain service
Wants = network-online.target
After = network-online.target
[Service]
User = $(whoami)
ExecStart = $(which lighthouse) bn --staking --validator-monitor-auto --metrics --network pyrmont
Restart = on-failure
[Install]
WantedBy = multi-user.target
EOF
****
🔥
Lighthouse Pro Tip: On the ExecStart line, adding the --eth1-endpoints flag allows for redundant eth1 nodes. Separate with comma. Make sure the endpoint does not end with a trailing slash or/ Remove it.
# Example:
--eth1-endpoints http://localhost:8545,https://nodes.mewapi.io/rpc/eth,https://mainnet.eth.cloud.ava.do,https://mainnet.infura.io/v3/xxx
💸
Find free ethereum fallback nodes at https://ethereumnodes.com/
Move the unit file to /etc/systemd/system
sudo mv $HOME/beacon-chain.service /etc/systemd/system/beacon-chain.service
Give it permissions.
sudo chmod 644 /etc/systemd/system/beacon-chain.service
Run the following to enable auto-start at boot time and then start your beacon node service.
sudo systemctl daemon-reload
sudo systemctl enable beacon-chain
sudo systemctl start beacon-chain
Nice work. Your beacon chain is now managed by the reliability and robustness of systemd. Below are some commands for using systemd.

🛠
Some helpful systemd commands

Check whether the beacon chain is active
sudo systemctl is-active beacon-chain
🔎
View the status of the beacon chain
sudo systemctl status beacon-chain
🔄
Restarting the beacon chain
sudo systemctl reload-or-restart beacon-chain
🛑
Stopping the beacon chain
sudo systemctl stop beacon-chain
🗄 Viewing and filtering logs
#view and follow the log
journalctl --unit=beacon-chain -f
#view log since yesterday
journalctl --unit=beacon-chain --since=yesterday
#view log since today
journalctl --unit=beacon-chain --since=today
#view log between a date
journalctl --unit=beacon-chain --since='2020-12-01 00:00:00' --until='2020-12-02 12:00:00'
The --metrics flag enables reporting on port 5054 and will be monitored with Prometheus.

🧬
4.6. Start the validator

Running the validator automatically with systemd.
🍰
Benefits of using systemd for your validator
  1. 1.
    Auto-start your validator when the computer reboots due to maintenance, power outage, etc.
  2. 2.
    Automatically restart crashed validator processes.
  3. 3.
    Maximize your validator up-time and performance.
🛠
Setup Instructions
Run the following to create a unit file to define yourvalidator.service configuration.
cat > $HOME/validator.service << EOF
# The eth2 validator service (part of systemd)
# file: /etc/systemd/system/validator.service
[Unit]
Description = eth2 validator service
Wants = network-online.target beacon-chain.service
After = network-online.target
[Service]
User = $(whoami)
ExecStart = $(which lighthouse) vc --network pyrmont --metrics
Restart = on-failure
[Install]
WantedBy = multi-user.target
EOF
Move the unit file to /etc/systemd/system and give it permissions.
sudo mv $HOME/validator.service /etc/systemd/system/validator.service
sudo chmod 644 /etc/systemd/system/validator.service
Run the following to enable auto-start at boot time and then start your validator.
sudo systemctl daemon-reload
sudo systemctl enable validator
sudo systemctl start validator
Nice work. Your validator is now managed by the reliability and robustness of systemd. Below are some commands for using systemd.

🛠 Some helpful systemd commands

✅ Check whether the validator is active
sudo systemctl is-active validator
🔎 View the status of the validator
sudo systemctl status validator
🔄 Restarting the validator
sudo systemctl reload-or-restart validator
🛑 Stopping the validator
sudo systemctl stop validator
🗄 Viewing and filtering logs
#view and follow the log
journalctl --unit=validator -f
#view log since yesterday
journalctl --unit=validator --since=yesterday
#view log since today
journalctl --unit=validator --since=today
#view log between a date
journalctl --unit=validator --since='2020-12-01 00:00:00' --until='2020-12-02 12:00:00'
Nimbus is a research project and a client implementation for Ethereum 2.0 designed to perform well on embedded systems and personal mobile devices, including older smartphones with resource-restricted hardware. The Nimbus team are from Status the company best known for their messaging app/wallet/Web3 browser by the same name. Nimbus (Apache 2) is written in Nim, a language with Python-like syntax that compiles to C.

4.1. Build Nimbus from source

Install dependencies.
sudo apt-get update
sudo apt-get install curl build-essential git -y
Install and build Nimbus.
mkdir ~/git
cd ~/git
git clone https://github.com/status-im/nimbus-eth2
cd nimbus-eth2
make NIMFLAGS="-d:insecure" nimbus_beacon_node
The build process may take a few minutes.
Verify Nimbus was installed properly by displaying the help.
cd $HOME/git/nimbus-eth2/build
./nimbus_beacon_node --help
Copy the binary file to /usr/bin
sudo cp $HOME/git/nimbus-eth2/build/nimbus_beacon_node /usr/bin

🎩
4.2. Import validator key

Create a directory structure to store nimbus data.
sudo mkdir -p /var/lib/nimbus
Take ownership of this directory and set the correct permission level.
sudo