Distributed patterns you should know by Eric Redmond

Watch the talk here: https://vimeo.com/68757697/settings

Transcript

1. DISTRIBUTED PATTERNS YOU SHOULD KNOW Eric Redmond @coderoshi http://git.io/MYrjpQ Tuesday, May 28, 13
2. Tuesday, May 28, 13
3. Tuesday, May 28, 13
4. Tuesday, May 28, 13
5. h  =  NaiveHash.new(("A".."J").to_a) tracknodes  =  Array.new(100000) 100000.times  do  |i|    tracknodes[i]  =  h.node(i) end h.add("K") misses  =  0 100000.times  do  |i|    misses  +=  1  if  tracknodes[i]  !=  h.node(i) end puts  "misses:  #{(misses.to_f/100000)  *  100}%" misses:  90.922% Tuesday, May 28, 13
6. 0 2160/2 2160 a single partition SHA1(Key) ring with 32 partitions Node 0 Node 1 Node 2 Tuesday, May 28, 13
7. 0 2160/2 2160 a single partition ring with 32 partitions Node 0 Node 1 Node 2 Node 3 SHA1(Key) Tuesday, May 28, 13
8. SHA1BITS  =  160 class  PartitionedConsistentHash    def  initialize(nodes=[],  partitions=32)        @partitions  =  partitions        @nodes,  @ring  =  nodes.clone.sort,  {}        @power  =  SHA1BITS  -­‐  Math.log2(partitions).to_i        @partitions.times  do  |i|            @ring[range(i)]  =  @nodes[0]            @nodes  <<  @nodes.shift        end        @nodes.sort!    end    def  range(partition)        (partition*(2**@power)..(partition+1)*(2**@power)-­‐1)    end    def  hash(key)        Digest::SHA1.hexdigest(key.to_s).hex    end    def  add(node)        @nodes  <<  node        partition_pow  =  Math.log2(@partitions)        pow  =  SHA1BITS  -­‐  partition_pow.to_i        (0..@partitions).step(@nodes.length)  do  |i|            @ring[range(i,  pow)]  =  node        end    end    def  node(keystr)        return  nil  if  @ring.empty?        key  =  hash(keystr)        @ring.each  do  |range,  node|            return  node  if  range.cover?(key)        end    end end h  =  PartitionedConsistentHash.new(("A".."J").to_a) nodes  =  Array.new(100000) 100000.times  do  |i|    nodes[i]  =  h.node(i) end puts  "add  K" h.add("K") misses  =  0 100000.times  do  |i|    misses  +=  1  if  nodes[i]  !=  h.node(i) end puts  "misses:  #{(misses.to_f/100000)  *  100}%\n" misses:  9.473% Tuesday, May 28, 13
9. class  Node    def  initialize(name,  nodes=[],  partitions=32)        @name  =  name        @data  =  {}        @ring  =  ConsistentHash.new(nodes,  partitions)    end    def  put(key,  value)        if  @name  ==  @ring.node(key)            puts  "put  #{key}  #{value}"            @data[  @ring.hash(key)  ]  =  value        end    end    def  get(key)        if  @name  ==  @ring.node(key)            puts  "get  #{key}"            @data[@ring.hash(key)]        end    end end Tuesday, May 28, 13
10. nodeA  =  Node.new(  'A',  ['A',  'B',  'C']  ) nodeB  =  Node.new(  'B',  ['A',  'B',  'C']  ) nodeC  =  Node.new(  'C',  ['A',  'B',  'C']  ) nodeA.put(  "foo",  "bar"  ) p  nodeA.get(  "foo"  )      #  nil nodeB.put(  "foo",  "bar"  ) p  nodeB.get(  "foo"  )      #  "bar" nodeC.put(  "foo",  "bar"  ) p  nodeC.get(  "foo"  )      #  nil Tuesday, May 28, 13
11. Tuesday, May 28, 13
12. Tuesday, May 28, 13
13. Client Service Request Reply Tuesday, May 28, 13
14. module  Services    def  connect(port=2200,  ip="127.0.0.1")        ctx  =  ZMQ::Context.new        sock  =  ctx.socket(  ZMQ::REQ  )        sock.connect(  "tcp://#{ip}:#{port}"  )        sock    end    def  service(port)        thread  do            ctx  =  ZMQ::Context.new            rep  =  ctx.socket(  ZMQ::REP  )            rep.bind(  "tcp://127.0.0.1:#{port}"  )            while  line  =  rep.recv                msg,  payload  =  line.split('  ',  2)                send(  msg.to_sym,  rep,  payload  )          #  EVVVIILLLL!!!            end        end    end    def  method_missing(method,  *args,  &block)        socket,  payload  =  args        payload.send(  "bad  message"  )  if  payload    end end Tuesday, May 28, 13
15. class  Node    include  Configuration    include  Threads    include  Services    def  start()        service(  config("port")  )        puts  "#{@name}  started"        join_threads()    end    def  remote_call(name,  message)        puts  "#{name}  <=  #{message}"        req  =  connect(config("port",  name),  config("ip",  name))        resp  =  req.send(message)  &&  req.recv        req.close        resp    end    #  ... Tuesday, May 28, 13
16.    #  ...    def  put(socket,  payload)        key,  value  =  payload.split('  ',  2)        socket.send(  do_put(key,  value).to_s  )    end    def  do_put(key,  value)        node  =  @ring.node(key)        if  node  ==  @name            puts  "put  #{key}  #{value}"            @data[@ring.hash(key)]  =  value        else            remote_call(node,  "put  #{key}  #{value}"  )        end    end Tuesday, May 28, 13
17. Tuesday, May 28, 13
18. Tuesday, May 28, 13
19. Publisher Subscriber Subscriber Subscriber Tuesday, May 28, 13
20. class  Node    #  ...    def  coordinate_cluster(pub_port,  rep_port)        thread  do            ctx  =  ZMQ::Context.new            pub  =  ctx.socket(  ZMQ::PUB  )            pub.bind(  "tcp://*:#{pub_port}"  )            rep  =  ctx.socket(  ZMQ::REP  )            rep.bind(  "tcp://*:#{rep_port}"  )            while  line  =  rep.recv                msg,  node  =  line.split('  ',  2)                nodes  =  @ring.nodes                case  msg                when  'join'                    nodes  =  (nodes  <<  node).uniq.sort                when  'down'                    nodes  -­‐=  [node]                end                @ring.cluster(nodes)                pub.send(  "ring  "  +  nodes.join(','))                rep.send(  "true"  )            end        end    end Tuesday, May 28, 13
21. class  Node    #  ...    def  track_cluster(sub_port)        thread  do            ctx  =  ZMQ::Context.new            sub  =  ctx.socket(  ZMQ::SUB  )            sub.connect(  "tcp://127.0.0.1:#{sub_port}"  )            sub.setsockopt(  ZMQ::SUBSCRIBE,  "ring"  )                        while  line  =  sub.recv                _,  nodes  =  line.split('  ',  2)                nodes  =  nodes.split(',').map{|x|  x.strip}                @ring.cluster(  nodes  )                puts  "ring  changed:  #{nodes.inspect}"            end        end    end Tuesday, May 28, 13
22. Tuesday, May 28, 13
23. Tuesday, May 28, 13
24. Tuesday, May 28, 13
25.    def  replicate(message,  n)        list  =  @ring.pref_list(n)        results  =  []        while  replicate_node  =  list.shift            results  <<  remote_call(replicate_node,  message)        end        results    end Tuesday, May 28, 13
26. Tuesday, May 28, 13
27. Tuesday, May 28, 13
28. Tuesday, May 28, 13
29. WHAT TO EAT FOR DINNER? • Adam wants Pizza {value:"pizza", vclock:{adam:1}} • Barb wants Tacos {value:"tacos", vclock:{barb:1}} • Adam gets the value, the system can’t resolve, so he gets bolth [{value:"pizza", vclock:{adam:1}}, {value:"tacos", vclock:{barb:1}}] • Adam resolves the value however he wants {value:"taco pizza", vclock:{adam:2, barb:1}} Tuesday, May 28, 13
30. #  artificially  create  a  conflict  with  vclocks req.send('put  1  foo  {"B":1}  hello1')  &&  req.recv req.send('put  1  foo  {"C":1}  hello2')  &&  req.recv puts  req.send("get  2  foo")  &&  req.recv sleep  5 #  resolve  the  conflict  by  decending  from  one  of  the  vclocks req.send('put  2  foo  {"B":3}  hello1')  &&  req.recv puts  req.send("get  2  foo")  &&  req.recv Tuesday, May 28, 13
31. Tuesday, May 28, 13
32. Tuesday, May 28, 13
33. Tuesday, May 28, 13
34. 1. 2. 3. 4. Tuesday, May 28, 13
35. Tuesday, May 28, 13
36. MERKEL TREE • A tree of hashes • Periodically passed between nodes • Differences are “repaired” Tuesday, May 28, 13
37. Tuesday, May 28, 13
38. array    =  [{value:1},{value:3},{value:5}] mapped  =  array.map{|obj|  obj[:value]} #  [1,  3,  5] mapped.reduce(0){|sum,value|  sum  +  value} #  9 Tuesday, May 28, 13
39. Tuesday, May 28, 13
40. module  Mapreduce    def  mr(socket,  payload)        map_func,  reduce_func  =  payload.split(/\;\s+reduce/,  2)        reduce_func  =  "reduce#{reduce_func}"        socket.send(  Reduce.new(reduce_func,  call_maps(map_func)).call.to_s  )    end    def  map(socket,  payload)        socket.send(  Map.new(payload,  @data).call.to_s  )    end    #  run  in  parallel,  then  join  results    def  call_maps(map_func)        results  =  []        nodes  =  @ring.nodes  -­‐  [@name]        nodes.map  {|node|            Thread.new  do                res  =  remote_call(node,  "map  #{map_func}")                results  +=  eval(res)            end        }.each{|w|  w.join}        results  +=  Map.new(map_func,  @data).call    end end Tuesday, May 28, 13
41. module  Mapreduce    def  mr(socket,  payload)        map_func,  reduce_func  =  payload.split(/\;\s+reduce/,  2)        reduce_func  =  "reduce#{reduce_func}"        socket.send(  Reduce.new(reduce_func,  call_maps(map_func)).call.to_s  )    end    def  map(socket,  payload)        socket.send(  Map.new(payload,  @data).call.to_s  )    end    #  run  in  parallel,  then  join  results    def  call_maps(map_func)        results  =  []        nodes  =  @ring.nodes  -­‐  [@name]        nodes.map  {|node|            Thread.new  do                res  =  remote_call(node,  "map  #{map_func}")                results  +=  eval(res)            end        }.each{|w|  w.join}        results  +=  Map.new(map_func,  @data).call    end end Tuesday, May 28, 13
42. 200.times  do  |i|    req.send(  "put  2  key#{i}  {}  #{i}"  )  &&  req.recv end req.send(  "mr  map{|k,v|  [1]};  reduce{|vs|  vs.length}"  ) puts  req.recv Tuesday, May 28, 13
43. 200.times  do  |i|    req.send(  "put  2  key#{i}  {}  #{i}"  )  &&  req.recv end req.send(  "mr  map{|k,v|  [1]};  reduce{|vs|  vs.length}"  ) puts  req.recv Tuesday, May 28, 13
44. Tuesday, May 28, 13
45. WHAT WE’VE DONE SO FAR • Distributed, Replicated, Self-healing, Conflict-resolving, Eventually Consistent Key/Value Datastore... with Mapreduce http://git.io/MYrjpQ Tuesday, May 28, 13
46. Distributed Hash Ring Vector Clocks Preference List Merkle Tree Read Repair Key/Value CRDT (coming) Node Gossip Request/ Response Tuesday, May 28, 13
47. basho http://github.com/coderoshi/little_riak_book http://pragprog.com/book/rwdata @coderoshi Tuesday, May 28, 13
48. I am the very model of a distributed database, I've information in my nodes residing out in cyber space, While other datastorers keep consistent values just in case, It's tolerant partitions and high uptime, that I embrace. Tuesday, May 28, 13
49. I use a SHA-1algorithm, one-sixty bits of hashing space consistent hash ensures k/v's are never ever out of place, I replicate my data across more than one partition, In case a running node or two encounters decommission. Tuesday, May 28, 13
50. My read repairs consistently, at least it does eventually, CAP demands you've only 2 to choose from preferentially, In short, you get consistency or high availability, To claim you can distribute and do both is pure futility. Tuesday, May 28, 13
51. A system such as I is in a steady tiff with Entropy, since practically a quorum is consistent only sloppily, My favorite solutions are both read repair and AAE, My active anti-entropy trades deltas via Merkel Tree. Tuesday, May 28, 13
52. After write, the clients choose their conflict resolution, With convergent replicated data types are a solution: I only take a change in state, and not results imperforate, And merge results to forge a final value that is proximate. Tuesday, May 28, 13
53. How to know a sequence of events w/o employing locks, Well naturally, I use Lamport logic ordered vector-clocks. I have both sibling values when my v-clocks face a conflict, and keep successive values 'til a single one is picked. Tuesday, May 28, 13
54. If values are your query goal then write some mapreduces. Invert-indexing values may reduce query obtuseness. Distributing a graph or a relation-style structure, though somewhat possible provides a weaker juncture. Tuesday, May 28, 13
55. For data of the meta kind, my ring state is a toss up, To keep in sync my nodes will chat through protocol gossip. I am a mesh type network, not tree/star topological, their single points of failure make such choices most illogical. Tuesday, May 28, 13
56. My network ring is just the thing, ensuring writes are quick, But know that CAP demands my choice give only 2 to pick. In short, I get consistency or high availability, To claim I could distribute and do both is just futility. Tuesday, May 28, 13