How to Run a Sui Node [Sui Node Requirements]

For those who want to go beyond simply using Sui and become active participants in its ecosystem, running your own Sui node is essential. Whether you're a developer, validator, or power user, Sui's architecture makes the experience smooth and efficient. In this guide, I’ll show you how to run a Sui node. We’ll simplify every step, making managing and setting up a Sui node accessible whether you're a beginner or an experienced user.

#What is Sui?

The Sui blockchain is a next-generation Layer 1 platform designed for speed, scalability, and developer-friendly smart contracts. Unlike older blockchains that struggle with congestion and high fees, Sui takes a radically different approach with its parallel execution model — imagine a multi-lane highway instead of a single-file road.

#What is a Sui Node?

A Sui node is your direct connection to the Sui network, acting as a server that syncs with the blockchain to maintain the latest ledger state and enforce consensus rules. It's the foundational tool for developers, validators, and users who want to engage with Sui beyond just making transactions.

#Key Roles of a Sui Node

For Developers: Build and test dApps locally, or deploy smart contracts without depending on external services.

For Validators: Secure the network and earn staking rewards by processing transactions.

For Power Users: Interact with the blockchain directly, ensuring transparency and independence.

Thanks to Sui's parallel processing architecture, running a Sui node is more efficient than on traditional blockchains. It handles transactions simultaneously, reducing hardware strain and sync times.

#How to become a Sui Validator?

Becoming a Sui validator offers a unique opportunity to earn rewards while helping secure one of the fastest-growing blockchains.

Unlike energy-intensive proof-of-work networks, Sui's delegated proof-of-stake (DPoS) system makes validation more accessible, but don't underestimate the hardware requirements.

To run a competitive Sui validator node, you'll need:

• High-performance processors to handle parallel transaction processing

• Ample RAM for seamless operation during network congestion

• Fast SSD Storage to keep up with blockchain synchronization

While the hardware demands are significant, they're far more reasonable than traditional mining rigs. In the following sections, we'll break down exactly what you need and walk you through the complete process of setting up your validator node.

#Sui Node Requirements

Running a competitive Sui validator requires enterprise-grade hardware to handle the network's parallel processing demands. Based on Sui's official documentation, here are the exact specifications you'll need:

CPU: 24 physical cores (48 vCPUs)

RAM: 128GB DDR4

Storage: 4TB NVMe SSD (sustained high IOPS)

Network: 1Gbps dedicated bandwidth

For this guide, we'll use Cherry Servers' pre-built SOLANA SERVER GEN4 - specifically optimized for high-performance blockchain workloads. Here's the hardware specifications:

Processor: AMD EPYC 9254 (24C/48T @ 3.8GHz base, 5nm architecture) Memory: 384GB DDR5 @ 4800MHz (expandable to 1152 GB) Storage: 2×1TB NVMe (OS and hot storage)/ 2×4TB NVMe (blockchain data, RAID configurable) Security: AMD Infinity Guard + IPMI 2.0 remote management Network: 3Gbps, 100TB /mo free traffic + DDoS protection

Performance Advantages for Sui Validation:

• Precision Matching: 24 physical cores exactly meet Sui's validator requirements
• Memory Bandwidth: DDR5 delivers 1.5× more throughput than minimum DDR4 specs
• Storage Flexibility: Dual-tier NVMe setup separates OS from chain data

#Note for Other Providers:

If using other chosen provider, ensure your server hardware provides:

• True physical cores (not virtual/logical cores)

• NVMe storage with sustained IOPS > 500k

• DDR4/DDR5 memory with ECC protection

• Dedicated (not shared) network bandwidth.

#How to Run a Sui Node: Step-by-Step

Running a Sui validator node requires precise configuration to handle the network's parallel processing demands. In this section we will walk you through every critical stage:

1. Server Deployment
2. Node Installation & Configuration
3. Validator Activation

#Stage 1: Server Deployment

