Redis Interview Questions and Answers

Redis (Remote Dictionary Server) is an open source key-value database. It is networked, single threaded, in- memory, advanced key-value store with optional durability. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets and sorted sets.  It supports memory persistent storage on disk, replication to scale read performance, and client-side sharding1 to scale write performance.

Redis creates a new category in the database world. It combines the best of in-memory, schema-less design with optimized data structures and versatile modules that adapt to your data needs. The result is the most adept, high performance, multi-purpose database that scales easily like a simple key/value data store but delivers sophisticated functionality with great simplicity. In addition to being fully in-memory, Redis enables data persistence and high availability through replication and backups. (Redislab). It is built for Speed & Languages. Redis-Ready Cloud Servers. In-Memory Processing for Media

• Queues
• Supported Languages
• Atomic operations
• Leaderboards/Counting
• Lua Scripting
• Pub/Sub
• Transactions
• Full Page Cache (FPC)
• Master/Slave replication
• Cluster (with automatic sharding)*
• Automatic failover (Redis Sentinel)
• Append Only File (AOF) persistence
• Snapshot (RDB file) persistence
• Redis can handle up to 232 keys and was tested in practice to handle at Least 250 million of keys per instance.
• It loads up to 110,000 SETs/second and 81,000 GETs/second can be retrieved in an entry level Linux box. It can execute 100000 queries per second
• Every list, set, and sorted set, can hold 232 elements.

Redis is supported many languages that have Redis bindings, including: C, C++, C#, Clojure, Common Lisp, Dart, Erlang, Go, Haskell, Haxe, Io, Java, ActionScript, JavaScript (Node.js), Lua, Objective-C, Perl, PHP, Pure Data, Python, R, Ruby, Scala, Smalltalk and Tcl.

Redis is written in ANSI C and mostly used for cache solution and session management. It creates unique keys for store values.

A list of well-known companies using Redis: Twitter, GitHub, Weibo, Pinterest, Snapchat, Craigslist Digg, Stack Overflow, Flickr, Tumblr, Twilio. Excluding Facebook and Google+

Redis is not a plain key-value store, actually it is a data structures server, supporting different kind of values. Here is a list all the data structures supported by Redis.

Redis supports these data structures:

Binary-safe strings: lists or collections of string elements are sorted according to the order of insertion.

Sets and sorted sets: collections of unique, unsorted string elements and collections in which every string element is associated with a floating number value called a score.

Hashes: It maps composed of fields associated with values. Both the field and the value are strings.

Bit arrays (bitmaps): It is use special commands to handle string values like an array of bits.

HyperLogLogs: a data structure that can estimate the number of items in a set.

Geospatial indexes – data that is stored as coordinate pairs.

There are two different ways of persisting data to disk. One is a method called snapshotting that takes the data as it exists at one moment in time and writes it to disk. The other method is called AOF, or append only file, and it works by copying incoming write commands to disk as they happen. These methods can be used together, separately, or not at all in some circumstances. Which to choose will depend on your data and your application.

Redis provides a different range of persistence options:

• The RDB persistence performs point-in-time snapshots of your dataset at specified intervals.
• The AOF persistence logs every write operation received by the server that will be played again at server startup, reconstructing the original dataset. Commands are logged using the same format as the Redis protocol itself, in an append-only fashion. Redis is able to rewrite the log on background when it gets too big.
• If you wish, you can disable persistence at all, if you want your data to just exist as long as the server is running.
• It is possible to combine both AOF and RDB in the same instance. Notice that, in this case, when Redis restarts the AOF file will be used to reconstruct the original dataset since it is guaranteed to be the most complete.

Redis replication is a very simple to use and configure master-slave replication that allows slave Redis servers to be exact copies of master servers. Here are some important facts about Redis replication:

Redis uses asynchronous replication.

• A master can have multiple slaves.
• Slaves are able to accept connections from other slaves. Slaves can also be connected to other slaves in a graph-like structure.
• Redis replication is non-blocking on the master side.
• Replication is also non-blocking on the slave side.
• Replication can be used both for scalability, in order to have multiple slaves for read-only queries or simply for data redundancy.
• It is possible to use replication to avoid the cost of writing the master write the full dataset to disk.

Redis will either be killed by the Linux kernel OOM killer, crash with an error, or will start to slow down. With modern operating systems malloc () returning NULL is not common, usually the server will start swapping and Redis performances will degrade so you’ll probably notice there is something wrong. The INFO command will report the amount of memory Redis is using so you can write scripts that monitor your Redis servers checking for critical conditions.

Append-only files (AOF) keep a record of data changes that occur by writing each change to the end of the file. AOF are not supported for cache.t1.micro and cache.t2.* nodes. For nodes of these types, the appendonly parameter value is ignored. Using AOF Redis is much more durable: you can have different fsync policies: no fsync at all, fsync every second, fsync at every query. With the default policy of fsync every second write performances are still great (fsync is performed using a background thread and the main thread will try hard to perform writes when no fsync is in progress.) but you can only lose one second worth of writes.

A value set by using SET command will set the value for the key. Doing it over again will override the value. However, using append has the effect of set only when the key has no value earlier, but if there is a value already assigned to the key , then doing append on the key would lead to an appended value to the existing value of th

