30 Redis Interview Questions and Answers

Redis is an open-source, in-memory key-value data store known for its speed and versatility. It is commonly used for caching, real-time analytics, session management, message brokering, and leaderboard systems.

Redis stores data in memory rather than on disk, enabling much faster read and write operations. Unlike relational databases, Redis uses a key-value structure and supports various data types such as strings, hashes, lists, sets, and sorted sets.

In-memory storage means that all data is kept in RAM, allowing for extremely fast data access. This makes Redis ideal for use cases where low latency and high throughput are critical.

Redis supports several data structures including strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes. Each data structure is optimized for specific use cases.

Redis offers two main persistence options: RDB snapshots, which save the dataset at specified intervals, and AOF (Append Only File), which logs every write operation. These can be used individually or together for durability.

A Redis cache temporarily stores frequently accessed data in memory, reducing the need to fetch data from slower backend databases. This significantly improves application response times and reduces database load.

Redis achieves high availability through replication, where data is copied from a primary node to one or more replica nodes. Redis Sentinel provides automatic failover and monitoring, while Redis Cluster enables partitioning and redundancy.

Redis pub/sub allows clients to subscribe to channels and receive messages in real time when other clients publish to those channels. This is useful for building chat systems, notifications, and real-time messaging applications.

While both are in-memory key-value stores, Redis supports a wider range of data structures, persistence options, and advanced features like replication and Lua scripting. Memcached is simpler and focuses mainly on caching strings.

Redis allows you to set expiration times (TTL) on keys, after which they are automatically deleted. It also supports various eviction policies to manage memory usage when the dataset exceeds the available RAM.

Redis Cluster is a distributed implementation of Redis that automatically shards data across multiple nodes. It provides horizontal scalability and fault tolerance by partitioning data and replicating it across nodes, ensuring continued operation even if some nodes fail.

RDB (Redis Database Backup) creates point-in-time snapshots of your dataset at specified intervals, offering fast recovery but potential data loss between snapshots. AOF (Append Only File) logs every write operation, providing more durability but potentially slower recovery. Use RDB for faster restarts and AOF for minimal data loss.

Redis supports transactions using the MULTI, EXEC, DISCARD, and WATCH commands. All commands in a transaction are queued and executed atomically. However, Redis transactions do not support rollbacks on errors within a transaction, and commands are not isolated from other clients until EXEC is called.

Redis Sentinel monitors Redis instances, detects failures, and automatically promotes a replica to master if the primary node fails. It also notifies clients of topology changes, ensuring high availability and minimal downtime.

Rate limiting can be implemented in Redis using data structures like counters with expiration (INCR and EXPIRE), sorted sets for sliding windows, or Lua scripts for atomicity. This allows you to efficiently track and restrict the number of actions per user or API key within a given timeframe.

Lua scripts allow you to execute multiple Redis commands atomically on the server side. They reduce network round-trips, ensure atomicity, and enable complex operations that are not possible with standard commands. Scripts are executed using the EVAL command.

Redis Cluster uses asynchronous replication, which means there is a possibility of data loss if the primary node fails before replicating changes to replicas. It provides eventual consistency and uses a concept called 'hash slots' to distribute data.

Redis Streams is a data structure for managing real-time data feeds. It supports message queuing, consumer groups, and message persistence, making it suitable for event sourcing, log aggregation, and building scalable messaging systems.

Best practices include binding Redis to localhost or using firewalls, enabling AUTH authentication, using TLS for encrypted connections, renaming or disabling dangerous commands, and running Redis with minimal privileges.

You can monitor Redis using built-in commands like INFO, MONITOR, and SLOWLOG, as well as external tools like RedisInsight and Prometheus. Key metrics include memory usage, command latency, key eviction rates, and replication lag. Troubleshooting involves analyzing slow queries, optimizing data structures, and tuning configuration parameters.

Redis pipelining allows clients to send multiple commands to the server without waiting for individual responses, reducing network latency and increasing throughput. By batching commands, clients can achieve significant performance gains, especially in scenarios involving many small operations.

Redis modules extend the core functionality of Redis by adding new data types, commands, and capabilities. Popular modules include RediSearch (full-text search), RedisJSON (JSON data manipulation), RedisGraph (graph database), and RedisTimeSeries (time-series data). These modules enable Redis to support a broader range of use cases beyond traditional caching.

Redis Cluster prioritizes availability and partition tolerance (AP) in the CAP theorem. It uses asynchronous replication, which can lead to eventual consistency. During network partitions, some data may be temporarily unavailable or lost if the primary node fails before replication. The trade-off is improved availability and scalability at the cost of strong consistency guarantees.

Scaling Redis horizontally involves sharding data across multiple nodes using Redis Cluster or client-side sharding. Challenges include data rebalancing, maintaining consistency, and handling failover. Strategies to overcome these include using hash slots for automatic partitioning, employing consistent hashing, and leveraging Redis Cluster's built-in mechanisms for rebalancing and failover.

Using Redis as a primary database requires careful consideration of persistence (AOF/RDB), replication, and backup strategies to ensure durability. Architecting for reliability involves deploying Redis Sentinel or Cluster for high availability, using disk persistence, and planning for disaster recovery. As a cache, durability is less critical, and focus shifts to performance and eviction policies.

Atomicity for multi-key operations can be achieved using Lua scripts, which execute all commands atomically on a single node. However, in Redis Cluster, multi-key operations are only atomic if all keys are in the same hash slot. For cross-slot operations, atomicity and isolation cannot be guaranteed, so application-level strategies or data modeling adjustments may be necessary.

Redis manages memory using efficient data structures and supports various eviction policies (e.g., LRU, LFU, random) when memory limits are reached. Memory fragmentation can occur due to allocation patterns; it can be mitigated by tuning allocator settings and periodically restarting Redis. Optimization techniques include using the right data types, key compression, and avoiding large objects.

Best practices include running Redis in a private network, enabling TLS encryption, using strong AUTH passwords, disabling or renaming sensitive commands, restricting access via firewalls or security groups, and using container security features like namespaces and resource limits. Regularly updating Redis and monitoring for vulnerabilities is also essential.

Zero-downtime upgrades can be achieved by deploying replicas, promoting them as needed, and using Redis Sentinel or Cluster for automatic failover. For migrations, techniques include dual-writing to old and new clusters, using replication for data sync, and gradually switching traffic. Thorough testing and rollback plans are critical to minimize risk.

Redis Streams and Pub/Sub make Redis suitable for event sourcing and CQRS (Command Query Responsibility Segregation) patterns. Benefits include high throughput, real-time processing, and scalability. Pitfalls include managing event ordering, ensuring durability, and handling backpressure. Careful design is required to avoid data loss and ensure consistency across read and write models.