DPTCloud
Back to articles
Technology Insight

Scaling Minimalism: Achieving High Availability with rqlite on 3 Ultra-Lightweight 1-vCPU VPS Nodes

June 4, 2026

Introduction: The High Availability Dilemma for Lean Infrastructure

In modern cloud architecture, achieving High Availability (HA) traditionally implies a significant financial and operational commitment. Standard distributed databases like CockroachDB, TiDB, or traditional MySQL/PostgreSQL clusters often demand multi-vCPU nodes, extensive memory pools, and complex clustering software to function reliably. For startups, edge computing deployments, and indie developers, this resource overhead can be cost-prohibitive.

Enter rqlite—an ultra-lightweight, distributed relational database built on top of SQLite and the Raft consensus protocol. By turning SQLite into a replicated, fault-tolerant system, rqlite allows you to build a highly available database cluster on hardware that would cause other distributed databases to stall. In this deep-dive guide, we will walk through the conceptual framework, architectural design, and step-by-step deployment of an rqlite HA cluster across three minimal 1-vCPU Virtual Private Servers (VPS).

Why rqlite? The Power of Distributed SQLite

SQLite is universally praised for its zero-configuration, single-file simplicity and blistering read speeds. However, its primary limitation has always been its localized nature; it is not inherently network-facing or distributed. rqlite bridges this gap perfectly.

By embedding the Raft consensus algorithm, rqlite ensures that every write operation is safely replicated across a quorum of nodes before being committed to the underlying SQLite database. Here is why it excels on ultra-lightweight 1-vCPU hardware:

  • Minimal Memory and CPU Footprint: Written in Go, rqlite compiles to a single, highly efficient binary. It lacks the heavy JVM or multi-layered abstractions of larger databases.
  • Production-Ready Consensus: The HashiCorp Raft implementation guarantees strict data consistency (CP in the CAP theorem).
  • Simplified Operations: No external dependencies, no complex configuration files, and an intuitive HTTP API for database interactions.

Architectural Blueprint: The 3-Node Quorum

To achieve true fault tolerance, distributed consensus systems require a majority of nodes to be operational. This mathematical requirement is defined as:

Quorum = floor(N/2) + 1

Where N is the total number of voting nodes in the cluster. A 3-node cluster provides the optimal entry-point for high availability, allowing the system to withstand the complete failure of exactly one node without interrupting service or losing data integrity.

For this architecture, we will utilize three distinct 1-vCPU VPS instances, preferably distributed across different availability zones or data centers to prevent localized hardware failures from compromising the entire cluster. Let us designate our nodes as follows:

  • Node 1: 192.168.1.10 (Initial Leader/Bootstrap Node)
  • Node 2: 192.168.1.11 (Follower Node)
  • Node 3: 192.168.1.12 (Follower Node)

Step-by-Step Deployment Guide

Step 1: System Preparation and Firewall Configuration

Before installing rqlite, ensure your 1-vCPU systems are updated and that the firewall allows communication across the cluster. rqlite typically uses two distinct ports:

  1. 4001: For the HTTP API (client-to-node communication).
  2. 4002: For Raft consensus (node-to-node communication).

Execute the following commands on all three nodes to open these ports using UFW (Uncomplicated Firewall):

sudo ufw allow 4001/tcp
sudo ufw allow 4002/tcp
sudo ufw reload

Step 2: Downloading and Installing rqlite

Because rqlite is a static binary, installation is trivial. Download the latest release, extract it, and move it to your system path. Run these commands on all nodes:

wget [https://github.com/rqlite/rqlite/releases/download/v8.0.0/rqlite-v8.0.0-linux-amd64.tar.gz](https://github.com/rqlite/rqlite/releases/download/v8.0.0/rqlite-v8.0.0-linux-amd64.tar.gz)
tar -xvf rqlite-v8.0.0-linux-amd64.tar.gz
sudo mv rqlite-v8.0.0-linux-amd64/rqlited /usr/local/bin/
sudo mv rqlite-v8.0.0-linux-amd64/rqlite /usr/local/bin/

Step 3: Bootstrapping Node 1 (The Cluster Seed)

On the first VPS (192.168.1.10), launch the initial node. We instruct the binary to bind to its public/private network interface so other nodes can discover it:

rqlited -node-id node1 \
  -http-addr 192.168.1.10:4001 \
  -raft-addr 192.168.1.10:4002 \
  ~/.rqlite

The database will initialize a new Raft log and elect itself as the leader, waiting for peers to join.

Step 4: Joining Node 2 and Node 3 to the Cluster

On the second VPS (192.168.1.11), execute the start command while explicitly passing the -join flag pointing to Node 1:

rqlited -node-id node2 \
  -http-addr 192.168.1.11:4001 \
  -raft-addr 192.168.1.11:4002 \
  -join [http://192.168.1.10:4001](http://192.168.1.10:4001) \
  ~/.rqlite

Repeat this step on the third VPS (192.168.1.12), ensuring the node ID is unique:

rqlited -node-id node3 \
  -http-addr 192.168.1.12:4001 \
  -raft-addr 192.168.1.12:4002 \
  -join [http://192.168.1.10:4001](http://192.168.1.10:4001) \
  ~/.rqlite

Once executed, Node 1 will process the join requests, replicate its current state to the new peers, and establish a healthy 3-node consensus group.

Verifying Cluster Health and Failover Mechanics

To ensure your cluster is operating correctly, use the built-in rqlite CLI tool from any node to query the status:

rqlite -h 192.168.1.10:4001
192.168.1.10:4001> .status

Look closely at the store section of the output. You should verify that num_peers is reported as 2, and the cluster state is active.

Testing Fault Tolerance

To truly appreciate the value of high availability, simulate a catastrophic node failure. Terminate the rqlited process on Node 1 (the initial leader). If you run a status check on Node 2 or Node 3, you will observe that the remaining two nodes immediately notice the leader's absence, initiate a new election cycle, and promote one of themselves to the leader position within milliseconds. The database remains fully writable and readable, seamlessly absorbing the outage.

Performance and Production Best Practices

While rqlite runs beautifully on 1-vCPU VPS configurations, production deployments should incorporate a few structural optimizations to maximize stability:

  • Use Systemd Services: Wrap your rqlited execution commands in systemd service units to guarantee automatic recovery if the underlying process crashes or the VPS reboots.
  • Prioritize Disk I/O: Raft relies heavily on disk synchronization (fsync) to guarantee durability. Opt for VPS providers that utilize fast NVMe storage, even on low-tier 1-vCPU plans.
  • Implement an Edge Load Balancer: Place a lightweight load balancer like HAProxy or Nginx in front of your cluster. Configure it to route write requests dynamically or utilize rqlite's automatic client-side redirection capabilities.

Conclusion

Achieving fault-tolerant, high-availability database infrastructure no longer requires substantial financial investments or bloated hardware stacks. By pairing the elegant design of rqlite with cost-efficient 1-vCPU cloud instances, engineering teams can deploy resilient, production-grade architectures at a fraction of the traditional cost. Whether you are powering a distributed IoT system, a geo-replicated configuration store, or a microservice ecosystem, rqlite offers an uncompromised path to lightweight resilience.