Rigel Group Software Engineering

Light a FUSE under your Riak cluster

As an experiment, we hacked together a FUSE driver in Ruby that lets you mount your Riak cluster as a file system, and browse around. Not sure how really useful it is, but was fun to do nonetheless.

If your Riak keys look like /foo/bar/logo.png, you will be able to ls and cd around the (simulated) directory structure, and cat files (keys).

Things get even more interesting if you hook this up with jsawk, then you can do things like this if your keys contain JSON values:

cat /mnt/riak/users/* | jsawk 'if (this.city != "Paris") return null'

The current implementation does a list keys function when you access a bucket, which of course is slow. We put all the keys into a tree structure and cache that for performance. Another fun project would be to rewrite it using Riak's Links to simulate the directory structure, and then run interactive map/reduce jobs to navigate the hierarchy. That will have to wait for another time...

Anyway, check it out yourself at Github, just keep in mind it is a toy and should not be pointed at a cluster you care about.

Hydra attacks Riak cluster

The great thing about querying a Riak cluster is that it's all just HTTP, so the huge universe of tools that are available to work with HTTP resources are at your disposal. For example, lets say we want to quickly request 20 keys from a Riak cluster. We could use curl or curb and request them one at a time, or we could use the multi-headed hydra that is Typhoeus to get them concurrently! Let's see this monster in action with a little Ruby code:

require 'rubygems'
require 'typhoeus'
require 'yajl'
 
HOST = "riak.cluster.com"
PORT = "8098"
 
# bucket is the name of a Riak bucket
# keys is an array of keys to get
# returns array of response hashes with the keys, :key :code :headers :body
def multi_get(bucket, keys)
  hydra = Typhoeus::Hydra.new
  @responses = []
  keys.each do |key|
    url = "http://#{HOST}:#{PORT}/riak/#{bucket}/#{key}"
    request = Typhoeus::Request.new(url)
    # When the request completes, this block gets run
    request.on_complete do |response|
      result = {}
      result[:key] = key
      result[:code] = response.code
      result[:headers] = response.headers
      result[:body] = response.body
      @responses << result
    end
    # queue up the request to run later
    hydra.queue request
  end
  # This is a blocking call that executes all queued requests concurrently, 
  # and returns when all requests have completed
  hydra.run
  @responses
end
 
# OK, lets try this baby out now,
# first, set up the list of keys we want to get
keys = YAML::load(&lt;&lt;EOT)
---
- 1244idS1NaricUO2RtXJrjcfzr8
- 12ktMhh8KZOCYzMIRTLlqf5JeGA
- 129Izkjd6Fh2i1zqxCE2acT6iju
- 129AomedyZIa3gjudjCxpke5kU9
- 12BEfyiKWPqwZqiqcKGmizVN34i
- 12EZagKQHnakkIChE3ruLUu4TrA
- 12RBVtZV0EwQyTixXFLwHHqwLuK
EOT
 
# Now let the Hydra out!
rs = multi_get("my_bucket", keys)
 
# Or, if you are storing JSON objects, get the results as JSON using the speedy Yajl gem...
rs = multi_get("my_bucket", keys).map{|r| Yajl::Parser.parse(r[:body])}

As you can see, it's pretty darn easy to leverage all the great work by the Typhoeus folks to speed up your queries.

Map/Reduce job to select specific keys

Riak will politely tell you about all the keys in a specific bucket, all you need to do is ask, like this:

curl http://localhost:8098/riak/my_bucket

The problem is what if you have a million keys? You can tell Riak to stream you the keys, but what if you only want certain keys, like all the keys that start with foo, for example. In that case, MapReduce is your friend. In Ruby, it looks like this:

results = Riak::MapReduce.new(client)
               .add("my_bucket")
               .map("function(value,keyData,arg) { 
                       var re = new RegExp(arg);
                       return value.key.match(re) ? [value.key] : []; 
                     }", :keep => true, :arg => "^foo").run

You can pass in any regular expression in the :arg parameter. Since keys in Riak have to be unique, you will never get duplicates and don't need a reduce phase.

Update: Note that this code is pretty slow to execute on a bucket with many keys, so is best used in background jobs, not for interactive queries. For example, on a single node, small EC2 instance, with 10,000 JSON objects (3K each in size) in a bucket, running the above map reduce code takes 60 seconds.

To see how much of that time is spent marshaling the JSON objects, we removed the JSON body of each object and left only the key, and then ran the code again, which took 30 seconds, still not even in the right ballpark for interactive use. Of course, YMMV.

Using Nginx as a front-end for Riak

One of the very cool things about Riak is that you dont need any type of connection pooling, and that any Riak node can answer any request. This config sets up Nginx to act as a load balancer between all of your Riak nodes, so you send your queries to Nginx, and it will distribute the requests out evenly to all of your nodes. It will also only allow simple GET requests, so no one can change or add data, or use the map/reduce functionality (to prevent DOS attacks on the Riak cluster).