Redis

Redis is an open source, in-memory data structure store (database and cache) used as a database, cache, message broker, and real-time data platform for low-latency workloads.

• In-memory key-value data store with rich data structures (database/cache)
• Supports strings, hashes, lists, sets, sorted sets, streams, geospatial indexes, and bitmaps (data management)
• Built-in replication, partitioning, and high availability with Redis Sentinel and Redis Cluster (data infrastructure)
• Publish–Subscribe Pattern (Pub/Sub) messaging, streams, and Link Utilization Analyzer (LUA) scripting for real-time and event-driven applications (application integration)
• Persistence options with snapshots and append-only files plus configurable durability and recovery (data durability)

More About Redis

Redis is an open source, in-memory data structure store (database and cache) designed to support low-latency access to operational data for online applications, services, and infrastructure systems. It stores data as key-value pairs and exposes data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams (data management), which allows developers and architects to model diverse use cases within a single platform.

From an enterprise perspective, Redis is commonly categorized as an in-memory NoSQL data store (database) and distributed cache (caching). It is used for application-side caching, user sessions, configuration data, leaderboards, queues, rate limiting, and real-time analytics. Its in-memory design and single-threaded event loop per core enable predictable low-latency operations, while optional persistence mechanisms such as RDB snapshots and append-only files (data durability) provide recovery from restarts or failures.

Redis supports high availability and scalability features oriented to production environments. Replication (data replication) allows data from a primary instance to be copied to one or more replicas for read scaling and failover. Redis Sentinel (cluster management) provides monitoring, automatic failover, and configuration management for high-availability deployments. Redis Cluster (sharding and clustering) distributes data across multiple nodes using hash slots, enabling horizontal scaling and continued operations when some nodes are unavailable, subject to configuration.

The platform includes additional capabilities that support application integration and event-driven architectures. Built-in publish/subscribe messaging (application integration) enables lightweight message broadcasting among clients. Redis Streams (data streaming) provide an Append-Only Log (AOL) data type suitable for messaging, event sourcing, and consumer groups. Server-side scripting with LUA (server-side scripting) enables execution of atomic operations that combine multiple Redis commands within a single script, reducing round trips and maintaining consistency.

Redis exposes a simple TCP-based protocol, RESP (application protocol), which is supported by client libraries in many programming languages. This protocol design and the existence of mature client libraries facilitate integration with application servers, microservices, and infrastructure components. Redis can operate as a standalone server, as part of a high-availability Sentinel deployment, or in a clustered configuration across multiple machines or containers.

Within enterprise architectures, Redis is often deployed as a shared caching and data platform that sits between application tiers and primary databases. It is used in combination with relational databases, document stores, and message queues to offload read traffic, maintain ephemeral state, and support real-time features such as personalization, counters, job queues, and Application Programming Interface (API) rate enforcement. Its role fits into categories including operational databases, distributed caching, session storage, lightweight messaging, and real-time data processing.