DPTCloud
Back to articles
Technology Insight

Building a High-Performance Decentralized Nostr Relay on a Budget Cloud Server

June 4, 2026

Introduction to the Decentralized Web and Nostr

The modern digital landscape is undergoing a massive shift toward decentralization. Centralized platforms, once the bedrock of global communication, increasingly face scrutiny over data privacy, censorship, and arbitrary governance. Amid this paradigm shift, Nostr (Notes and Other Stuff Transmitted by Relays) has emerged as a groundbreaking, open-source protocol designed to ensure censorship-resistant social networking.

Unlike traditional platforms where a single corporation manages the infrastructure, Nostr relies on a distributed network of independent servers called relays. These relays are responsible for accepting, storing, and distributing cryptographic events. Operating your own relay not only strengthens the resilience of the ecosystem but also grants you absolute control over your data distribution. This guide provides a detailed, technical walkthrough on how to build and maintain a high-performance Nostr relay using a budget, low-spec cloud server.

The Core Architecture of a Nostr Relay

Before diving into the deployment phase, it is essential to understand how a Nostr relay interacts with the broader network. Unlike a traditional database-driven web application, a Nostr relay does not authenticate users, handle complex business logic, or process heavy media files. Its primary responsibilities are lightweight yet highly concurrent:

  • WebSocket Connections: Relays maintain persistent, bi-directional WebSocket connections with clients to broadcast new events in real time.
  • Event Validation: Every incoming note or event must be verified against its cryptographic signature to ensure data integrity.
  • Efficient Querying: Relays filter and serve historical events based on specific subscription filters sent by clients.

Because the protocol is radically simple, a properly configured relay does not require massive computing power. However, running on a low-spec server (e.g., 1 vCPU and 1GB RAM) requires selecting an optimal, memory-efficient software implementation.

Selecting the Right Software Stack for Low-Spec Servers

Choosing the right relay implementation is the most critical decision when working with constrained hardware. While there are implementations written in Go, Python, and TypeScript, the optimal choices for low-spec servers are compiled languages known for minimal memory footprints and high concurrency.

1. Nostr-rs-relay (Rust)

Written in Rust, nostr-rs-relay is a highly efficient implementation that utilizes SQLite or PostgreSQL as its storage engine. It features robust event filtering, rate limiting, and whitelist/blacklist support. Its native memory management makes it an exceptional choice for servers with less than 1GB of RAM.

2. Khatru (Go)

Developed as a lightweight framework for building custom relays, Khatru offers extreme speed and low CPU utilization. It uses BadgerDB or SQLite, making it incredibly fast for read and write operations under heavy concurrent loads.

For this guide, we will focus on deploying nostr-rs-relay with an optimized SQLite backend due to its ease of configuration, structural simplicity, and minimal overhead.

Step-by-Step Deployment Guide

Step 1: Preparing the Server Environment

First, provision a basic Linux VPS running Ubuntu LTS. Once connected via SSH, update your system packages and install the necessary dependencies, including Docker and Docker Compose, which simplify container isolation and resource management.

sudo apt update && sudo apt upgrade -y
sudo apt install docker.io docker-compose -y

Step 2: Configuring nostr-rs-relay

Create a dedicated directory for your relay configuration and data storage. We will use a config.toml file to fine-tune the relay's behavior, ensuring it does not consume excessive memory.mkdir ~/nostr-relay && cd ~/nostr-relay nano config.toml

Inside the config.toml, implement strict limits to protect your low-spec hardware from denial-of-service (DoS) vectors:

[info]
relay_name = "My Budget Decentralized Relay"
description = "A lightweight Nostr relay running on minimalist infrastructure."

[limits]
max_event_size = 65536 # Limit event size to 64KB
max_ws_message_size = 131072
max_filters = 100
max_limit = 500

[database]
data_directory = "./data"
max_conn_pool = 4 # Restrict connection pool to conserve RAM

Step 3: Orchestrating with Docker Compose

Create a docker-compose.yml file to define the deployment structure. This configuration ensures that the relay automatically restarts if it encounters a critical error.

version: '3'
services:
  relay:
    image: scinfra/nostr-rs-relay:latest
    ports:
      - "8080:8080"
    volumes:
      - ./config.toml:/usr/src/app/config.toml
      - ./data:/usr/src/app/data
    restart: always

Launch the service by executing the following command:

docker-compose up -d

Optimizing Reverse Proxy and SSL Encryption

Exposing a raw WebSocket port directly to the public internet is insecure and inefficient. To handle SSL termination and optimize network traffic, we must implement a reverse proxy using Nginx.

Install Nginx and obtain a free TLS certificate via Let's Encrypt:

sudo apt install nginx certbot python3-certbot-nginx -y

Configure Nginx to upgrade standard HTTP traffic to secure WebSockets (WSS). Create a new site configuration file:

sudo nano /etc/nginx/sites-available/nostr

Insert the following block, replacing yourdomain.com with your actual domain:

server {
    server_name yourdomain.com;

    location / {
        proxy_pass [http://127.0.0.1:8080](http://127.0.0.1:8080);
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Enable the configuration and execute Certbot to automatically apply SSL protection:

sudo ln -s /etc/nginx/sites-available/nostr /etc/nginx/sites-enabled/
sudo systemctl restart nginx
sudo certbot --nginx -d yourdomain.com

Performance Tuning for Low-Spec Virtual Machines

To guarantee that your relay remains highly responsive on a low-spec cloud server, you must apply several kernel and database optimizations. Failure to do so may result in the Linux kernel's Out-Of-Memory (OOM) killer terminating your relay process during peak traffic.

1. Configure Swap Space

If your server only has 1GB of RAM, creating a swap file acts as an emergency memory buffer. To allocate a 2GB swap space, run:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

2. Optimize SQLite for High Concurrency

By default, SQLite locks the entire database during write transactions. To prevent read operations from being blocked, ensure your relay is running in WAL (Write-Ahead Logging) mode. The nostr-rs-relay binary handles this automatically, but maintaining the underlying storage on an SSD-backed cloud volume is highly recommended to minimize I/O wait times.

Monitoring and Long-Term Maintenance

Operating a decentralized infrastructure asset requires proactive monitoring. Keep a close eye on disk space utilization, as the Nostr network handles millions of global events daily. If you run an open relay without strict event limits, your storage will fill up rapidly.

To prevent storage exhaustion, consider creating an automated cron job that periodically prunes historical events older than 30 days, or switch your relay configuration to a private or whitelisted model where only designated pubkeys can publish data. You can view real-time operations and resource issues using basic Docker logging commands:

docker-compose logs --tail=100 -f

Conclusion

Building a decentralized Nostr relay on a budget cloud server proves that robust, censorship-resistant infrastructure does not require expensive data centers or massive capital investment. By selecting efficient software like Rust-based relays, optimizing connection pools, enforcing strict limits, and implementing proper Nginx reverse proxying, you can maintain a resilient node in the Nostr network for just a few dollars a month. Take control of your data routing today and actively contribute to the growth of the sovereign web.