MemcacheD: MemcacheD is easy yet powerful. Its manageable design promotes fast deployment, ease of exaggeration, and solves many problems related to large data caches. Memcached could be preferable when caching relatively small and static data, such as HTML code fragments. Memcached internal memory management, is more efficient in the simplest use cases because it consumes comparatively less memory resources for metadata.Memcached’s memory management efficiency diminishes quickly when data size is dynamic, at which point Memcached’s memory can become fragmented. Also, large data sets often involve serialized data, which always requires more space to store. If you are using Memcached then data is lost with a restart and rebuilding cache is a costly process. Memcached’s read/write speed is higher than redis.         

Redis: Redis is an open source in-memory data structure store which also can be used as a database as well as caching. Redis has five primary data structures to choose from, opening up a world of possibilities to the application developer through intelligent caching and manipulation of cached data. Because of its data structures (Stores data in a variety of formats: list, array, sets and sorted sets) Redis as a cache gives you a lot of power and greater efficiency overall. Caches employ a mechanism called data eviction to make room for new data by deleting old data from memory. Memcached’s data eviction mechanism employs a Least Recently Used algorithm and somewhat arbitrarily evicts data that’s similar in size to the new data. Redis’s read/write speed is fast, but it depends on the application being developed.

• Both are categorised as NoSQL.
• Both store data in the format of key-value.
• Both can store data in memory.

There are a lot of differences between Redis and RDBMS:

• Redis is a NoSQL database while RDBMS is an SQL database.
• Redis follows the key-value structure while RDBMS follows the table structure.
• Redis extremely fast while RDBMS is comparatively slow.
• Redis stores all the dataset in primary memory while RDBMS stores its dataset in secondary memory.
• Redis is generally used to store small and frequently used files while RDBMS is used to store big files.
• Redis provides only official support for Linux, BSD, Mac OS X, and Solaris. It doesn?t provide official support for Windows currently while RDBMS provides support for both.

To improve the durability of Redis “append only file” can be configured by using fsync data on disk.

• Fsync () every time a new command is added to the append log file: It is safe but very slow.
• Fysnc() one time every second: It is fast, but you may lose 1 second of data if system fails.
• Never fsync(): It is an unsafe method, and your data is in hand of Operating System.

Use BGSAVE command to save a spanshot of the database into a dump.rdb

Copy this dump.rdb file into another server

KEYS / SCAN only list keys that are on the current server; not the wider logical database

FLUSHDB / FLUSHALL only remove keys that are on the current server; not the wider logical database

RANDOMKEY only selects a key that is on the current server; not the wider logical database

• TYPE key
• TTL key
• KEYS pattern
• EXPIRE key seconds
• EXPIREAT key timestamp
• EXISTS key
• DEL key

To use Redis in .Net applications, follow these steps:

• First, Download Redis Server.
• Install Redis Server.
• Download Redis Client.
• Set Configuration into Web.config File.
• Use Redis Client Class.

MongoDB is a nonstructured (at least, in definition) distributed document storage. For clearing purpose, you can think about it as a high scalable and not so high performance JSON storage (though actually it uses BSON). It has a simple but effective multitype index system, replication and sharding, and a lot of more nice features. Redis is a simplest key/value store, with transient data caching. It can work as an efficient queue system.

Looking for more specific information you will find a lot of scenarios where both them are used, Mongo as a true persistent canonical storage, and Redis as an transient/cache storage.

To check Redis is running try out the following code:

try

{

    $redis = new Redis ();

    $redis->connect (‘127.0.0.1’, 6379);

    echo “Redis is running.”;

    echo “Server is running: ” . $redis->ping();

}

catch (Exception $e)

{

    echo $e->getMessage();

}

To set multiple values in Redis use the following commands:

• $redis->lpush(“tutorials”, “PHP”);
• $redis->lpush(“tutorials”, “MySQL”);
• $redis->lpush(“tutorials”, “Redis”);
• $redis->lpush(“tutorials”, “Mongodb”);
• $redis->lpush(“tutorials”, “Mysql”);

SAVE command is used to create a backup of a current Redis database. This command will create a dump.rdb file in your Redis directory by performing synchronous save.

Syntax”

SAVE 

Return Value:The SAVE command returns OK after successful execution.

Use BGSAVE command to save a spanshot of the database into a dump.rdb

Copy this dump.rdb file into another server.

Binary safe means that it has a known length but not limited by any special character. You can store any value unto the given size. A string value can be 512 MB in length.

You can stop Redis by using following path:

/etc/init.d/redis-server stop

Pros:

• Blazing Fast
• Robust
• Redis is in-memory data structure store, used as database, cache and message broker.
• Easy to setup, Use and maintain
• Data Scheme free
• Extensible with LUA scripting
• Redis uses Sharding for partition.
• Redis follows proprietary protocol.
• Optimistic locking, atomic execution of commands blocks and scripts.
• Rich Client-Side Library
• Server-side locking

Cons:

• Redis in-memory
• It is single threaded
• It has got limited client support for consistent hashing
• It is not deployed widely
• Persistence consumes lot of I/O when using RDB
• All your data must fit in memory