--- title: "Running an Ethereum Node on OVHcloud Public instances" description: "Ethereum is quickly becoming known as one of the most efficient and flexible blockchain networks in the world, enabling financial organizations and individuals" url: https://docs.us.ovhcloud.com/en/public-cloud/compute/running-ethereum-node-ovhcloud-public-instances lang: en --- > For AI agents: the complete documentation index is available at https://docs.us.ovhcloud.com/en/llms.txt, the full documentation bundle is available at https://docs.us.ovhcloud.com/en/llms-full.txt. # Running an Ethereum Node on OVHcloud Public instances Ethereum is quickly becoming known as one of the most efficient and flexible blockchain networks in the world, enabling financial organizations and individuals alike to create smart contracts that can power the likes of decentralized finance (DeFi) applications and NFT ecosystems. Ethereum is one of the foundations of Web3, providing a decentralized, scalable, and secure network where builders can create the digital economy of the future. By the end of this guide, you will have a fully functional Ethereum node running on OVHcloud, following best practices for reliability and maintainability. The security hardening and operational best practices required to fully protect an Ethereum node are beyond the scope of this tutorial. Users are strongly advised to implement additional security measures — such as firewall configuration, key management, and monitoring — according to their organizational requirements and industry best practices. ## Requirements - A [Public Cloud Project](https://us.ovhcloud.com/public-cloud/) in your OVHcloud Control Panel #### OVHcloud Control Panel Access - **Direct link:** [Public Cloud Projects](https://manager.us.ovhcloud.com/#/public-cloud/pci/projects/) - **Navigation path:** `Public Cloud` > Select your project ## Instructions **Content Overview:** - [Launching an instance](#launching-an-instance) - [Adding storage](#adding-storage) - [Mounting the volume](#mounting-the-volume) - [Create a dedicated user](#create-a-dedicated-server) - [Ethereum preliminaries](#ethereum-preliminaries) - [Installing Nethermind (Execution Client)](#installing-nethermind-execution-client) - [Step 1: Add the Nethermind APT repository](#step-1-add-the-nethermind-apt-repository) - [Step 2: Update the package index](#step-2-update-the-package-index) - [Step 3: Install Nethermind](#step-3-install-nethermind) - [Installing Lighthouse (Consensus Client)](#installing-lighthouse-consensus-client) - [Step 1: Download the latest stable release](#step-1-download-the-latest-stable-release) - [Step 2: Extract the archive](#step-2-extract-the-archive) - [Step 3: Verify and move the binary](#step-3-verify-and-move-the-binary) - [Create the JWT secret file](#create-the-jwt-secret-file) - [Step 1: Create a secrets directory](#step-1-create-a-secrets-directory) - [Step 2: Generate the JWT token](#step-2-generate-the-jwt-token) - [Using screen for session persistence](#using-screen-for-session-persistence) - [Setting ownership for /mnt/chaindata](#setting-ownership-for-mnt-chaindata) - [Launching Nethermind (Execution Client)](#launching-nethermind-execution-client) - [Step 1: Create a screen session](#step-1-create-a-screen-session) - [Step 2: Run Nethermind](#step-2-run-nethermind) - [Step 3: Detach the session](#step-3-detach-the-session) - [Step 4: List active sessions (optional)](#step-4-list-active-sessions) - [Launching Lighthouse (Consensus Client)](#launching-lighthouse-consensus-client) - [Step 1: Create a new screen session](#step-1-create-a-new-screen-session) - [Step 2: Run Lighthouse beacon node](#step-2-run-lighthouse-beacon-node) - [Step 3: Detach the session](#h_01KP3PEFZT1B2K48W46HKGCRE4) - [Verifying synchronization between EL and CL](#verifying-synchronization-between-el-andcl) - [Step 1: Reattach to the Nethermind session](#h_01KP3CHNMFNJ8DYDMQHWGGPSPC) - [Step 2: Check for communication messages](#step-2-check-for-communication-messages) - [Conclusion](#conclusion) ### Launching an instance Select the `Instances` menu and click `+ Create an instance` to begin the provisioning process. **Note:** For an in-depth tutorial on creating an instance, see our [How to create a Public Cloud instance and connect to it](https://docs.us.ovhcloud.com/en/public-cloud/compute/getting-started.md#step-4-create-the-instance) guide. To run an Ethereum node reliably, the hardware specifications must meet the client software’s minimum requirements. According to the Ethereum Foundation documentation, an Ethereum node requires at least: - **Execution client**: 2 CPU cores, 16 GB of RAM, and 1 TB of fast SSD storage. - **Consensus client**: 2 CPU cores, 8 GB of RAM, and access to the same storage. While creating your instance, use the following specifications: - **Model:** `R2-30` For production environments and long-term stability, higher specifications are strongly recommended. In this tutorial, we will provision an instance with 2 vCores and 30 GB of RAM, which satisfies the minimum combined requirements for running both the execution and consensus clients on a single machine. - **Configure your instance:** Do **not** add a post-installation script. - **Configure your network:** `Public` This will assign the instance a public IP address and enable external connectivity, which is required for the node to participate in the Ethereum network. Next, choose your preferred **billing method** and click on `Create an instance` to launch the deployment process. OVHcloud will provision the server with the selected configuration, and within a few minutes, the instance will be available and running. At this point, your Ethereum node host environment is ready for initial access and further configuration. ### Adding storage The next step is to provision persistent storage for the Ethereum blockchain data. This volume will serve as the primary data store for the Ethereum chain, ensuring durability and scalability independent of the compute instance. In the OVHcloud Control Panel, navigate to `Block Storage` and click `+ Create a volume`. **Note:** For an in-depth tutorial on creating a Block Storage volume, see our [Creating and configuring an additional disk on an instance](https://docs.us.ovhcloud.com/en/storage-and-backup/block-storage/create-and-configure-an-additional-disk-on-an-instance.md) guide. While creating your Block Storage volume, use the following specifications: - **Region:** Choose the same region as the instance you created (above). This is essential to guarantee low-latency access and to allow the volume to be attached directly to your node without cross-region performance penalties. - **Volume type:** `high-speed-gen2` Running an Ethereum node requires **high-performance storage** due to the constant read and write operations needed to synchronize the blockchain and access block and state data. For this reason, we strongly recommend selecting a **High-Speed Gen2 volume**, which delivers the necessary throughput and input/output operations per second (IOPS) to ensure stable node performance. - **Volume capacity:** `2 TB` (minimum) Both the **Ethereum Execution Layer (EL) client** and the **Consensus Layer (CL) client** require significant disk capacity to store blockchain data, state, and historical records. A minimum of **2 TB of storage** is recommended to operate a full mainnet node reliably. When creating the block storage volume in OVHcloud, set the capacity to **2 TB** and select the **High-Speed Gen2** option to ensure sufficient performance for synchronization and long-term operation. Once all parameters have been configured — including the region, storage type, capacity, and name — click `Create the volume`. OVHcloud will provision the block storage resource, which will then be available to attach to your Ethereum node instance. #### Mounting the volume After the new volume appears as **available** in the OVHcloud Control Panel, attach it to your Ethereum node instance. To do this, open the _more options_ `...` menu next to the volume entry and select `Attach to instance`. From the list of instances, choose the node you previously created. The volume will then be linked to that instance and accessible as an additional block device. Now, establish a secure connection to your server via SSH. Use the following command from your local terminal, replacing `IPaddress` with the public IP assigned to your instance: ``` ssh -i ubuntu@IPaddress ``` By default, OVHcloud instances provisioned with the Ubuntu image create a user named **ubuntu**, which you should use for the initial connection. Authentication will be handled through the SSH key you configured during instance creation. Once connected to the instance, run the following command to list all available block devices: ``` lsblk ``` This will display a tree view of the system’s storage devices, including the root disk and the newly attached block storage volume. Identify the additional device (e.g., `/dev/sdb`) corresponding to the 2 TB volume you created above. This device will later be formatted and mounted to store the Ethereum blockchain data. Next, create a partition on the newly attached volume. Replace `/dev/sdb` with the device name identified in the previous step if it differs. Execute: ``` sudo fdisk /dev/sdb ``` This command will open the partitioning utility for the selected block device. From there, you can create a new primary partition that spans the entire disk. Once complete, the partition will typically be available as `/dev/sdb1`. Once the partition has been created (e.g., `/dev/sdb1`), format it with the **ext4** filesystem so it can be mounted and used by the operating system. Run the following command: ``` sudo mkfs.ext4 /dev/sdb1 ``` This will initialize the partition with an ext4 filesystem, which is a stable and widely supported choice for storing Ethereum chain data. Now, create a dedicated directory to serve as the mount point for the formatted volume, then mount it and verify that it has been successfully attached to the filesystem. Execute the following commands: ``` sudo mkdir -p /mnt/chaindata ``` ``` sudo mount /dev/sdb1 /mnt/chaindata ``` ``` df -h ``` - `mkdir -p /mnt/chaindata` creates the mount directory (using `-p` ensures no error if intermediate directories are missing). - `mount /dev/sdb1 /mnt/chaindata` mounts the formatted partition to the directory. - `df -h` displays all mounted filesystems in a human-readable format, allowing you to confirm that `/dev/sdb1` is correctly mounted at `/mnt/chaindata` with the expected capacity (approximately 2 TB). At this point, your disk is mounted and ready for use. However, the configuration is **not persistent**; if the server restarts, the volume will need to be mounted manually. To ensure the volume is mounted automatically at boot, we must configure it in the `/etc/fstab` file. First, retrieve the **UUID (Universally Unique Identifier)** of your volume by running: ``` sudo blkid ``` This command lists all block devices and their associated attributes. Identify the entry corresponding to your new partition (e.g., `/dev/sdb1`) and copy the value of its UUID field, which will be used in the fstab configuration. Next, edit the `/etc/fstab` file to configure the automatic mount. Open the file with your preferred text editor, for example: ``` sudo nano /etc/fstab ``` Then add the following line at the end of the file, replacing the UUID with the one obtained from the previous `blkid` command: ``` UUID=e4f9629b-e787-49b5-872c-1afcf0a397e9 /mnt/chaindata ext4 nofail 0 0 ``` This entry ensures that the partition will be mounted at `/mnt/chaindata` automatically on every system boot. The nofail option allows the system to continue booting even if the device is unavailable. Your storage volume is now fully configured and ready to be used for storing Ethereum blockchain data. With the automatic mount entry in place, the system will make the volume available at `/mnt/chaindata` on every reboot, ensuring a stable and persistent data directory for your node. ### Create a dedicated user Next, create a **dedicated user account** to manage all Ethereum node operations. This practice improves security by separating node processes from the default system user. Run the following commands: ``` sudo useradd -s /bin/bash -d /home/node_admin/ -m -G sudo node_admin ``` ``` echo 'node_admin:MySuperPassword123' | sudo chpasswd ``` ``` sudo mkdir -p /home/node_admin/.ssh ``` - `useradd` creates a new user named node\_admin, with a home directory, bash shell, and membership in the sudo group. - `chpasswd` sets an initial password for the new user (replace with a strong secret or configure key-based login). - `mkdir -p` creates the .ssh directory for SSH configuration in the user’s home directory. Now, configure **SSH key-based authentication** for the new user by adding your public SSH key to the authorized\_keys file. Replace the placeholder with your actual public key: ``` sudo sh -c "echo 'My-public-SSH-key' > /home/node_admin/.ssh/authorized_keys" ``` This command creates the authorized\_keys file under `/home/node_admin/.ssh/` and writes your public key into it, allowing secure, passwordless login as the `node_admin` user. ### Ethereum preliminaries Operating a fully functional Ethereum node requires the coordinated operation of two key software components: 1\. **Execution Client (EL)** – responsible for processing transactions and maintaining the Ethereum state. 2\. **Consensus Client (CL)** – responsible for reaching consensus with the rest of the network through the Ethereum proof-of-stake protocol. These two components must run in tandem and communicate securely to maintain synchronization with the Ethereum mainnet. The Ethereum ecosystem supports multiple client implementations, each developed independently but compliant with the Ethereum specification. The most widely used options include: **Execution Clients (EL):** - Geth - Nethermind - Reth - Besu - Erigon **Consensus Clients (CL):** - Lighthouse - Prysm - Teku - Nimbus - Lodestar For this guide, we will use the following combination: - **Execution Client**: Nethermind - **Consensus Client**: Lighthouse ### Installing Nethermind (Execution Client) #### Step 1: Add the Nethermind APT repository To install Nethermind via APT, begin by adding the official repository: ``` sudo add-apt-repository ppa:nethermindeth/nethermind ``` If the above command is not found, install the required tools first: ``` sudo apt-get install software-properties-common ``` #### Step 2: Update the package index Refresh your package list to include packages from the newly added repository: ``` sudo apt-get update ``` **Warning:** **NOTE:** This may take a few minutes depending on your system and network speed. #### Step 3: Install Nethermind Now install the Nethermind binary: ``` sudo apt-get install nethermind -y ``` ### Installing Lighthouse (Consensus Client) #### Step 1: Download the latest stable release Navigate to the Lighthouse GitHub Releases page and locate the **latest stable release**. **Note:** This tutorial was written using version 8.1.3. Use the following curl command to download the Lighthouse client binary archive: ``` curl -LO https://github.com/sigp/lighthouse/releases/download/v8.1.3/lighthouse-v8.1.3-x86_64-unknown-linux-gnu.tar.gz ``` #### Step 2: Extract the archive Once downloaded, extract the archive: ``` tar -xvf lighthouse-v8.1.3-x86_64-unknown-linux-gnu.tar.gz ``` This will place the lighthouse binary in your current directory. #### Step 3: Verify and move the binary Test the binary to ensure it is working: ``` ./lighthouse –-version ``` Move it to a directory included in your system’s $PATH for global access: ``` sudo cp lighthouse /usr/bin ``` ### Create the JWT secret file A shared JWT secret is required for secure, authenticated communication between the execution and consensus clients. #### Step 1: Create a secrets directory ``` sudo mkdir -p /secrets ``` #### Step 2: Generate the JWT token ``` openssl rand -hex 32 | tr -d "\n" | sudo tee /secrets/jwt.hex > /dev/null ``` You should now have the file /secrets/jwt.hex containing a 32-byte hexadecimal secret. ### Using screen for session persistence When running on a remote server (such as an OVH cloud instance), any disconnection from your SSH session will terminate running processes unless they are managed through tools like screen. Check if screen is installed: ``` screen –-version ``` If not installed: ``` sudo apt-get install screen ``` ### Setting ownership for /mnt/chaindata When running Ethereum clients (Nethermind and Lighthouse), the user executing the commands must have the necessary access to the data directory. To avoid permission issues and maintain security, you should assign ownership of the previously mounted directory to your current user. ``` sudo chown $USER:$USER /mnt/chaindata ``` This command sets the user and group ownership of /mnt/chaindata to the currently logged-in user. It ensures that you (and your Ethereum clients, if run under your user account) have full access to read, write, and modify files in this directory. Now we are ready to launch both the execution and consensus clients in **separate screen sessions** for persistent background operation. ### Launching Nethermind (Execution Client) #### Step 1: Create a screen session ``` screen -S nethermind ``` #### Step 2: Run Nethermind ``` nethermind -c mainnet \ --data-dir /mnt/chaindata/nethermind \ --JsonRpc.Enabled true \ --HealthChecks.Enabled true \ --HealthChecks.UIEnabled true \ --JsonRpc.EngineHost=127.0.0.1 \ --JsonRpc.EnginePort=8551 \ --JsonRpc.JwtSecretFile /secrets/jwt.hex ``` You should see logs indicating the client is running. Eventually, the message: ``` Waiting for Forkchoice message from Consensus Layer ``` will appear, indicating the execution client is waiting to pair with the consensus client. #### Step 3: Detach the session Press `Ctrl-a` then `d` to detach from the session and return to the main shell. #### Step 4: List active sessions (optional) ``` screen -ls ``` To reattach later: ``` screen -r nethermind ``` ### Launching Lighthouse (Consensus Client) #### Step 1: Create a new screen session ``` screen -S lighthouse ``` #### Step 2: Run Lighthouse Beacon Node ``` lighthouse bn \ --network mainnet \ --execution-endpoint http://127.0.0.1:8551 \ --execution-jwt /secrets/jwt.hex \ --checkpoint-sync-url https://mainnet.checkpoint.sigp.io \ --http \ --datadir /mnt/chaindata/lighthouse ``` After some initial setup, Lighthouse should begin syncing with the network. ### Step 3: Detach the session Use the same key combination: `Ctrl-a` then `d`. ### Verifying synchronization between EL and CL At this stage, both the **execution client** (Nethermind) and the **consensus client** (Lighthouse) should be running in separate screen sessions. To confirm that they are properly connected and the synchronization is underway, reattach to the Nethermind session and inspect the logs. #### Step 1: Reattach to the Nethermind session ``` screen -r nethermind ``` This command brings you back into the Nethermind screen session, where you can observe real-time logs. #### Step 2: Check for communication messages If Lighthouse is running and connected correctly, Nethermind’s logs should no longer display: ``` Waiting for Forkchoice message from Consensus Layer ``` Instead, you should see logs indicating that the **Engine API** communication has been established, and blocks are being processed. Look for messages like: ``` Received ForkChoice: ... Syncing... ``` These logs confirm that Nethermind is receiving block proposals and fork choice updates from Lighthouse, and that the node is syncing correctly with the Ethereum mainnet. ## Conclusion And you’re done! You have deployed a fully functional Ethereum node on OVHcloud. While this guide focused on the technical deployment, it is important to complement the setup with proper security hardening, monitoring, and maintenance practices to ensure long-term stability. With the foundation now in place, you can extend the node’s functionality, integrate it into larger infrastructures, or use it as a base for research, development, and staking operations. Browse all the [Compute guides](https://docs.us.ovhcloud.com/en/public-cloud/compute/landing-page-compute.md). Browse the rest of the [OVHcloud US documentation](https://docs.us.ovhcloud.com/en/index.md) for guides on our other products and services. Learn more about [Public Cloud Compute](https://us.ovhcloud.com/public-cloud/compute/) on the OVHcloud US website.