3/13/2018 - 7:46 PM


What is redis and how to use it in rails ...


  • REmote DIctionary Server
  1. key/value store
  2. Built-in support for data structures like hashes
  3. Performs well as a cache store and a full-fledged NoSQL data store

Installing Redis

  • brew install redis on OSX
  • To have launchd start redis now and restart at login: brew services start redis
  • If you don't want/need a background service: redis-server /usr/local/etc/redis.conf (use!)
  • Use in a rails app: gem install redis

How does caching work?

  • Disk access is expensive!
  • Disk access also negatively impacts performance!
    • To counter this, implement a caching layer between your application and database server
  • Initially, a caching layer doesn't contain any data at first!
    • When it receives the request for the data, it calls the database and stores the result in memory
    • Later requests won't need to access the database because the data is already stored in the cache!

Model Caching using Redis

  • Create a simple app using scaffold Snippet content:text

  • In this example, redis will be used to load snippets from Rails rather than using a SQL db.

  • For loading a page that contains many records, it may take a very long time to load, Redis can be used to load the records drastically faster

  • Once the app is created and migrations are ran, install the following gems:

    • gem 'rack-mini-profiler': displays loading time in upper left corner of browser
    • gem 'faker': used to fill in dummy data to create records faster
    #example of using faker in seed.db
    100000.times do 
      Snippet.create(content: Faker::Lorem.paragraph)
  • bundle install

  • bundle exec rake db:seed

  • Change root to snippets#index

  • Run rails s

  • Notice the loading time of rack-mini-profiler!

Using Redis as a cache store

  • Open terminal, in one window run redis-server
    • Make an alias in your bash_profile: redis-server /usr/local/etc/redis.conf
  • Add the following gems to Gemfile:
    • gem 'redis'
    • gem 'redis-rails'
  • bundle install
  • In config/development.rb, you can instruct Rails to use redis as a cache store: (or even production.rb)
