Dedicated Ethereum RPC Node Server

Bare metal servers provide dedicated hardware resources without virtualization overhead, delivering consistent performance, lower latency, and complete control over your Ethereum RPC infrastructure. You get predictable response times, no resource contention, and the ability to fine-tune hardware specifically for Ethereum’s requirements.

At RedSwitches, we provide optimized bare metal infrastructure and expertise to help you deploy and maintain high-performance Ethereum nodes for RPC operations or validator participation.

The hardware requirements for an Ethereum node include:

• CPU: High-performance, multi-core processor (16+ cores recommended, AMD EPYC preferred)
• RAM: Minimum 16GB, with 64GB ECC DDR4 recommended for optimal performance
• Storage: Large NVMe storage for growing blockchain data (2 x 3.84TB NVMe enterprise drives suggested)
• Network: Reliable high-speed connection with a minimum 10Gbps upload speed

Running your own Ethereum node requires technical expertise in setting up the right software stack on appropriate server hardware. 

Let’s start by taking a quick look at the suggested hardware.

Suggested Hardware:

• CPU: 16 cores or more (AMD EPYC preferred)
• RAM: 256GB ECC DDR4
• Storage: Minimum 2TB NVMe SSD for blockchain data
• Connectivity: Stable, high-speed link with bandwidth from 1Gbps to 100Gbps

Recommended OS: Ubuntu (22.04 LTS or latest stable version) or similar Linux distributions.

Process Overview

As a prerequisite, update the system packages, create a non-root user with sudo privileges for the Ethereum node operations. Additionally, review UFW rules and make sure the ports used by Geth and Prysm (TCP 30303, UDP 30303, UDP 12000, TCP 13000, TCP 22) are opened and accessible. 

Generate JWT 

start by creating the directories for storing the JWT secret with mkdir. Next, make sure the directories have appropriate permissions.

Create Data Directories

Create the directories for storing data for Geth and Prysm. These directories will contain the actual blockchain and log data. 

Install Geth 

If you haven’t already, start by updating the server packages. Add the Ethereum PPA and install Geth. Once the process finishes, update the package index again to make sure the system recognizes the Ethereum PPA. 

Next, create a systemd service file for the Geth background service. Finally, start the Geth service. Optionally, you can enable the service start at boot. 

Install & Configure Prysm

Create the appropriate directories and download the Prysm Beacon Chain client. Once the download finishes, create a systemd service file. Next, start the service and optionally enable the service start at the machine boot up. 

Performance and Security Tips:

• Keep software updated with the latest Ethereum client binaries
• Set up firewalls, use DDoS protection, and isolate RPC ports
• Regularly tune system parameters, file descriptors, and caching for RPC workloads

RedSwitches offers fully managed Ethereum RPC and validator nodes with pre-configured enterprise hardware, geo-optimized deployment, 24/7 support, and SLA-backed uptime guarantees.

What are the available Ethereum JSON-RPC API methods?

These methods facilitate programmatic interaction with an Ethereum node.

Account & State Information

eth_getBalance <address> <block_identifier>: Retrieves the balance of an account at a specific block.

eth_getCode <address> <block_identifier>: Retrieves the bytecode deployed at a contract address.

eth_getStorageAt <address> <position> <block_identifier>: Retrieves the value at a specific storage slot of a contract.

eth_getTransactionCount <address> <block_identifier>: Retrieves the number of transactions sent from an address (nonce).

eth_accounts: Retrieves a list of addresses owned by the client (primarily for node-controlled wallets, often not exposed on public RPCs).

eth_coinbase: Retrieves the client’s coinbase address (miner reward recipient).

eth_getProof <address> <storage_keys> <block_identifier>: Retrieves the Merkle proof for an account’s state, including its balance, nonce, code hash, and storage hash.

Transaction Information & Submission

eth_sendRawTransaction <signed_tx_data>: Submits a signed, RLP-encoded transaction to the network.

