How to Run a Pi Coin Node on a Cloud Server with Linux

If your PC can’t run Docker or containers due to hardware limitations, don’t worry! You can still participate in the Pi Network by setting up a Pi Coin node on a cloud server with Linux. This tutorial walks you through the process step-by-step, from installing Docker to monitoring your node’s ports. Let’s get started, and Run a Pi Coin Node !

Why Use a Cloud Server for Your Pi Coin Node?

Running a Pi Coin node on a cloud server is a great solution for users with underpowered PCs or those who want 24/7 uptime. Cloud providers like AWS, Google Cloud, Hetzner or DigitalOcean offer scalable Linux servers perfect for this task.

Prerequisites for Running a Pi Node on a Cloud Server

• A cloud server with Ubuntu/Debian-based Linux (e.g., Ubuntu 20.04 or later).

• Root or sudo access to the server.

• Basic knowledge of SSH and terminal commands.

Step 1: Install Docker on Your Cloud Server

For Ubuntu/Debian-based systems:

• Update system packages:

bash

sudo apt update && sudo apt upgrade -y

• Install Docker:

bash

sudo apt install docker.io -y

• Enable Docker to start on boot:

bash

sudo systemctl enable docker  

• Verify the installation:

bash

docker --version

Example Output: Docker version 20.10.x, build xxxxxxx

Step 2: Install Docker Compose (Optional)

Step 3: Pull the Pi Coin Node Docker Image

Step 4: Launch Your Pi Node Container

Step 5: Verify Your Pi Node is Running

Running Pi Node Container

Step 6: Monitor Port Activity with a Custom Script

Use this shell script (summarize_ports.sh) to monitor ports 31400-31409:

bash

#!/bin/bash  
echo "=== Port Summary (31400-31409) ==="  

get_packet_data() {  
    sudo iptables -L -v -n | grep ":$1" | awk '{print $1}' | head -n 1  
}  

get_latest_block() {  
    docker exec pi-node stellar-core --c info | grep "Ledger" | grep "seq" | awk '{print $3}'  
}  

get_connection_data() {  
    incoming=$(netstat -an | grep ":$1" | grep -c "ESTABLISHED")  
    outgoing=$(netstat -an | grep ":$1" | grep -c "SYN_SENT")  
    echo "$incoming,$outgoing"  
}  

latest_block=$(get_latest_block)  
echo "Latest Block: $latest_block"  

for port in {31400..31409}; do  
    connections=$(netstat -an | grep ":$port" | wc -l)  
    states=$(netstat -an | grep ":$port" | awk '{print $NF}' | sort | uniq -c | awk '{print $2 ": " $1}' | tr '\n' ', ')  
    packets=$(get_packet_data "$port")  
    packets=${packets:-0}  
    connection_data=$(get_connection_data "$port")  
    incoming=$(echo "$connection_data" | awk -F',' '{print $1}')  
    outgoing=$(echo "$connection_data" | awk -F',' '{print $2}')  

    if [ "$connections" -gt 0 ]; then  
        echo "Port: $port, Connections: $connections, Incoming: $incoming, Outgoing: $outgoing, States: ${states%, }, Packets: $packets"  
    else  
        echo "Port: $port, Connections: 0, Incoming: 0, Outgoing: 0, Packets: 0"  
    fi  
done  

1. Save it: nano summarize_ports.sh.

2. Make it executable: chmod +x summarize_ports.sh.

3. Run it: ./summarize_ports.sh.

Terminal output showing port summary for ports 31400-31409

Step 7: Test Connectivity to Pi Node Ports

Test ports with Netcat:

bash

nc -zv <yourserver> 31400-31409  

Or install and use Nmap:

bash

sudo apt install nmap -y  
nmap -Pn <yourserver> -p 31400-31409  

Step 8: Manage Firewall Rules with IPTables

Step 9: Troubleshoot Connectivity Issues

Step 10: Use Webmin to Manage Firewall Rules (Optional)

Key Observations When Monitoring Your Pi Node

The First Day of Running Pi Node

Summary: Tools and Commands for Pi Node Management