module nameOfApp
  class Application < Rails::Application
    config.cache_store = :redis_store, 'redis://localhost:6379/0/cache', {expires_in: 90.minutes}
    # redis has 16 databases to choose from (0-15), represents the 0 before cache
    # cache represents the namespace
    # you can configure host, port and other db:
    # => '', :port => 6380, :db => 15)
    # Alternatively: 
    config.cache_store = :redis_store, {
      host: 'localhost',
      port: 6379,
      db: 0,
      namespace: 'cache'
  • Restart your app any time you makes changes to these files!

Application Modifications

  • Configuring and setting up redis is now complete!
  • Instead of loading records from the SQL database, head in to a controller that loads records:
#include the controller helper folder, code will be ran inside there
# example SnippetsController.rb
def index
  @data = fetch_snippets


module SnippetsHelper
  def fetch_snippets
    snippets = $redis.get("snippets")
    if snippets.nil?
      # the first time around snippets will be nil, redis hasn't put anything in yet
      snippets = Snippet.all.to_json
      #Now redis is inserting the array of snippets in a hash with key "snippets"
      # from the database access, so that next time it can just bypass the db and use its store 
      $redis.set("snippets", snippets)
      #Expire the cache every 5 hours
      $redis.expire("snippets", 5.hour.to_i)
    JSON.load snippets

#Update the views

<% @data.each do |snippet| %>

  <%= snippet["content"] %>

<% end %>

  • Why convert the data received from the db? The fastest way to write objects to redis.
    • Alternative is to iterate over all the objects and then save them as a hash = SLOW
    • Fastest way is to save them as a JSON encoded string, to decode use JSON.load
    • This alters the returned data so we will need to change the views to access attributes as a hash (as above)
  • Restart server and refresh page to notice the change in loading time!
  • If you make a change to a model, redis will wait the amount specified to expire befor getting fresh data. You can create a after_save validation on the model being cached:
#example of categories being cached
class Category

  after_save: :clear_cache
  def clear_cache
    $redis.del "categories"
  • Now, when a model is updated (and saved to the db) Rails is instructed to clear the cache, ensuring that the cache is always upto date.

Redis Rails

  • in gemfile: gem 'redis-rails'
# setting a key/value pair 
redis.set("key", "value")

# retrieving a value
#=> "value"

# in your rails app, view template
<% cache 'word-of-the-hour', :expires_in => + 1.hour do %>
  <%= %w(ruby rails javascript web developer).sample %>
<% end %>

# Every hour, redis will empty the cache and set a new value for the key

Redis (Overview)

  • Install Redis link
  • After installation run redis server
  • In a new tab, run redis-cli
    • You can see the redis url:, default port is 6379
  • Simple commands:
# set key value
set name parm

# get value from key
get name 
# => parm

Redis Basics


  • key/value pair
  • string
  • list (list of ORDERED strings)
  • hashes
  • set (list of UNORDERED and UNIQUE strings)

Redis Persistence Options

  • Data is saved in memory for fast access!
  • Two options:
    • AOF (Append-only File): logs every operation in the system file. If the log gets too large, Redis will be able to shrink it down to only the latest version of the file.
    • RDB (Redis Database File): creates a snapshot, creating copies of moments in time. (Default)
  • Configuring which option to use:
    • cd in to the directory where you downloaded redis
    • Open redis.config, find section for Snapshotting, read the info on how to configure the snapshot after x sec with atleast x amount of changes
    • Find section for appendonly and change no to yes
    • Save & close, copy the path to the file
    • Restart the server and this time append the path to it: redis-server /usr/local/etc/redis.conf


  • Copy and rename the above file as redis2.conf
    • change the port number to 3780
    • find slaveof and replace with: slaveof 6379, slave of redis.config
    • Open a new tab and start another server with the redis2.conf file
    • Should notice master-slave relation has started


  • Open both .conf files
  • find requirepass enterpass, replace enterpass with a password, make sure slave is updated with the same password in the location of masterauth
  • restart both servers for each to take effect!
  • In order to use the cli, enter the following: redis-cli -a password, entering the password that was set in the .conf file.

Datasets using Keys

set address 435

incr address #increment by 1
# => 436

incrby address 100 #increment by x

decr address
decrby address

# For multiple words for a value, USE DOUBLE QUOTES!!
set country "North America"

#getset is used to get a key and then set it, returns original key
getset firstName "Parm"

#set multiple values:
mset street blah city blah2 state blah3 zip "blah4"

#retrieve those values:
mget street city state zip

#check if something exists:
exists street
# returns 1 for yes it exists, 0 else

#delete a key
del street

#expire a key in x sec
exp city 5

#set and expires
set zip "989-899989" ex 9


#creating a hash:
hmset nameofhash key1 value1 key2 value2 ...

#retrieve the hash:
hgetall nameofhash

#retrieve a certain value in the hash:
hget nameofhash key1

#retrieve multiple values
hmget nameofhash key1 key2

hexist nameofhash  key1

#set another key
hmset nameofhash keyx valuex

hincrby nameofhash key numtoincrementby


#creates a new list (right push appends to bottom of list)
rpush nameoflist value1 value2 value3 ...

#list the list
lrange nameoflist startindex stopindex
#startindex is usually 0!
# -1 all 
# -2 all except the last one
# -3 all except the last 2

#append to the BEGINNING of a list (left push)
lpush nameoflist valuex

#remove (left pop)
lpop nameoflist

#right pop (removes at the end of the list)
rpop nameoflist

#trimming a list
ltrim nameoflist starti stopi
#ex ltrim grocery 0 2
# lrange 0 -1 to see the new list


#creating a set
sadd nameofset value1 value2 value3 value4

#retrieve set
smembers name

#add more values
sadd valuex valauey

#is there?
sismember nameofset value
#returns 0 no, 1 yes

#creating a subset
sadd nameofset:value value_1 value_2 value_3 ...

#retrieve subset
smembers nameofset:value

#creating a new value that has the same sublist as another value
sunionstore nameofset:newvalue nameofset:existingvalue

#remove the last value from the subset
spop nameofset:value

#count of how many values
scard nameofset

Sorted Sets

#creating a sorted set, helps if keys are integers
zadd nameofset key1 value1 key2 value2 key3 value3 ...

#listing the set
zrange nameofset starti endi
# 0 start, -1 end
# return just the values, to return with key AND values:

zrange nameofset 0 -1 withscores #again 0 is starti and -1 is endi

#reverse the set
zrevrange nameofset starti endi withscores

#get upto a certain range of key
zrangebyscore nameofset -inf integer withscores
#inf = information that will be obtained until the integer value

#retrieve the position of a value
zrank nameofset value
#returns the index or ranking


Security with Redis

  • open the config file and search for security, requirepass password is the main way to secure redis
  • Next, ensure that redis port and address is firewalled from unrestriced access!
    • Binding redis to a single interface is the standard config and best practice
  • Search for bind and notice that redis is binded to = 1 interface, which means we can only access the redis server through that address!
  • It is advised to stray away from adding more than one interface to a single redis server!