SSDB VS mini-redis

I've used SSDB[0] in the past for some really stupid large datasets (20TB)_and it worked really well in production

[0] https://github.com/ideawu/ssdb

> Or wanting to shift the architecture entirely to avoid using memory-bound Redis as a queue with an overflow risk.

I wanted to use SSDB[1] instead of Redis for that reason, but it doesn't support the necessary data structures.

[1] https://github.com/ideawu/ssdb

There is also ssdb https://github.com/ideawu/ssdb

It's 2021 and we have extremely fast key-value lookups using LevelDB/RocksDB, but we're still using RAM-based caching tools [1] [2] [3]. It's time to consider RAM-based caching harmful, and start caching with SSDs for larger datasets and lower costs. For ex: SSDB [4]

[1] https://redis.io/

[2] https://memcached.org/

[3] https://news.ycombinator.com/item?id=29532552

[4] https://github.com/ideawu/ssdb#ssdb-vs-redis

Aside from this particular use-case, which is what most people here are talking about -- I had never heard of the SSDB project, but it interests me because I often use Redis for certain things it's able to do, aside from its in-memory storage, and sometimes the fact that the data is not stored on disk is a bit of a drawback for me, something I have to work around.

Hi, I'm trying to implement RESP with Rust (more like a mini-redis clone from tokio tutorial).

One project I found extremely easy to read and understand was mini-redis. Anything similar to that?

For learning async Rust, mini-redis repo is hard to surpass: https://github.com/tokio-rs/mini-redis

The code is simple enough for beginners to follow, but also complex enough to demonstrate Rust async in the wild. And best of all, the code is heavily commented!

You can follow the official Tokio tutorial to implement mini-redis incrementally: https://tokio.rs/tokio/tutorial/setup

for backend async service: https://github.com/tokio-rs/mini-redis

The official Tokio mini-Redis example has a well-documented example of shutting down worker tasks: https://github.com/tokio-rs/mini-redis/blob/master/src/shutdown.rs

Have a look at https://github.com/tokio-rs/mini-redis, written as an example of a modern rust application.

I sure learned a ton from looking at the mini-redis implementation from the tokio team https://github.com/tokio-rs/mini-redis -- especially when you want to work with tokio! I think it's remarkably well structured and documented.

If https://github.com/tokio-rs/mini-redis does not help answer your question, could you elaborate a bit more on your struggle and we can see if we can fit it into our docs.

Tokio async runtime for Rust has a tutorial in its user guide https://tokio.rs/tokio/tutorial on writing a mini-redis (https://github.com/tokio-rs/mini-redis).

You may be able to take inspiration from mini-redis, which is a learning resource created by the Tokio project. Its purpose is to show off many common patterns in async Rust, and a shared hashmap is one of them.