How Flickr delivers Real-Time Push Notifications using Node.js and Redis

push notifications are, of course, nothing new. recently, joshua cohen at the flickr blog described flickr's process for delivering real-time push notifications using node.js and redis.

flickr's decisions about the underlying architecture centered around four considerations; their push notifications had to have:

• minimal impact on normal page serving times.
  
• near-real-time delivery.
  
• deliver thousands of notifications per second.
• highly available underlying services.
  

event generation and targeting

they found that their existing push infrastructure was insufficient. the devs found, though, that they could use redis for event generation and targeting:

the event generation phase happens while processing the response to a user request. as such, we wanted to ensure that there was little to no impact on the response times as a result. to ensure this was the case, all we do here is a lightweight write into a global redis queue... everything after this initial redis action is processed out of band by our deferred task system and has no impact on site performance.

message delivery

they built their message delivery using node.js:

flickr’s web-serving stack is php, and, up until now, everything described has been processed by php. unfortunately, one area where php does not excel is long-lived processes or network connections, both of which make delivering push notifications in real time much easier. because of this we decided to build the final phase, message delivery, as a separate endpoint in node.js.

so, the question arose: how do we get messages pending delivery from these php workers over to the node.js endpoints that will actually deliver them? for this, we again turned to redis, this time using its built in pub/sub functionality.

scalability

dividing the workload across individual node.js processes, they published. each message to the redis pub/sub channel as a sharded channel.

whenever we need to add more processing power to the cluster, we can just add more servers and more shards. this also makes it easy to pull hosts out of rotation for maintenance without impacting message delivery: we simply reconfigure the remaining processes to subscribe to additional channels to pick up the slack.

availability

the team wanted to design their push notification system for high availability, which was a particular challenge because they wanted to ensure that they could lose processes, servers, or even data centers without the need for a human operator.

we liked the idea of having one host serve as a backup for another, but we didn’t like having to coordinate the interaction between so many moving pieces. to solve this issue we went with a convention based approach. instead of each host having to maintain a list of its partners, we just use redis to maintain a global lock.

read more on flickr's blog, including code excerpts, here .