boringproxy VS rqlite

boringproxy - Designed to be very easy to use. No config files. Clients can be remote-controlled through a simple WebUI and/or REST API on the server.

A couple of years ago I've read about this concept (already forgot the name) of using self hosted data storage with cloud applications. Basically, you as a user own your data and only permit the cloud hosted web application to access it - not own it and manage in your place.

I was thinking of a similar concept, but in the context of mobile applications. The mobile application itself would be accessible via Google Play Store/App Store, but the backend part would be self hosted and upon opening the application you would have to specify how to access backend.

My question is how would I access the backend if it was hosted on let's say rpi running in the living room? It's not a problem as long as I'm within the home network, but I want seemless network transition without losing access when entering/leaving the house. I was told https://www.cloudflare.com/en-gb/products/zero-trust/access/ could be used for this, but to me it sounds a bit of an overkill to use it for an application which would never be used by more than a single digit amount of users. This looks more suitable: https://github.com/boringproxy/boringproxy

Finally, someone in the above project's Matrix room directed me towards boringproxy - https://github.com/boringproxy/boringproxy. This was the perfect solution. No lengthy config files, easy to use and automate. Setup took about an hour and now everything is back up and running. The only issue I've currently not been able to solve is one where the container seems to use a websocket, which keeps getting timed out (will investigate this further tomorrow).

boringproxy (GitHub) is my go-to for this sort of thing. Thanks for the announcement, I'll have to do a head-to-head and see how they stack up!

boringproxy

Am I the only one who thinks SQLite is still too complicated for many programs? Maybe it's just the particular type of software I normally work on, which tends towards small, self-hosted networking services[0] that would often have a single user, or maybe federated with <100 users. These programs need a small amount of state for things like tokens, users accounts, and maybe a bit of domain-specific things. This can all live in memory, but needs to be persisted to disk on writes. I've reached for SQLite several times, and always come back to just keeping a struct of hashmaps[1] in memory and dumping JSON to disk. It's worked great for my needs.

Now obviously if I wanted to scale up, at some point you would have too many users to fit in memory. But do programs at that scale actually need to exist? Why can't everyone be on a federated server with state that fits in memory/JSON? I guess that's more of a philosophical question about big tech. But I think it's interesting that most of our tech stack choices are driven by projects designed to work at a scale most of us will never need, and maybe nobody needs.

[0]: https://boringproxy.io/

[1]: https://github.com/boringproxy/boringproxy/blob/master/datab...

This is the commit that seems to have broken the docker image.

I use https://github.com/boringproxy/boringproxy

Seems like you could do the same with rqlite [1], since SQLite supports JSON.

[1]: https://rqlite.io

rqlite[1] creator here, happy to answer any questions about rqlite, this latest release, and how it works.

[1] https://rqlite.io

I found simple distributed RQlite https://github.com/rqlite/rqlite based on raft and sqlite. How hard is to add it?

rqlite[1] creator here, happy to answer any questions. rqlite also supports read-only nodes, which can also help with reads at the "edge". It probably wouldn't scale to 100s of nodes, it is an option.

"rqlite supports adding read-only nodes. You can use this feature to add read scalability to the cluster if you need a high volume of reads, or want to distribute copies of the data nearer to clients – but don’t want those nodes counted towards the quorum. These types of nodes are also known as non-voting nodes."

[1] https://rqlite.io/

[2] https://rqlite.io/docs/clustering/read-only-nodes/