• Select and deploy server (we've used a pre-configured "SOLANA SERVER GEN4")
• Configure Options:
  • OS: Ubuntu 22.04 LTS (pre-installed)
  • Storage: RAID 1 for 4TB NVMe
• Deploy:
  • Click "Deploy Now" (takes ~15 minutes)
  • Credentials sent via email:
    • IPv4 address
    • Root password
    • Server ID

#Stage 2: Node Installation & Configuration

#Step 1: Access Your Server

Before installing Sui, ensure you can securely access your server instance. Open a terminal and connect via SSH:

ssh root@your_server_ip

Note: Replace your_server_ip with the IPv4 address from Cherry servers confirmation email.

Once logged in, update your system packages to ensure all dependencies are current and secure:

apt update && apt upgrade -y

#Step 2: Create a sui user (Recommended for security)

Running services under a dedicated user minimizes security risks. Create a sui user and grant sudo privileges:

sudo adduser sui
sudo usermod -aG sudo sui
su - sui

#Step 3: Install Dependencies

Sui requires several core packages to function properly. Install them with the following command:

sudo apt-get install curl git-all cmake gcc libssl-dev pkg-config libclang-dev libpq-dev build-essential

Key Packages:

• cmake & gcc - Essential build tools for compiling Rust and Sui binaries
• libssl-dev - Enables secure cryptographic operations (TLS/SSL) for node communication
• pkg-config - Helps the system locate library dependencies during compilation
• libclang-dev - Required for the Move compiler (Sui's smart contract language)
• libpq-dev - PostgreSQL development files (used for Sui's database backend)
• build-essential - A meta-package that includes critical compilers and libraries

Since Sui is built with Rust, you must also install the latest Rust toolchain:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env

#Step 4: Download the Sui Node Binary

Fetch the latest Sui node binary from the official releases. Replace $SUI_SHA with the current version (check the Sui Discord or announcements for the latest testnet release).

For this guide, we'll use Testnet v1.46.1 (SHA: 68a866b8d63e62ff628f11e45e4adea170d97107)

wget https://releases.sui.io/$SUI_SHA/sui-node -O ~/sui-node

#Step 5: Prepare the Node Directory Structure

Organize your node files for better management and security:

sudo mkdir -p /opt/sui/{db,config,bin,key-pairs}
sudo chown -R sui:sui /opt/sui
mv ~/sui-node /opt/sui/bin/
chmod +x /opt/sui/bin/sui-node

#Step 6: Generate Required keys

Before we generate the keys, we need to make sure you have the Sui CLI installed with keytool support. Here's how to get it set up:

cargo install --locked --git https://github.com/MystenLabs/sui.git --branch testnet --features tracing sui

Why testnet? We're using the testnet branch because that's what this guide focuses on, but you could replace testnet with mainnet if needed.

After installation, let's verify everything worked:

sui --version

Understanding Validator Keys Your Sui validator needs four special keys to function properly:

1. Protocol Key (BLS12-381) - Used for consensus
2. Account Key (Ed25519) - Controls validator staking and rewards
3. Network Key (Ed25519) - Secures peer-to-peer communication
4. Worker Key (Ed25519) - Handles worker operations

Generating Your Keys Generate each key with the following commands:

sui keytool generate bls12381
sui keytool generate ed25519
sui keytool generate ed25519
sui keytool generate ed25519

After each command, you'll see output showing your address and public key - make sure to save this information somewhere safe! You'll need these details later.

Organizing Your Key Files Here's where things get a bit messy by default. When you check your directory, you'll see files with crazy names like: bls-0xf83e7eb88873eac46f243cf6a467a8e3d22e3fbfc90004aa33.key

Let's clean this up! We'll rename them to something more sensible:

mv bls-0xf83e7eb88873eac46f243cf6a467a8e3d22e3fbfc90004aa33.key protocol.key

Do the same for your other keys, naming them:

• account.key
• network.key
• worker.key

Now let's move these to a safer location and lock down their permissions:

mv *.key /opt/sui/key-pairs/
chmod 600 /opt/sui/key-pairs/*.key

Your /opt/sui/key-pairs/ directory should now have:

• protocol.key
• account.key
• network.key
• worker.key

#Step 7: Restoring a Sui Full Node from Snapshots

Let's be honest - syncing a node from genesis is like watching paint dry. It takes forever, eats up your bandwidth, and honestly? It's completely unnecessary when we've got perfectly good snapshots available.

You can download a recent snapshot and be up and running in a fraction of the time. That's exactly what we're going to do here.

Get the Sui-Tool First, we'll grab the snapshot tool. We're using the same trusted version (commit 68a866b) that matched our validator setup earlier:

cd $HOME && \
wget https://sui-releases.s3-accelerate.amazonaws.com/68a866b8d63e62ff628f11e45e4adea170d97107/sui-tool && \
chmod +x sui-tool && \
sudo mv sui-tool /opt/sui/bin/sui-tool

Pro Tip: Always check the Sui Discord for the latest commit hashes - they update frequently!

Download the Database Snapshot We'll use the tool to fetch the latest testnet snapshot (change to mainnet if needed):

/opt/sui/bin/sui-tool download-db-snapshot \
  --latest \
  --network testnet \
  --path /opt/sui/db/authorities_db \
  --num-parallel-downloads 50

Parameters:

• --latest - Grabs the most recent snapshot available
• --network testnet - Specifies the network (use mainnet for production)
• --path /opt/sui/db/authorities_db - Where to save the snapshot data
• --num-parallel-downloads 50 - Turbocharges your download with 50 simultaneous connections
• --no-sign-request - Bypasses AWS signature requirements for faster access

Important: Make sure your /opt/sui/db directory:

• Has enough space (check with df -h)
• Is owned by your sui user (chown -R sui:sui /opt/sui/db)

For a 4TB SSD, this typically takes 2 hours depending on your connection. Grab some coffee ☕

After your snapshot download completes, there's one crucial step to make it operational:

Step 1. Navigate to your database directory:

cd /opt/sui/db/authorities_db

Step 2. Locate the epoch folder and rename for proper node recognition:

mv epoch_0 live

• The live folder is where Sui nodes expect to find current chain data
• Without this rename, your node won't recognize the downloaded snapshot
• This ensures a smooth transition when starting your node

Downloading the Genesis Blob

Every Sui node needs its starting point, that's where the genesis blob comes in. Think of it as the "origin story" for your blockchain data. Here's how to get it properly set up:

Step 1. Navigate to your config directory:

cd /opt/sui/config

Step 2. Download the testnet genesis blob:

curl -fLJO https://github.com/MystenLabs/sui-genesis/raw/main/testnet/genesis.blob

If you're setting up a mainnet node instead, simply replace testnet with mainnet in the URL. Always double-check you're using the right network's genesis file!

Download and set up the configuration file

Step 1. Download the default validator template from Sui's Github repository:

wget https://raw.githubusercontent.com/MystenLabs/sui/main/config/validator.yaml -O /opt/sui/config/validator.yaml

Step 2. Edit the configuration file using vim or your preferred text editor:

vim /opt/sui/config/validator.yaml

Make the following adjustments:

• Update all file paths to point to /opt/sui/ (e.g., db-path: /opt/sui/db/authorities_db)
• Insert the keys you generated earlier in their respective fields

Save the file and exit.

Launching your Sui Node

Now that everything's configured, we can launch our node. We'll do this properly so you can monitor progress while keeping it running securely in the background.

Opening the Network port

First, we need to unblock the metrics port so you can check your node's health:

sudo ufw allow 9184/tcp

This opens port 9184 specifically for the metrics endpoint - crucial for monitoring but keeps other ports locked down for security.

Starting the Node with Tmux

We'll use tmux to keep your node running even if your SSH session disconnects.

Step 1. First, create a new tmux session:

tmux new -s sui-node

Step 2. Now launch your node inside this session:

/opt/sui/bin/sui-node --config-path /opt/sui/config/validator.yaml

Step 3. Detach from the tmux session by pressing: Ctrl+B followed by D

(You'll see a message confirming you've detached)

Verifying your Node Health While your node syncs in the background, you can check its progress:

curl http://localhost:9184/metrics | grep current_epoch

#Stage 3: Validator Activation

Now that your node is running smoothly, let's get you officially recognized as a validator on the Sui network. This process has two key phases: first becoming a validator candidate, then joining the active validator set.

#Phase 1: Registering as a Validator Candidate

Before you can validate transactions, you need to introduce yourself to the network with your metadata and configuration:

sui client call \
  --package 0x3 \
  --module sui_system \
  --function request_add_validator_candidate \
  --args 0x5 \
    {protocol_pubkey_bytes} \
    {network_pubkey_bytes} \
    {worker_pubkey_bytes} \
    {proof_of_possession} \
    "Your Validator Name" \
    "Short description of your service" \
    "https://your-validator-logo.png" \
    "https://your-project-website.com" \
    {net_address} \
    {p2p_address} \
    {primary_address} \
    {worker_address} \
    {gas_price} \
    {commission_rate} \
  --gas-budget 10000

Key Preparation Notes:

1. Metadata Matters: Your name, description, and URLs help delegators identify your service
2. Address Configuration: Ensure your network addresses are correct and publicly accessible
3. Proof of Possession: Generate this using your protocol key with sui keytool generate-proof-of-possession

#Phase 2: Meeting Staking Requirements

Before joining the active set, you need sufficient stake:

• Minimum: 30M SUI in your staking pool
• Grace Period: If below 20M SUI, you have 7 epochs (~7 days) to recover
• Immediate Removal: Below 15M SUI removes you at epoch end

#Phase 3: Joining the Validator Set

Once your staking pool reaches 30M SUI, make it official:

sui client call \
  --package 0x3 \
  --module sui_system \
  --function request_add_validator \
  --args 0x5 \
  --gas-budget 10000000

What Happens Next:

• Your validator will enter the set at the next epoch boundary (every 24 hours)
• Start earning staking rewards immediately
• Your node will begin participating in consensus

#Pro Tips for New Validators:

1. Monitor Your Status:

sui client validators

2. Stay Active:

• Keep your node online 24/7
• Respond to governance proposals
• Update your metadata for visibility

3. Essential Maintenance:

• Regularly check your gas price survey
• Keep software updated
• Monitor your peer connections

#Sui Staking Rewards

Now that you're an active validator, let's talk about the sweet part, staking rewards. These rewards come from two main sources: transaction gas fees and stake subsidies. Here's how it all works.

#How Rewards Are Calculated

Every epoch (24 hours), Sui distributes rewards to validators and their delegators based on:

1. Gas Fees - Every transaction on Sui pays gas fees. These fees pile up and get distributed as rewards at the end of each epoch.
2. Stake Subsidies - Early in Sui's lifecycle, an extra 10% of SUI tokens are set aside to boost rewards. Eventually, this subsidy will run out, and gas fees alone will fund rewards.

The total rewards per epoch are simply: Total Rewards = Gas Fees + Stake Subsidies

#How Rewards Are Distributed

• Validators earn commission fees (a percentage cut) from their staking pool
• Delegators (people who stake with you) get the remaining rewards, proportional to their stake

This means:

• If you run a validator, you get extra rewards from commissions
• If you're a delegator, you earn passive income just for staking

#What Affects Your Rewards?

• Gas Price - Higher gas prices = bigger rewards
• Stake Amount - More stake in your pool = more rewards (but with diminishing returns if the pool gets too big)
• Commission Rate - Validators set their own %, but too high might discourage delegators

#When Do Rewards Arrive?

Rewards are automatically compounded into your staked SUI at the end of each epoch. You don't need to manually claim them, they just grow over time.

#Conclusion

Congratulations! You've now got a fully functional Sui validator node running on enterprise-grade hardware. Let's recap what you've accomplished:

• Deployed optimized server infrastructure
• Configured all necessary cryptographic keys
• Bootstrapped using the latest network snapshot
• Activated validator participation

Where to Go From Here:

1. Monitor your node's performance with:

sui client validators | grep YOUR_VALIDATOR_NAME

2. Join the Sui Validator Discord for real-time support
3. Consider setting up monitoring with Prometheus/Grafana
4. Stay updated with Sui's GitHub Releases

Remember, running a validator is an ongoing process. Regular maintenance and updates will ensure you continue earning optimal staking rewards while helping secure the Sui network.

Happy validating!