Redis (consistent hashing based) sharding made easy | Hacker News Reader

Redis (consistent hashing based) sharding made easy

emre.github.io

31 pointsemre-yilmaz23 comments

> Q: What about data invalidation if I move servers, change the config etc.

> A: It's minimum. At least better than: Node = Hash(key) MOD N

Seriously?

Redis is not just a cache. Let me repeat that. Redis is not just a cache. Lots of people use Redis as a primary data store. If Redis is your primary data store, you can't afford to have any of your keys invalidated, ever. "Minimum" might be good enough when you're talking to Memcached, but it's not enough when you're taking to Redis.

Consistent hashing has been a solved problem for a long time if you can afford to misplace a few keys from time to time, which will happen every time a node is added to or removed from the pool. There are Redis client libraries implementing consistent hashing in nearly every language, and most of them work just fine if you use Redis as a cache or if your pool size never changes. Solving this problem again isn't particularly interesting.

What really would be interesting is a server that sits between Redis nodes and clients and intelligently moves keys from one node to another in the background so that no key is ever invalidated even when the pool size changes. I believe that project is called Redis Cluster or something. That might be worth an extra TCP connection. But right now, I'm not seeing why I should prefer Redis-Router to any tried-and-true client library with built-in lossy consistent hashing.

What you're describing sounds a lot like mongodb - it has the server (mongos) that sits between the client and the upstream databases (mongod) and stores metadata about where data is located, and it moves that data around based on shard keys.

Unfortunately it's the weakest part of mongodb.

okay, tell me a python library comes with consistent hashing?

(for the record = HASH(key) MOD N is not 'consistent hashing'.)

redis-router is just a library that wraps redis-py with consistent-hashing. nothing more.

I use it in production heavily since it solves the client-side sharding problem for me. When I wrote this, there was no trustable client library comes with consistent-hashing.

I don't know what do you want to see actually. "saving the world" is a todo though. wait for the new releases. you might like it. :)

> okay, tell me a python library comes with consistent hashing?

Nydus uses the same Ketama algorithm that you use, but I suppose it might not have had that feature when you started to work on Redis Router.

Also, pretty much every up-to-date client library in nearly every popular language, such as PHP, Ruby, C#, and Java.

I'm not complaining about the fact that you created a neat Python library for Redis. My complaint is about the standalone server feature. I don't see why it's needed because nearly every popular language has native libraries that implement consistent hashing (not HASH MOD N), often using the exact same algorithm you're using. So I went looking for bells and whistles that might justify the standalone server, and unfortunately I found none.

> Redis is not just a cache. Let me repeat that. Redis is not just a cache. Lots of people use Redis as a primary data store. If >Redis is your primary data store, you can't afford to have any of your keys invalidated, ever. "Minimum" might be good enough when > you're talking to Memcached, but it's not enough when you're taking to Redis.

"minimum" is enough for the people who use redis for cache, since a lot of people use it for just, plain, simple, old "caching".

Nowhere is it suggested that this is suitable for uses where you need durability. In fact if you are looking for a library for consistent hashing, I'd assume you'd understand the drawbacks (invalidation on resize).

Have you a point other than ranting that this isn't a unicorn? It really bothers me that this is the top comment at the moment.

My point is that I don't see much reason to run a server the sole purpose of which is to perform consistent hashing. I have no complaints about using the client library as part of a Python program. Actually, apologies to OP because I didn't realize that this is like the first Redis client library in Python with consistent hashing built in.

But a standalone server to talk to other languages such as PHP? Why would I want to add yet another TCP connection, yet another point of failure, and yet another protocol to my software stack when PHP's very own Predis, for example, does consistent hashing just fine while talking to Redis directly? Many other languages like Ruby, Java, and C#/.NET also have Redis clients that support consistent hashing. Sorry Pythonists, everyone else has been having fun with turnkey consistent hashing for 3-4 years already.

Lossless sharding came to mind immediately as a possible benefit of a middle layer, because Redis users have been asking for something like that for ages. When someone says "Redis" and "sharding" in the same breath, I'm sure a lot of people will think "Finally, a way to distribute my larger-than-RAM dataset across multiple machines!" After all, durability is a big deal when it comes to Redis. I'm sorry if my comment came across as rude, but I was honestly quite disappointed because my expectations were probably too high.

See also: Twitter's Twemproxy (http://github.com/twitter/twemproxy)

another good alternative: https://github.com/disqus/nydus

The "abstract" text (copied from the Wikipedia page) lacks the variable names, making the text incomprehensible:

When a hash table is resized and consistent hashing is used, only keys need to be remapped on average, where is the number of keys [...]

it should end "only K/n keys need to be remapped on average, where K is the number of keys [...]". Just thought I'd point this out so it could get fixed, should only take a few seconds to edit.

thanks! https://github.com/emre/redis-router/commit/0d9307436e4c3b69...

Somewhat off-topic, but just wondering: is anyone using consistent hashing for their DB masters? Every setup I've seen uses a manual sharding table.

Yes, and it works fine as long as you accept that data will need to be migrated at some point when you run out of memory and/or instances.

To put this off as long as possible, you can max out the memory in your boxes and use a large number of servers - 100s in some cases - running on those servers, hopefully with less than 1 per CPU core to maximize performance.

Then if you begin maxing out memory, you can easily split those servers onto their own hardware. My calculations showed that would allow scaling to trillions of keys without problems.

The TCP server example shows a different protocol than the default redis protocol. (As I could not install it correctly I couldn't try it.) If this is the case current redis client libraries cannot be used.

Hello,

Redis accepts both a structured protocol, and a simple space-separated tokens protocol (called the inline protocol) that helps sysadmins to avoid a disaster just because they lack a proper redis-cli but are in need to run a Redis command ASAP. Perhaps this proxy is also supporting both forms.

You can do that with any modern enough Redis server:

    Escape character is '^]'.
    ping
    +PONG
    set foo bar
    +OK
    get foo
    $3
    bar

I know of that simple protocol. But the responses in the example telnet session on that side return "True" and "13" where it should be "+OK" and ":13" with the redis protocol.

good point...

It doesn't support like this. It seems easy to implement it like that though. I will do it when I have free time.

What was the problem for installation?

I use redis-router in production as a library. some of my non-pythoneer friends asked to use it in PHP, so I made a little wrapper with gevent.

It's probably not compatible with current clients. Needs testing :)

Had problems installing "ketama".

I re-read the README now and it explicitely states that libketama should be installed from the git repository. I'll try it again later.

The servers are returning the output of the redis-py library, which maps returned values from redis into python objects (hashes -> dicts etc).

I had a quick look but I don't see an easy way to have redis-py pass forward the raw return values, though I think it could be done with some effort. So this isn't a drop in proxy for a redis server just yet.

Edit: referring to the TCP/HTTP Servers above, the library itself can be used as a drop in replacement for redis-py in python.

It seems like you've tried to support the set/store (sinterstore, sdiffstore, etc) methods across multiple instances in a non-atomic way - won't that lead to potential data loss?

Yes, these methods are dangerous to use.

I need a locking mechanism to do it safely but this will wait until I need it most likely.

Reply on news.ycombinator.com