Command	Purpose
./summarize_ports.sh	Monitor port activity and connections
nc -zv <IP> <ports>	Test external connectivity
sudo iptables -L -v -n	Check firewall rules
docker logs pi-node	View node logs
tcpdump -i any port <port>	Capture real-time traffic

Ready to Run your Pi Coin Node on Cloud Server? Start today and join the Pi Network!

---

How to Link Your Mobile Pi Network Account with WinSCP via a Cloud Server

Important Note: Pi Network does not provide a direct method to "link" your mobile account with WinSCP, as it’s a mobile app, and WinSCP is a tool for file management on a server. However, you can use WinSCP to connect to your cloud server running a Pi Node and manage files related to your node. If you need to transfer mobile account data (e.g., your wallet passphrase), this requires manual steps.

Step 1: Prepare Your Cloud Server

1. Ensure your Pi Coin node is running on the cloud server with Linux, as outlined in the tutorial (see "Step 4: Launch Your Pi Node Container").

2. Obtain your cloud server’s IP address (e.g., from your provider’s dashboard, such as DigitalOcean or AWS).

3. Confirm SSH access is enabled on the server (port 22 is typically open by default).

   
   

Step 2: Install WinSCP on Your Computer

1. Download WinSCP from the official website (https://winscp.net) and install it on your Windows computer.

2. Launch WinSCP after installation.

   
   

Step 3: Connect to the Cloud Server Using WinSCP

1. Open WinSCP and select "New Site."

2. Enter the following details:

   • File Protocol: Choose SFTP (or SCP if preferred).

   • Host Name: Input your cloud server’s IP address.

   • Port Number: Leave as 22 (default SSH port).

   • Username: Enter your server’s username (e.g., root or a custom user).

   • Password: Provide the server password, or leave blank if using an SSH key.

   • Private Key (Optional): If using an SSH key (.ppk file), specify it under "Advanced" > "SSH" > "Authentication."

3. Click "Login" to connect. You’ll see your server’s file system in the WinSCP interface.

   
   

Step 4: Locate Pi Node Files on the Server

1. Navigate to the directory where your Pi Node data is stored. Based on the tutorial, this is likely:

   /root/Pi-Network/docker_volumes/testnet_2/stellar/core/etc

   This is the volume mounted in the Docker container (-v flag in the docker run command).

2. These files include configuration data for your Pi Node, such as stellar-core settings.

   
   

Step 5: Linking Your Mobile Account (Manual Process)

• First, download and install the Pi Node application on your PC.

• When you launch it for the first time and log in, it will create a folder where all data is stored: C:\Users\YOUR_USERNAME\AppData\Roaming\Pi Network

• This folder contains all the essential data that the Pi Node uses.

• Use a tool like WinRAR or 7-Zip to compress the Pi Network folder into a .zip file.

• Simply drag the .zip file from your PC and drop it into the desired directory on the server.

• Navigate to the directory where you uploaded the .zip file.

• Use this command to unzip the file:

bash

unzip your_file_name.zip

• Replace your_file_name.zip with the actual name of your zipped file

• After unzipping, make sure the unzipped contents are in the correct directory for the node to function.

• If you encounter any issues, double-check file permissions and paths.

• Security Warning: Never store sensitive data like passphrases unencrypted. Use encryption tools (e.g., GPG) if needed.

Step 6: Verify and Test

• Use WinSCP to check the Pi Node logs:

• Navigate to the Docker logs (not directly accessible via WinSCP, but you can SSH into the server and run docker logs pi-node to troubleshoot).

• Alternatively, copy logs to a viewable directory with:

bash

docker logs pi-node > /root/pi_data/pi_node_logs.txt

• Then download pi_node_logs.txt via WinSCP.

• Ensure your node is running (docker ps) and ports 31400-31409 are active.

  
  

Why This Matters

Using WinSCP, you can manage your Pi Node’s files and potentially integrate mobile account data manually. This is critical if you’re troubleshooting, backing up, or syncing your node with your Pi Network identity. However, Pi Network’s node software and mobile app don’t have a built-in "link" feature—WinSCP simply bridges the gap by giving you file-level access to your server.