eth_getTransactionByHash <tx_hash>: Retrieves a transaction by its hash.

eth_getTransactionByBlockHashAndIndex <block_hash> <index>: Retrieves transaction by block hash and index.

eth_getTransactionByBlockNumberAndIndex <block_number> <index>: Retrieves transaction by block number and index.

eth_getTransactionReceipt <tx_hash>: Retrieves the receipt of a transaction (contains status, gas used, logs).

eth_pendingTransactions: Retrieves all transactions currently pending in the node’s queue.

Contract Interaction & Simulation

eth_call <transaction_object> <block_identifier>: Executes a message call or contract creation without changing the blockchain state (read-only).

eth_estimateGas <transaction_object>: Estimates the gas required to execute a transaction or contract call.

Blockchain & Block Information

eth_blockNumber: Retrieves the current block number on the longest chain.

eth_getBlockByHash <block_hash> <full_tx_objects>: Retrieves a block by its hash.

eth_getBlockByNumber <block_number> <full_tx_objects>: Retrieves a block by its number.

eth_getBlockTransactionCountByHash <block_hash>: Retrieves the number of transactions in a block by hash.

eth_getBlockTransactionCountByNumber <block_number>: Retrieves the number of transactions in a block by number.

eth_getUncleCountByBlockHashAndIndex <block_hash> <uncle_index>: Retrieves information about an uncle block by hash and index.

eth_getUncleByBlockNumberAndIndex <block_number> <uncle_index>: Retrieves information about an uncle block by number and index.

eth_getLogs <filter_object>: Retrieves a list of logs that match specific filter criteria.

Network & Node Status

net_version: Retrieves the current network ID (e.g., “1” for Mainnet, “3” for Ropsten).

net_listening: Checks if the client is actively listening for network connections.

net_peerCount: Retrieves the number of peers currently connected to the client.

eth_syncing: Reports the client’s synchronization status (returns an object if syncing, false otherwise).

eth_chainId: Retrieves the chain ID of the current network (EIP-155 compliant).

web3_clientVersion: Retrieves the current client (node) version string.

eth_protocolVersion: Retrieves the current Ethereum protocol version.

Gas & Fee Information

eth_gasPrice: Retrieves the current average gas price in Wei.

eth_maxPriorityFeePerGas: Retrieves an estimate for the priority fee (tip) needed for a transaction to be included in the next block (for EIP-1559).

eth_feeHistory <block_count> <newest_block> <reward_percentiles>: Retrieves historical gas prices and base fee/priority fee suggestions for a range of blocks.

Event Subscriptions & Filters (Live Data)

eth_subscribe <subscription_type> <params>: Subscribes to new block headers, pending transactions, or log events (requires WebSocket connection).

eth_unsubscribe <subscription_id>: Unsubscribes from an active subscription.

eth_newBlockFilter: Creates a filter that triggers on new blocks. (Polling)

eth_newPendingTransactionFilter: Creates a filter that triggers on new pending transactions. (Polling)

eth_newFilter <filter_options>: Creates a filter for logs matching specific criteria. (Polling)

eth_getFilterChanges <filter_id>: Retrieves changes (new blocks, transactions, or logs) since the last

getFilterChanges call for a specific filter. (Polling)

eth_getFilterLogs <filter_id>: Retrieves all logs for a specific filter ID. (Polling)

web3_sha3 <data>: Hashes data using Keccak-256.

For more information, please refer to the official Ethereum Documentation . 

At RedSwitches, we provide unlimited rate limits, sub-50ms response times, and 24/7 availability for our dedicated Ethereum RPC nodes. Our infrastructure is tuned specifically for high-volume API workloads, powering DeFi platforms, NFT marketplaces, and trading bots with consistent performance.

Our bare metal servers eliminate virtualization overhead, providing predictable latency and dedicated resources that scale with your application demands without performance degradation.