Docs

Redis Insight v3.0.0, November 2025

Sun, 30 Nov 2025 00:00:00 +0000

3.0.0 (November 2025)

This is the General Availability (GA) release of Redis Insight 3.0.0, a major version upgrade that introduces a new UI experience, a new navigation architecture, and foundational improvements that set the stage for faster, more powerful developer workflows from now on.

Redis Insight v2.70.1, July 2025

Thu, 10 Jul 2025 00:00:00 +0000

2.70.1 (July 2025)

This is a maintenance release for Redis Insight 2.70.

Redis Insight v2.70.0, May 2025

Wed, 28 May 2025 00:00:00 +0000

2.70 (May 2025)

This is the General Availability (GA) release of Redis Insight 2.70.

Redis Insight v2.68.0, April 2025

Tue, 01 Apr 2025 00:00:00 +0000

2.68 (April 2025)

This is the General Availability (GA) release of Redis Insight 2.68.

Redis Insight v2.66.0, January 2025

Thu, 30 Jan 2025 00:00:00 +0000

2.66 (January 2025)

This is the General Availability (GA) release of Redis Insight 2.66.

Redis Insight v2.64.1, December 2024

Fri, 27 Dec 2024 00:00:00 +0000

2.64.1 (December 2024)

This is a maintenance release for Redis Insight 2.64.

Redis Insight v2.64.0, December 2024

Thu, 19 Dec 2024 00:00:00 +0000

2.64 (December 2024)

This is the General Availability (GA) release of Redis Insight 2.64.

Redis Insight v2.62.0, November 2024

Wed, 27 Nov 2024 00:00:00 +0000

2.62 (November 2024)

This is the General Availability (GA) release of Redis Insight 2.62.

Redis Insight v2.60.0, October 2024

Wed, 30 Oct 2024 00:00:00 +0000

2.60 (October 2024)

This is the General Availability (GA) release of Redis Insight 2.60.

Redis Insight v2.58.0, October 2024

Tue, 01 Oct 2024 00:00:00 +0000

2.58 (October 2024)

This is the General Availability (GA) release of Redis Insight 2.58.

Redis Insight v2.56.0, September 2024

Mon, 09 Sep 2024 00:00:00 +0000

2.56 (September 2024)

This is the General Availability (GA) release of Redis Insight 2.56.

Redis Insight v2.54.0, August 2024

Tue, 06 Aug 2024 00:00:00 +0000

2.54 (August 2024)

This is the General Availability (GA) release of Redis Insight 2.54.

Redis Insight v2.52.0, June 2024

Wed, 26 Jun 2024 00:00:00 +0000

2.52 (June 2024)

This is the General Availability (GA) release of Redis Insight 2.52.

Redis Insight v2.50.0, May 2024

Thu, 30 May 2024 00:00:00 +0000

2.50 (May 2024)

This is the General Availability (GA) release of Redis Insight 2.50.

Redis Insight v2.48.0, April 2024

Wed, 10 Apr 2024 00:00:00 +0000

2.48 (April 2024)

This is the General Availability (GA) release of Redis Insight 2.48.

RedisInsight v2.46.0, March 2024

Thu, 28 Mar 2024 00:00:00 +0000

2.46 (March 2024)

This is the General Availability (GA) release of RedisInsight 2.46.

RedisInsight v2.44.0, February 2024

Thu, 29 Feb 2024 00:00:00 +0000

2.44 (February 2024)

This is the General Availability (GA) release of RedisInsight 2.44.

RedisInsight v2.42.0, January 2024

Tue, 30 Jan 2024 00:00:00 +0000

2.42 (January 2024)

This is the General Availability (GA) release of RedisInsight 2.42.

RedisInsight v2.40.0, December 2023

Wed, 27 Dec 2023 00:00:00 +0000

2.40 (December 2023)

This is the General Availability (GA) release of RedisInsight 2.40.

RedisInsight v2.38.0, November 2023

Wed, 29 Nov 2023 00:00:00 +0000

2.38 (November 2023)

This is the General Availability (GA) release of RedisInsight 2.38.

RedisInsight v2.36.0, October 2023

Thu, 26 Oct 2023 00:00:00 +0000

2.36 (October 2023)

This is the General Availability (GA) release of RedisInsight 2.36.

RedisInsight v2.34.0, September 2023

Thu, 28 Sep 2023 00:00:00 +0000

2.34 (September 2023)

This is the General Availability (GA) release of RedisInsight 2.34.

RedisInsight v2.32.0, August 2023

Thu, 31 Aug 2023 00:00:00 +0000

2.32 (August 2023)

This is the General Availability (GA) release of RedisInsight 2.32.

RedisInsight v2.30.0, July 2023

Thu, 27 Jul 2023 00:00:00 +0000

2.30 (July 2023)

This is the General Availability (GA) release of RedisInsight 2.30.

RedisInsight v2.28.0, June 2023

Wed, 28 Jun 2023 00:00:00 +0000

2.28 (June 2023)

This is the General Availability (GA) release of RedisInsight 2.28.

RedisInsight v2.26.0, May 2023

Wed, 31 May 2023 00:00:00 +0000

2.26 (May 2023)

This is the General Availability (GA) release of RedisInsight 2.26.

RedisInsight v2.24.0, April 2023

Thu, 27 Apr 2023 00:00:00 +0000

2.24 (April 2023)

This is the General Availability (GA) release of RedisInsight 2.24.

RedisInsight v2.22.1, March 2023

Thu, 30 Mar 2023 00:00:00 +0000

2.22.1 (March 2023)

This is the General Availability (GA) release of RedisInsight 2.22.

RedisInsight v2.20.0, February 2023

Tue, 28 Feb 2023 00:00:00 +0000

2.20.0 (February 2023)

This is the General Availability (GA) release of RedisInsight 2.20.

RedisInsight v2.18.0, January 2023

Tue, 31 Jan 2023 00:00:00 +0000

2.18.0 (January 2023)

This is the General Availability (GA) release of RedisInsight 2.18.

Redis Enterprise for Kubernetes 7.2.4-15 (October 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-144. For information on supported distributions, breaking changes, and limitations, see the previous 7.2.4-15 release notes.

Redis Enterprise for Kubernetes 7.22.0-17 (September 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.0-250. For version changes, supported distributions, and known limitations, see the release notes for 7.22.0-15 (July 2025).

Redis Enterprise for Kubernetes 7.22.2-31 (December 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.2-41. For supported distributions known limitations, see the 7.22.2 releases.

Redis Enterprise for Kubernetes 7.4.6-7 (December 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-275. For version changes, supported distributions, and known limitations, see the release notes for 7.4.6.

Redis Enterprise for Kubernetes 7.8.4-9 (March 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release to support Redis Enterprise Software version 7.8.4-95 and OpenShift 4.17 and 4.18.

For version changes and known limitations, see the release notes for 7.8.2-6 (Nov 2024).

Supported distributions

The following table shows supported distributions at the time of this release. You can also find this list in Supported Kubernetes distributions.

Redis Enterprise for Kubernetes 7.8.6-8 (October 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 7.8.6-8 (October 2025) is a maintenance release that includes support for Redis Software 7.8.6-207.

For supported distributions, known limitations, and API changes, see Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes.

Downloads

Redis Enterprise: redislabs/redis:7.8.6-207
Operator: redislabs/operator:7.8.6-8
Services Rigger: redislabs/k8s-controller:7.8.6-8
OLM operator bundle : v7.8.6-8.1

Known limitations

See 7.8.6 releases for information on known limitations.

Redis Enterprise for Kubernetes 8.0.2-2 (October 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

This feature release of Redis Enterprise for Kubernetes supports Redis Software 8.0.2-17 and includes enhancements, platform support changes, and bug fixes.

Warning:

Custom modules not supported: If you use custom (user-defined) modules, skip this release. Custom module support will be available in the next release.

New in this release

This release includes enhancements to the Redis Enterprise for Kubernetes operator, and includes features supported by Redis Software 8.0.2-17, and Redis Open Source 8.0 and 8.2.

Redis Enterprise for Kubernetes 8.0.2-6 (December 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

This maintenance release of Redis Enterprise for Kubernetes supports Redis Software 8.0.2-41 and includes enhancements, API changes, and bug fixes.

Warning:

Custom modules not supported: If you use custom (user-defined) modules, skip this release. Custom module support will be available in the next release.

Enhancements

Support for Redis Enterprise Software version 8.0.2-41
Added API fields to configure internode encryption (RED-174881)

Resolved issues

Fixed upgrade issues with large clusters (RED-176468)

API changes

CRD	Field	Change	Description
REC	spec.dpInternodeEncryptionCertificateSecretName	Add	Secret name to use for cluster's Data Plane Internode Encryption (DPINE) certificate. If left blank, a cluster-provided certificate will be used.
REC	spec.cpInternodeEncryptionCertificateSecretName	Add	Secret name to use for cluster's Control Plane Internode Encryption (CPINE) certificate. If left blank, a cluster-provided certificate will be used.

Version changes

Modules in Redis 8

In Redis Enterprise databases created with or upgraded to Redis version 8 or later, bundled modules are enabled automatically, so you don't need to specify them in the spec.moduleList field. However, if you want to use a specific version of a bundled module, you can specify it in the spec.moduleList field.

Redis Enterprise for Kubernetes 8.0.6-8 (December 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 8.0.6-8 is a feature release that supports Redis Software 8.0.6-54, and includes enhancements, supported distribution updates and bug fixes.

Highlights

Support for external module repositories (custom modules)
Support for Redis Software 8.0.6-54
SAML 2.0 single sign-on (SSO) authentication support for the cluster manager UI

Enhancements

API support has been added for the following features:

ACL

Mon, 01 Jan 0001 00:00:00 +0000

The Redis ACL, short for Access Control List, is the feature that allows certain connections to be limited in terms of the commands that can be executed and the keys that can be accessed. The way it works is that, after connecting, a client is required to provide a username and a valid password to authenticate. If authentication succeeded, the connection is associated with a given user and the limits the user has. Redis can be configured so that new connections are already authenticated with a "default" user (this is the default configuration). Configuring the default user has, as a side effect, the ability to provide only a specific subset of functionalities to connections that are not explicitly authenticated.

Redis administration

Mon, 01 Jan 0001 00:00:00 +0000

Redis setup tips

Linux

Deploy Redis using the Linux operating system. Redis is also tested on OS X, and from time to time on FreeBSD and OpenBSD systems. However, Linux is where most of the stress testing is performed, and where most production deployments are run.

Aggregations

Mon, 01 Jan 0001 00:00:00 +0000

Aggregations are a way to process the results of a search query. Aggregation allows you to group, sort, and transform your result data, and to extract analytic insights from it. Much like aggregation queries in other databases and search engines, they can be used to create analytics reports, or perform faceted search style queries.

For example, indexing a web-server's logs, you can create a report for unique users by hour, country, or any other breakdown. Or you can create different reports for errors, warnings, etc.

Modules API reference

Mon, 01 Jan 0001 00:00:00 +0000

Sections

Redis benchmark

Mon, 01 Jan 0001 00:00:00 +0000

How fast is Redis?

Redis includes the redis-benchmark utility that simulates running commands done by N clients at the same time sending M total queries (it is similar to the Apache's ab utility). Below you'll find the full output of a benchmark executed against a Linux box.

Redis modules and blocking commands

Mon, 01 Jan 0001 00:00:00 +0000

Redis has a few blocking commands among the built-in set of commands. One of the most used is BLPOP (or the symmetric BRPOP) which blocks waiting for elements arriving in a list.

The interesting fact about blocking commands is that they do not block the whole server, but just the client calling them. Usually the reason to block is that we expect some external event to happen: this can be some change in the Redis data structures like in the BLPOP case, a long computation happening in a thread, to receive some data from the network, and so forth.

Bulk loading

Mon, 01 Jan 0001 00:00:00 +0000

Bulk loading is the process of loading Redis with a large amount of pre-existing data. Ideally, you want to perform this operation quickly and efficiently. This document describes some strategies for bulk loading data in Redis.

Bulk loading using the Redis protocol

Using a normal Redis client to perform bulk loading is not a good idea for a few reasons: the naive approach of sending one command after the other is slow because you have to pay for the round trip time for every command. It is possible to use pipelining, but for bulk loading of many records you need to write new commands while you read replies at the same time to make sure you are inserting as fast as possible.

Redis CLI

Mon, 01 Jan 0001 00:00:00 +0000

In interactive mode, redis-cli has basic line editing capabilities to provide a familiar typing experience.

To launch the program in special modes, you can use several options, including:

Simulate a replica and print the replication stream it receives from the primary.
Check the latency of a Redis server and display statistics.
Request ASCII-art spectrogram of latency samples and frequencies.

This topic covers the different aspects of redis-cli, starting from the simplest and ending with the more advanced features.

Redis command tips

Mon, 01 Jan 0001 00:00:00 +0000

Command tips are an array of strings. These provide Redis clients with additional information about the command. The information can instruct Redis Cluster clients as to how the command should be executed and its output processed in a clustered deployment.

Unlike the command's flags (see the 3rd element of COMMAND's reply), which are strictly internal to the server's operation, tips don't serve any purpose other than being reported to clients.

Command tips are arbitrary strings. However, the following sections describe proposed tips and demonstrate the conventions they are likely to adhere to.

Compare data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis provides a wide range of data types to store your data. The following are highly specialized for precise purposes:

Geospatial: store strings with associated coordinates for geospatial queries.
Vector sets: store strings with associated vector data (and optional metadata) for vector similarity queries.
Probabilistic data types: keep approximate counts and other statistics for large datasets.
Time series: store real-valued data points along with the time they were collected.

The remaining data types are more general-purpose:

Configuration parameters

Mon, 01 Jan 0001 00:00:00 +0000

Note:

As of Redis 8 in Redis Open Source (Redis 8), configuration parameters for Redis Query Engine (RQE) are now set in the following ways:

At load time via your redis.conf file.
At run time (where applicable) using the CONFIG SET command.

Also, Redis 8 persists RQE configuration parameters just like any other configuration parameters (e.g., using the CONFIG REWRITE command).

Connect

Mon, 01 Jan 0001 00:00:00 +0000

Basic synchronous connection

The example below creates a simple synchronous connection to a local Redis server and tests the connection, before closing it with redisFree(). The redisConnect() function takes just a hostname and port as its arguments, and returns a context object.

Redis CPU profiling

Mon, 01 Jan 0001 00:00:00 +0000

Filling the performance checklist

Redis is developed with a great emphasis on performance. We do our best with every release to make sure you'll experience a very stable and fast product.

Redis as an in-memory data structure store quick start guide

Mon, 01 Jan 0001 00:00:00 +0000

This quick start guide shows you how to:

Get started with Redis
Store data under a key in Redis
Retrieve data with a key from Redis
Scan the keyspace for keys that match a specific pattern

The examples in this article refer to a simple bicycle inventory.

Setup

The easiest way to get started with Redis is to use Redis Cloud:

Database connectivity

Mon, 01 Jan 0001 00:00:00 +0000

Connecting applications to Redis Enterprise databases in Kubernetes involves understanding service discovery, credentials management, and access patterns. This guide covers the essential connectivity aspects unique to Kubernetes deployments.

Service types and access patterns

When you create a RedisEnterpriseDatabase (REDB), the Redis Enterprise operator automatically creates Kubernetes services to route traffic to your database. Understanding these service types is crucial for proper connectivity.

Distributed Locks with Redis

Mon, 01 Jan 0001 00:00:00 +0000

Distributed locks are a very useful primitive in many environments where different processes must operate with shared resources in a mutually exclusive way.

There are a number of libraries and blog posts describing how to implement a DLM (Distributed Lock Manager) with Redis, but every library uses a different approach, and many use a simple approach with lower guarantees compared to what can be achieved with slightly more complex designs.

Run Redis Open Source on Docker

Mon, 01 Jan 0001 00:00:00 +0000

Run Redis Open Source on Docker

To start the Redis Open Source server using the redis:<version> image, run the following command in your terminal:

Event library

Mon, 01 Jan 0001 00:00:00 +0000

Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010), and does not necessarily reflect the latest Redis implementation.

Why is an Event Library needed at all?

Let us figure it out through a series of Q&As.

Exact match queries

Mon, 01 Jan 0001 00:00:00 +0000

An exact match query allows you to select all documents where a field matches a specific value.

You can use exact match queries on several field types. The query syntax varies depending on the type.

The examples in this article use a schema with the following fields:

Field name	Field type
`description`	`TEXT`
`condition`	`TAG`
`price`	`NUMERIC`

You can find more details about creating the index and loading the demo data in the quick start guide.

Redis functions

Mon, 01 Jan 0001 00:00:00 +0000

Redis Functions is an API for managing code to be executed on the server. This feature, which became available in Redis 7, supersedes the use of EVAL in prior versions of Redis.

Prologue (or, what's wrong with Eval Scripts?)

Prior versions of Redis made scripting available only via the EVAL command, which allows a Lua script to be sent for execution by the server. The core use cases for Eval Scripts is executing part of your application logic inside Redis, efficiently and atomically. Such script can perform conditional updates across multiple keys, possibly combining several different data types.

Getting Started with RedisVL

Mon, 01 Jan 0001 00:00:00 +0000

redisvl is a versatile Python library with an integrated CLI, designed to enhance AI applications using Redis. This guide will walk you through the following steps:

Defining an IndexSchema
Preparing a sample dataset
Creating a SearchIndex object
Testing rvl CLI functionality
Loading the sample data
Building VectorQuery objects and executing searches
Updating a SearchIndex object

...and more!

Prerequisites:

Ensure redisvl is installed in your Python environment.
Have a running instance of Redis Stack or Redis Cloud.

Define an `IndexSchema`

The IndexSchema maintains crucial index configuration and field definitions to enable search with Redis. For ease of use, the schema can be constructed from a python dictionary or yaml file.

HyperLogLog

Mon, 01 Jan 0001 00:00:00 +0000

HyperLogLog is a probabilistic data structure that estimates the cardinality of a set. As a probabilistic data structure, HyperLogLog trades perfect accuracy for efficient space utilization.

The Redis HyperLogLog implementation uses up to 12 KB and provides a standard error of 0.81%.

Counting unique items usually requires an amount of memory proportional to the number of items you want to count, because you need to remember the elements you have already seen in the past in order to avoid counting them multiple times. However, a set of algorithms exist that trade memory for precision: they return an estimated measure with a standard error, which, in the case of the Redis implementation for HyperLogLog, is less than 1%. The magic of this algorithm is that you no longer need to use an amount of memory proportional to the number of items counted, and instead can use a constant amount of memory; 12k bytes in the worst case, or a lot less if your HyperLogLog (We'll just call them HLL from now) has seen very few elements.

Install on desktop

Mon, 01 Jan 0001 00:00:00 +0000

Download Redis Insight

Supported operating systems

Redis Insight is supported on multiple operating systems:

Internal design

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source implements inverted indexes on top of Redis, but unlike previous implementations of Redis inverted indexes, it uses a custom data encoding that allows more memory and CPU efficient searches, and more advanced search features.

This document details some of the design choices and how these features are implemented.

Intro: Redis String DMA

The main feature that this module takes advantage of is Redis Modules Strings Direct Memory Access (DMA).

Diagnosing latency issues

Mon, 01 Jan 0001 00:00:00 +0000

This document will help you understand what the problem could be if you are experiencing latency problems with Redis.

In this context latency is the maximum delay between the time a client issues a command and the time the reply to the command is received by the client. Usually Redis processing time is extremely low, in the sub microsecond range, but there are certain conditions leading to higher latency figures.

Redis latency monitoring

Mon, 01 Jan 0001 00:00:00 +0000

Redis is often used for demanding use cases, where it serves a large number of queries per second per instance, but also has strict latency requirements for the average response time and the worst-case latency.

While Redis is an in-memory system, it deals with the operating system in different ways, for example, in the context of persisting to disk. Moreover Redis implements a rich set of commands. Certain commands are fast and run in constant or logarithmic time. Other commands are slower O(N) commands that can cause latency spikes.

Install Redis on Linux

Mon, 01 Jan 0001 00:00:00 +0000

Most major Linux distributions provide packages for Redis.

Install on Ubuntu/Debian

Add the repository to the APT index, update it, and install Redis:

Install Redis Stack on Linux

Mon, 01 Jan 0001 00:00:00 +0000

Learn how to install Redis Stack on Linux from the official APT repository or RPM feed, or with Snap or AppImage.

From the official Ubuntu/Debian APT Repository

See this page for a complete list of supported Ubuntu/Debian platforms. Add the repository to the APT index, update it, and install Redis Stack:

Install Redis on macOS

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows you how to install Redis on macOS using Homebrew. Homebrew is the easiest way to install Redis on macOS. If you'd prefer to build Redis from the source files on macOS, see Installing Redis from Source.

Note:

The Homebrew distribution of Redis Open Source is only supported on macOS.

Prerequisites

First, make sure you have Homebrew installed. From the terminal, run:

Memory optimization

Mon, 01 Jan 0001 00:00:00 +0000

Special encoding of small aggregate data types

Since Redis 2.2 many data types are optimized to use less space up to a certain size. Hashes, Lists, Sets composed of just integers, and Sorted Sets, when smaller than a given number of elements, and up to a maximum element size, are encoded in a very memory-efficient way that uses up to 10 times less memory (with 5 times less memory used being the average saving).

Modules API for native types

Mon, 01 Jan 0001 00:00:00 +0000

Redis modules can access Redis built-in data structures both at high level, by calling Redis commands, and at low level, by manipulating the data structures directly.

By using these capabilities in order to build new abstractions on top of existing Redis data structures, or by using strings DMA in order to encode modules data structures into Redis strings, it is possible to create modules that feel like they are exporting new data types. However, for more complex problems, this is not enough, and the implementation of new data structures inside the module is needed.

Prepare AWS Aurora PostgreSQL/AWS RDS PostgreSQL for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Prepare AWS Aurora PostgreSQL databases to work with Redis Data Integration.

Prepare Oracle and Oracle RAC for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Redis Open Source quick start

Mon, 01 Jan 0001 00:00:00 +0000

To quickly set up a database with Redis Stack (Redis Open Source) features, you can sign up for a free Redis Cloud subscription and create a Redis Stack database.

Alternatively, you can use one of these methods:

Redis Enterprise Software
Redis Enterprise Software in a Docker container
Other platforms for Redis Enterprise Software

Set up a Redis Cloud database

To set up a Redis Cloud database with Redis Stack features, follow these steps:

RDI on Redis Cloud quick start

Mon, 01 Jan 0001 00:00:00 +0000

The rdi-cloud-automation GitHub repository contains a Terraform script that quickly sets up a PostgreSQL source database on an EC2 instance and all required permissions and network setup to connect it to a Redis Cloud target database.

Note:

This guide is for demonstration purposes only. It is not recommended for production use.

Prerequisites

To follow this guide, you need to:

Quick start using Redis Insight

Mon, 01 Jan 0001 00:00:00 +0000

Make sure that you have Redis Stack installed and running. Alternatively, you can create a free Redis Cloud account.

If you haven't already installed Redis Insight, you can download the latest version here. If this is your first time using Redis Insight, you may wish to read through the Redis Insight guide before continuing with this guide.

Connect to Redis Stack

Open the Redis Insight application, and connect to your database by clicking on its database alias.

Redis Enterprise Software quickstart

Mon, 01 Jan 0001 00:00:00 +0000

This guide helps you install Redis Enterprise Software on a Linux host to test its capabilities.

When finished, you'll have a simple cluster with a single node:

Note:

This quickstart is designed for local testing only. For production environments, see the install and setup guide for deployment options and instructions.

Ensure port availability

If ports that Redis assigns to the database are being used by the operating system or other processes, the installation fails.

Redis 8.4 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 8.4, organized by functional group

Use Redis Insight on Redis Cloud

Mon, 01 Jan 0001 00:00:00 +0000

Redis Insight is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.

You can either install Redis Insight on your computer, or you can open your database in Redis Insight directly on Redis Cloud.

Note:

Opening your database with Redis Insight in your browser is only available for Essentials databases. For all other databases, install Redis Insight on your computer and open Redis Insight from the database page.

To open your database with Redis Insight on Redis Cloud, select Open with Redis Insight on the database screen.

Best practices for Redis Query Engine performance

Mon, 01 Jan 0001 00:00:00 +0000

Note:

If you're using Redis Software or Redis Cloud, see the best practices for scalable Redis Query Engine page.

Checklist

Below are some basic steps to ensure good performance of the Redis Query Engine (RQE).

Schema definition

Mon, 01 Jan 0001 00:00:00 +0000

An index structure is defined by a schema. The schema specifies the fields, their types, whether they should be indexed or stored, and other additional configuration options. By properly configuring the schema, you can optimize search performance and control the storage requirements of your index.

FT.CREATE idx 
    ON HASH 
    PREFIX 1 blog:post: 
SCHEMA 
    title TEXT WEIGHT 5.0
    content TEXT
    author TAG
    created_date NUMERIC SORTABLE
    views NUMERIC

In this example, a schema is defined for an index named idx that will index all hash documents whose keyname starts with blog:post:. The schema includes the fields title, content, author, created_date, and views. The TEXT type indicates that the title and content fields are text-based, the TAG type is used for the author field, and the NUMERIC type is used for the created_date and views fields. Additionally, a weight of 5.0 is assigned to the title field to give it more relevance in search results, and created_date is marked as SORTABLE to enable sorting based on this field.

Secondary indexing

Mon, 01 Jan 0001 00:00:00 +0000

Redis is not exactly a key-value store, since values can be complex data structures. However it has an external key-value shell: at API level data is addressed by the key name. It is fair to say that, natively, Redis only offers primary key access. However since Redis is a data structures server, its capabilities can be used for indexing, in order to create secondary indexes of different kinds, including composite (multi-column) indexes.

Set up Redis for Bedrock

Mon, 01 Jan 0001 00:00:00 +0000

With Amazon Bedrock, users can access foundational AI models from a variety of vendors through a single API, streamlining the process of leveraging generative artificial intelligence.

String internals

Mon, 01 Jan 0001 00:00:00 +0000

Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010). Virtual Memory has been deprecated since Redis 2.6, so this documentation is here only for historical interest.

The implementation of Redis strings is contained in sds.c (sds stands for Simple Dynamic Strings). The implementation is available as a standalone library at https://github.com/antirez/sds.

The C structure sdshdr declared in sds.h represents a Redis string:

Technical overview

Mon, 01 Jan 0001 00:00:00 +0000

Abstract

Redis Query Engine ("RQE") is a powerful text search and secondary indexing engine that is built on top of Redis Open Source.

TLS

Mon, 01 Jan 0001 00:00:00 +0000

SSL/TLS is supported by Redis starting with version 6 as an optional feature that needs to be enabled at compile time.

Getting Started

Building

To build with TLS support you'll need OpenSSL development libraries (e.g. libssl-dev on Debian/Ubuntu).

Upgrade Redis database version

Mon, 01 Jan 0001 00:00:00 +0000

You can upgrade databases that are not on the latest available version of Redis to a later version at any time.

Note:

Please keep in mind the following before upgrading your database version:

We recommend that you back up your data before upgrading to make it easier to manually revert the upgrade if needed.

User functions

Mon, 01 Jan 0001 00:00:00 +0000

All TFCALL command arguments that follow the function name are passed to the function callback. The following example shows how to implement a simple function that returns the value of a key of type string or hash:

#!js api_version=1.0 name=lib

redis.registerFunction('my_get', function(client, key_name){
    if (client.call('type', key_name) == 'string') {
        return client.call('get', key_name);
    }
    if (client.call('type', key_name) == 'hash') {
        return client.call('hgetall', key_name);
    }
    throw "Unsupported type";
});

Example of running the preceding function:

127.0.0.1:6379> set x 1
OK
127.0.0.1:6379> TFCALL lib.my_get 1 x
"1"
127.0.0.1:6379> hset h a b x y
(integer) 2
127.0.0.1:6379> TFCALL lib.my_get 1 h
1) "a"
2) "b"
3) "x"
4) "y"

It is also possible to get all the function arguments as a JS array. This is how we can extend the above example to accept multiple keys and return their values:

Virtual memory (deprecated)

Mon, 01 Jan 0001 00:00:00 +0000

Note: This document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010). Virtual Memory was deprecated in Redis 2.4 and removed in Redis 2.6, so this documentation exists only for historical interest.

This document details the internals of the Redis Virtual Memory subsystem prior to Redis 2.6. The intended audience is not the final user but programmers willing to understand or modify the Virtual Memory implementation.

Install Redis on Windows

Mon, 01 Jan 0001 00:00:00 +0000

Run Redis on Windows using Memurai

Redis is now natively supported on Windows through Memurai, the official Redis partner for Windows compatibility.

RedisInsight v2.16.0, December 2022

Wed, 28 Dec 2022 00:00:00 +0000

2.16.0 (December 2022)

This is the General Availability (GA) release of RedisInsight 2.16.

Redis Enterprise for Kubernetes 7.2.4-12 (June 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-130. For information on supported distributions, breaking changes, and limitations, see the previous 7.2.4-12 release notes.

Redis Enterprise for Kubernetes 7.2.4-15 (September 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-138. For information on supported distributions, breaking changes, and limitations, see the previous 7.2.4-12 release notes.

Redis Enterprise for Kubernetes 7.22.0-16 (August 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.0-241. For version changes, supported distributions, and known limitations, see the release notes for 7.22.0-15 (July 2025).

Redis Enterprise for Kubernetes 7.22.2-22 (October 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.2-20. For version changes, supported distributions, and known limitations, see the 7.22.2 releases.

Redis Enterprise for Kubernetes 7.4.6-7 (September 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-272. For version changes, supported distributions, and known limitations, see the release notes for 7.4.6.

Redis Enterprise for Kubernetes 7.8.2-6 (Jan 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.8.2-60. For version changes, supported distributions, and known limitations, see the release notes for 7.8.2-6 (Nov 2024).

Redis Enterprise for Kubernetes 7.8.4-8 (Feb 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

This release includes bug fixes, enhancements, and support for Redis Enterprise Software version 7.8.4-66.

New in this release

Enhancements

Support for a read-only file system on Redis Enterprise containers (RED-75139).
Support for Redis Enterprise Software version 7.8.4-66.

Resolved issues

Fixed log collector handling of STDERR warnings (RED-148292).

API changes

CRD	Field	Change	Description
REC	spec.SecurityContext.readOnlyRootFilesystemPolicy.enabled	Add	Enables the read-only filesystem

Supported distributions

The following table shows supported distributions at the time of this release. You can also find this list in Supported Kubernetes distributions.

Redis Enterprise for Kubernetes 7.8.6-5 (August 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 7.8.6-5 (August 2025) is a maintenance release that includes support for Redis Software 7.8.6-152.

For supported distributions, known limitations, and API changes, see Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes.

Downloads

Redis Enterprise: redislabs/redis:7.8.6-152
Operator: redislabs/operator:7.8.6-5
Services Rigger: redislabs/k8s-controller:7.8.6-5
OLM operator bundle : v7.8.6-5.1

Known limitations

See 7.8.6 releases for information on known limitations.

Install Redis Open Source on Linux

Mon, 01 Jan 0001 00:00:00 +0000

Install Redis Open Source on Ubuntu or Debian Linux using APT

Add the repository to the APT index, update it, and install Redis Open Source:

Client-side caching reference

Mon, 01 Jan 0001 00:00:00 +0000

Note:

This document is intended as an in-depth reference for client-side caching. See Client-side caching introduction for general usage guidelines.

Client-side caching is a technique used to create high performance services. It exploits the memory available on application servers, servers that are usually distinct computers compared to the database nodes, to store some subset of the database information directly in the application side.

Redis configuration

Mon, 01 Jan 0001 00:00:00 +0000

Redis is able to start without a configuration file using a built-in default configuration, however this setup is only recommended for testing and development purposes.

The proper way to configure Redis is by providing a Redis configuration file, usually called redis.conf. Beginning with Redis 8 in Redis Open Source, there are two configuration files:

redis.conf - contains the configuration settings for Redis server only.
redis-full.conf - contains configuration settings for Redis server and all available components: Redis Query Engine, Redis time series, and Redis probabilistic data structures. This file has as its first line include redis.conf, which pulls in the Redis server configuration settings at startup. Use redis-full.conf when you want to enable all available components. The file contains four loadmodule directives, one for each component, and also loads Redis JSON (though JSON has no configuration parameters).

If you are building Redis from source and choose to build Redis server without the available components, you can use redis.conf as your configuration file.

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Note:

Jedis 7.2.0 introduced a new client connection API:

New API class	Replaces	Use case
`RedisClient`	`UnifiedJedis`, `JedisPool`, `JedisPooled`	Single connection (with connection pooling)
`RedisClusterClient`	`JedisCluster`	Redis Cluster connections
`RedisSentinelClient`	`JedisSentinelPool`	Redis Sentinel connections

The old client classes are now considered deprecated.

Basic connection

The following code opens a basic connection to a local Redis server:

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Start by creating a connection to your Redis server. There are many ways to achieve this using Lettuce. Here are a few.

Basic connection

import io.lettuce.core.*;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

public class ConnectBasicTest {

    public void connectBasic() {
        RedisURI uri = RedisURI.Builder
                .redis("localhost", 6379)
                .withAuthentication("default", "yourPassword")
                .build();
        RedisClient client = RedisClient.create(uri);
        StatefulRedisConnection<String, String> connection = client.connect();
        RedisCommands<String, String> commands = connection.sync();

        commands.set("foo", "bar");
        String result = commands.get("foo");
        System.out.println(result); // >>> bar

        connection.close();

        client.shutdown();
    }
}

Connect to a Redis cluster

To connect to a Redis cluster, use RedisClusterClient.

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Basic connection

Connect to localhost on port 6379.

Connect to Azure Managed Redis

Mon, 01 Jan 0001 00:00:00 +0000

The redis-authx-entraid package lets you authenticate your app to Azure Managed Redis (AMR) using Microsoft Entra ID. You can authenticate using a system-assigned or user-assigned managed identity or a service principal, letting redis-authx-entraid fetch and renew the authentication tokens for you automatically.

See Use Microsoft Entra for cache authentication in the Microsoft docs to learn how to configure Azure to use Entra ID authentication.

Install

Install jedis first, if you have not already done so.

Connect to Azure Managed Redis

Mon, 01 Jan 0001 00:00:00 +0000

See Use Microsoft Entra for cache authentication in the Microsoft docs to learn how to configure Azure to use Entra ID authentication.

Install

Install Lettuce first, if you have not already done so.

Connect to Azure Managed Redis

Mon, 01 Jan 0001 00:00:00 +0000

The @redis/entraid package lets you authenticate your app to Azure Managed Redis (AMR) using Microsoft Entra ID. You can authenticate using a system-assigned or user-assigned managed identity, a service principal, an auth code flow, or a DefaultAzureCredential instance. The @redis/entraid code fetches and renews the authentication tokens for you automatically.

Install

Install node-redis and @redis/entraid with the following commands:

Create and edit Cloud accounts

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud Bring your own Cloud (BYOC) lets you use your own cloud infrastructure to deploy Redis Cloud.

You can associate your existing AWS account as a cloud account for your subscription. This requires setting up and entering credentials that enable monitoring, maintenance, and technical support of your subscription.

To do this, you need:

A programmatic user with an access key and a secret access key for that user.
A console role that allows administrative access to the cloud account.

You need to create these resources before adding the cloud account to your subscription. To learn more, see Create IAM resources.

Create a Bedrock knowledge base

Mon, 01 Jan 0001 00:00:00 +0000

With Amazon Bedrock, users can access foundational AI models from a variety of vendors through a single API, streamlining the process of leveraging generative artificial intelligence.

Create a free database

Mon, 01 Jan 0001 00:00:00 +0000

Free databases are perfect for learning and exploring Redis. You get 30 MB of space for you to learn Redis concepts and develop application prototypes.

Note:

You can only have one free database per account. If you already have a free database, you can delete it or upgrade it to a paid Essentials plan before creating a new one.

Before creating a Redis Cloud database, you need to create an account.

Docker quickstart for Redis Enterprise Software

Mon, 01 Jan 0001 00:00:00 +0000

Warning:

Docker containers are currently only supported for development and test environments, not for production. Use Redis Enterprise on Kubernetes for a supported containerized deployment.

For testing purposes, you can run Redis Enterprise Software on Docker containers on Linux, Windows, or MacOS. The Redis Enterprise Software container acts as a node in a cluster.

Redis as a document database quick start guide

Mon, 01 Jan 0001 00:00:00 +0000

This quick start guide shows you how to:

Create a secondary index
Add JSON documents
Search and query your data

The examples in this article refer to a simple bicycle inventory that contains JSON documents with the following structure:

{
  "brand": "brand name",
  "condition": "new | used | refurbished",
  "description": "description",
  "model": "model",
  "price": 0
}

Setup

The easiest way to get started with Redis is to use Redis Cloud:

Field and type options

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source provides various field types that allow you to store and search different kinds of data in your indexes. This page explains the available field types, their characteristics, and how they can be used effectively.

Numeric fields

Numeric fields are used to store non-textual, countable values. They can hold integer or floating-point values. Numeric fields are sortable, meaning you can perform range-based queries and retrieve documents based on specific numeric conditions. For example, you can search for documents with a price between a certain range or retrieve documents with a specific rating value.

Garbage collection

Mon, 01 Jan 0001 00:00:00 +0000

The need for garbage collection

When documents are deleted by the user, Redis only marks them as deleted in the global document table rather than deleting them outright. This is done for efficiency. Depending on the length of a document, deletion can be a long operation.
This means that it is no longer the case that an internal numeric id is assigned to a deleted document. When the index is traversed, a check is made for deletion.
All inverted index entries belonging to deleted document ids are garbage.
Updating a document is basically the same as deleting it and then adding it again with a new incremental internal ID. No diffing is performed, and the indexes are appended, so the IDs remain incremental, and the updates fast.

All of the above means that if there are a lot of updates and deletes, a large portion of our inverted index will become garbage, both slowing things down and consuming unnecessary memory.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v6.0.0 onwards, Jedis uses query dialect 2 by default. Redis query engine methods such as ftSearch() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the Jedis client library if you haven't already done so.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the Lettuce client library if you haven't already done so.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v5.0.0 onwards, node-redis uses query dialect 2 by default. Redis query engine methods such as ft.search() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the node-redis client library if you haven't already done so.

Index/Search JSON documents

Mon, 01 Jan 0001 00:00:00 +0000

In addition to storing JSON documents, you can also index them using the Redis Query Engine feature. This enables full-text search capabilities and document retrieval based on their content.

To use these features, install Redis Open Source.

See the tutorial to learn how to search and query your JSON.

Install

Mon, 01 Jan 0001 00:00:00 +0000

RIOT can be installed in different ways depending on your environment and preference.

macOS via Homebrew

brew install redis/tap/riot

Windows via Scoop

scoop bucket add redis https://github.com/redis/scoop.git
scoop install riot

Linux via Homebrew

brew install redis/tap/riot

Docker

docker run riotx/riot [OPTIONS] [COMMAND]

Manual installation

Download the pre-compiled binary from the releases page, uncompress, and copy to the desired location.

Install on Docker

Mon, 01 Jan 0001 00:00:00 +0000

This tutorial shows how to install Redis Insight on Docker so you can use Redis Insight in development. See a separate guide for installing Redis Insight on AWS.

Install Docker

The first step is to install Docker for your operating system.

Install RedisVL

Mon, 01 Jan 0001 00:00:00 +0000

Installation

Install the redisvl package into your Python (>=3.8) environment using the pip command:

JavaScript API

Mon, 01 Jan 0001 00:00:00 +0000

Redis object

Since version: 2.0.0

The triggers and functions JavaScript API provides a singleton instance of an object named redis. The redis instance enables registered functions to interact with the Redis server on which they are running. Following is the API provided by the redis instance.

Keyspace triggers

Mon, 01 Jan 0001 00:00:00 +0000

Keyspace triggers allow you to register a function that will be executed whenever an event occurs in the database. Most events are triggered by command invocations, but there are two special events that can occur independently of a command:

Expired: This event is fired when a key expires from the database.
Evicted: This event is fired when a key is evicted from the database.

For a complete list of supported events, please refer to the Redis keyspace notifications page.

Scripting with Lua

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets users upload and execute Lua scripts on the server. Scripts can employ programmatic control structures and use most of the commands while executing to access the database. Because scripts execute in the server, reading and writing data from scripts is very efficient.

Redis guarantees the script's atomic execution. While executing the script, all server activities are blocked during its entire runtime. These semantics mean that all of the script's effects either have yet to happen or had already happened.

Install Redis Stack on macOS

Mon, 01 Jan 0001 00:00:00 +0000

To install Redis Stack on macOS, use Homebrew. Make sure that you have Homebrew installed before starting on the installation instructions below.

There are three brew casks available.

redis-stack contains both redis-stack-server and redis-stack-redisinsight casks.
redis-stack-server provides Redis Stack server only.
redis-stack-redisinsight contains Redis Insight.

Install using Homebrew

First, tap the Redis Stack Homebrew tap:

Prepare AWS Aurora MySQL/AWS RDS MySQL for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Prepare AWS Aurora MySQL and AWS RDS MySQL databases to work with Redis Data Integration.

Prepare MongoDB for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Prepare MySQL/MariaDB for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Prepare PostgreSQL/Supabase for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Prepare source database

Mon, 01 Jan 0001 00:00:00 +0000

Create new data pipeline

In the Redis Cloud console, go to your target database and select the Data Pipeline tab.

Prepare Spanner for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Prepare SQL Server for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Vector quantization and compression

Mon, 01 Jan 0001 00:00:00 +0000

Efficient management of high-dimensional vector data is crucial for scalable search and retrieval. Advanced methods for vector quantization and compression, such as LVQ (Locally-adaptive Vector Quantization) and LeanVec, can dramatically optimize memory usage and improve search speed, without sacrificing much accuracy. This page describes practical approaches to quantizing and compressing vectors for scalable search.

Warning:

Some advanced vector compression features may depend on hardware or Intel's proprietary optimizations. Intel's proprietary LVQ and LeanVec optimizations are not available in Redis Open Source. On non-Intel platforms and Redis Open Source platforms, SVS-VAMANA with COMPRESSION will fall back to basic, 8-bit scalar quantization implementation: all values in a vector are scaled using the global minimum and maximum, and then each dimension is quantized independently into 256 levels using 8-bit precision.

Quantization and compression techniques

LVQ (Locally-adaptive Vector Quantization)

Method: Applies per-vector normalization and scalar quantization; learns parameters directly from the data.
Advantages:
- Enables fast, on-the-fly distance computations.
- SIMD-optimized layout for efficient search.
- Learns compression parameters from representative vectors.
Variants:
- LVQ4x4: 8 bits per dimension, fast search, large memory savings.
- LVQ8: Faster ingestion, slower search.
- LVQ4x8: Two-level quantization for improved recall.

LeanVec (LVQ with dimensionality reduction)

Method: Combines dimensionality reduction with LVQ, applying quantization after reducing vector dimensions.
Advantages:
- Best suited for high-dimensional vectors.
- Significant speed and memory improvements.
Variants:
- LeanVec4x8: Recommended for high-dimensional datasets, fastest search and ingestion.
- LeanVec8x8: Improved recall when more granularity is needed.
LeanVec Dimension: For faster search and lower memory usage, reduce the dimension further by using the optional REDUCE argument. The default is typically input dimension / 2, but more aggressive reduction (such as input dimension / 4) is possible for greater efficiency.

Choosing a compression type

Compression type	Best for	Observations
LVQ4x4	Fast search and low memory use	Consider LeanVec for even faster search
LeanVec4x8	Fastest search and ingestion	LeanVec dimensionality reduction might reduce recall
LVQ4	Maximum memory saving	Recall might be insufficient
LVQ8	Faster ingestion than LVQ4x4	Search likely slower than LVQ4x4
LeanVec8x8	Improved recall when LeanVec4x8 is insufficient	LeanVec dimensionality reduction might reduce recall
LVQ4x8	Improved recall when LVQ4x4 is insufficient	Slightly worse memory savings

Two-level compression

Both LVQ and LeanVec support two-level compression schemes. LVQ's two-level compression works by first quantizing each vector individually to capture its main structure, then encoding the residual error—the difference between the original and quantized vector—using a second quantization step. This allows fast search using only the first level, with the second level used for re-ranking to boost accuracy when needed.

Querying with RedisVL

Mon, 01 Jan 0001 00:00:00 +0000

In this notebook, we will explore more complex queries that can be performed with redisvl

Before running this notebook, be sure to

Have installed redisvl and have that environment active for this notebook.
Have a running Redis instance with RediSearch > 2.4 running.

import pickle
from jupyterutils import table_print, result_print

# load in the example data and printing utils
data = pickle.load(open("hybrid_example_data.pkl", "rb"))
table_print(data)

user	age	job	credit_score	office_location	user_embedding	last_updated
john	18	engineer	high	-122.4194,37.7749	b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'	1741627789
derrick	14	doctor	low	-122.4194,37.7749	b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'	1741627789
nancy	94	doctor	high	-122.4194,37.7749	b'333?\xcd\xcc\xcc=\x00\x00\x00?'	1710696589
tyler	100	engineer	high	-122.0839,37.3861	b'\xcd\xcc\xcc=\xcd\xcc\xcc>\x00\x00\x00?'	1742232589
tim	12	dermatologist	high	-122.0839,37.3861	b'\xcd\xcc\xcc>\xcd\xcc\xcc>\x00\x00\x00?'	1739644189
taimur	15	CEO	low	-122.0839,37.3861	b'\x9a\x99\x19?\xcd\xcc\xcc=\x00\x00\x00?'	1742232589
joe	35	dentist	medium	-122.0839,37.3861	b'fff?fff?\xcd\xcc\xcc='	1742232589

schema = {
    "index": {
        "name": "user_queries",
        "prefix": "user_queries_docs",
        "storage_type": "hash", # default setting -- HASH
    },
    "fields": [
        {"name": "user", "type": "tag"},
        {"name": "credit_score", "type": "tag"},
        {"name": "job", "type": "text"},
        {"name": "age", "type": "numeric"},
        {"name": "last_updated", "type": "numeric"},
        {"name": "office_location", "type": "geo"},
        {
            "name": "user_embedding",
            "type": "vector",
            "attrs": {
                "dims": 3,
                "distance_metric": "cosine",
                "algorithm": "flat",
                "datatype": "float32"
            }

        }
    ],
}

from redisvl.index import SearchIndex

# construct a search index from the schema
index = SearchIndex.from_dict(schema, redis_url="redis://localhost:6379")

# create the index (no data yet)
index.create(overwrite=True)

# use the CLI to see the created index
!rvl index listall

13:00:56 [RedisVL] INFO   Indices:
13:00:56 [RedisVL] INFO   1. user_queries

# load data to redis
keys = index.load(data)

index.info()['num_docs']

Hybrid Queries

Hybrid queries are queries that combine multiple types of filters. For example, you may want to search for a user that is a certain age, has a certain job, and is within a certain distance of a location. This is a hybrid query that combines numeric, tag, and geographic filters.

Quick start using redis-cli

Mon, 01 Jan 0001 00:00:00 +0000

Make sure that you have Redis Stack installed and running. Alternatively, you can create a free Redis Cloud account. The triggers and functions preview is available in the fixed subscription plan for the Google Cloud Asia Pacific (Tokyo) and AWS Asia Pacific (Singapore) regions.

Connect to Redis Stack

> redis-cli -h 127.0.0.1 -p 6379

Load a library

Use the TFUNCION LOAD command to create a new library in your Redis instance.

Range queries

Mon, 01 Jan 0001 00:00:00 +0000

A range query on a numeric field returns the values that are in between a given start and end value:

FT.SEARCH index "@field:[start end]"

You can also use the FILTER argument, but you need to know that the query execution plan is different because the filter is applied after the query string (e.g., *) is evaluated:

FT.SEARCH index "*" FILTER field start end

Start and end values

Start and end values are by default inclusive, but you can prepend ( to a value to exclude it from the range.

Redis 8.2 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 8.2, organized by functional group

Redis design draft #2 (historical)

Mon, 01 Jan 0001 00:00:00 +0000

Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2013), as part of a series of design drafts. This is preserved for historical interest.

Redis Design Draft 2 -- RDB version 7 info fields

Author: Salvatore Sanfilippo antirez@gmail.com
GitHub issue #1048

History of revisions

1.0, 10 April 2013 - Initial draft.

Redis vector library guide (Python)

Mon, 01 Jan 0001 00:00:00 +0000

See the RedisVL Guide for more information.

Move from Development to Production with Redis Query Engine

Mon, 01 Jan 0001 00:00:00 +0000

Transitioning a Redis Open Source with Redis Query Engine (RQE) environment from development to production requires thoughtful consideration of configuration, performance tuning, and resource allocation. This guide outlines key practices to ensure your Redis deployment operates optimally under production workloads.

Configuration parameter considerations

RQE offers several configurable parameters that influence query results and performance. While a full list of these parameters and their functions can be found here, this section highlights the most commonly adjusted parameters for production environments.

Sentinel client spec

Mon, 01 Jan 0001 00:00:00 +0000

Redis Sentinel is a monitoring solution for Redis instances that handles automatic failover of Redis masters and service discovery (who is the current master for a given group of instances?). Since Sentinel is both responsible for reconfiguring instances during failovers, and providing configurations to clients connecting to Redis masters or replicas, clients are required to have explicit support for Redis Sentinel.

This document is targeted at Redis clients developers that want to support Sentinel in their clients implementation with the following goals:

Stream triggers

Mon, 01 Jan 0001 00:00:00 +0000

Redis Stack's triggers and functions feature comes with a full stream API to process data from Redis streams. Unlike RedisGears v1 that provided a micro batching API, the new triggers and functions feature provides a real streaming API, which means that the data will be processed as soon as it enters the stream.

Register a stream consumer

Triggers and functions provide an API that allows to register a stream trigger. Do not get confused with Redis streams consumer groups, triggers and functions uses the Redis Module API to efficiently read the stream and manage its consumers. This approach gives a much better performance as there is no need to invoke any Redis commands in order to read from the stream. Lets see a simple example:

RedisInsight v2.14.0, November 2022

Mon, 28 Nov 2022 00:00:00 +0000

2.14.0 (November 2022)

This is the General Availability (GA) release of RedisInsight 2.14.

Redis Enterprise for Kubernetes 7.2.4-12 (March 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-122. For information on supported distributions, breaking changes, and limitations, see the previous 7.2.4-12 release notes.

Redis Enterprise for Kubernetes 7.22.0-15 (July 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

Helm chart support is now generally available.

New in this release

Redis Enterprise for Kubernetes 7.22.0-15 is a feature release that includes enhancements, platform updates, and support for Redis Software 7.22.0-216.

Redis Enterprise for Kubernetes 7.22.2-21 (October 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.2-14. For version changes, supported distributions, and known limitations, see the 7.22.0 releases.

Redis Enterprise for Kubernetes 7.4.6-6 (June 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-268. For version changes, supported distributions, and known limitations, see the release notes for 7.4.6.

Redis Enterprise for Kubernetes 7.8.2-6 (Nov 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

New in this release

Enhancements

Parallel startup and recovery (enabled by default) (RED-117645).
Azure marketplate deployment (RED-113029)
Support for Redis Software 7.8.2-34.
Improved upgrade validations for modules and Redis database versions (RED-132197).
Support for Community Kubernetes 1.31 (RED-13549).
New minimal roles required to use the log collector (RED-132686).
Support proxy certificate updates for Active-Active databases (RED-122552).
Add directory_timeout_s field to LDAP configuration (RED-119079).
Allow configuring port number for replication endpoints in Active-Active databases (RED-113626).

Resolved issues

Fixed documentation for REAADB globalConfigurations field (RED-138727).
Allow log collector execution without kubectl installed (RED-131537).
Fix recreation issue for rec-bulletin-board config map (RED-130599).
Avoid deletion of operator config maps created by users (RED-129214).
Fixed errors shown in bootstrapper logs (RED-125776).
Limit the number of calls made to Vault (RED-125396).
Fixed log collector issue with detecting version (RED-121144).

API changes

CRD	Field	Change	Description
REC	`status.CertificatesUpdateStatus`	Rename	Renamed status field and changed the structure
REC	`status.state`	Add value to enum	`runningRollingUpgrade`
REDB	`spec.modulesList`	Field enabled	Don't need to set `ENABLE_ALPHA_FEATURES` to enable.
RERC	`spec.apiPort`	Added
REDB	`redb.upgradeSpec.upgradeModulesToLatest`	Changed default	Default is now `true`

Version changes

Breaking changes

RHEL9-based images

Redis Enterprise images are now based on Red Hat Enterprise Linux 9 (RHEL9). This means upgrades to 7.8.2-6 require:

Redis Enterprise for Kubernetes 7.8.6-3 (June 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 7.8.6-3 (June 2025) is a maintenance release that includes support for Redis Software 7.8.6-119.

For supported distributions, known limitations, and API changes, see Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes.

Downloads

Redis Enterprise: redislabs/redis:7.8.6-119
Operator: redislabs/operator:7.8.6-3
Services Rigger: redislabs/k8s-controller:7.8.6-3
OLM operator bundle : v7.8.6-3.2

Known limitations

See 7.8.6 releases for information on known limitations.

Command key specifications

Mon, 01 Jan 0001 00:00:00 +0000

Many of the commands in Redis accept key names as input arguments. The 9th element in the reply of COMMAND (and COMMAND INFO) is an array that consists of the command's key specifications.

A key specification describes a rule for extracting the names of one or more keys from the arguments of a given command. Key specifications provide a robust and flexible mechanism, compared to the first key, last key and step scheme employed until Redis 7.0. Before introducing these specifications, Redis clients had no trivial programmatic means to extract key names for all commands.

Configuration Parameters

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source - set configuration parameters

Before Redis 8 in Redis Open Source (version 8.0), all time series configuration parameters are load-time parameters. Use one of the following methods to set the values of load-time configuration parameters:

Configuration

Mon, 01 Jan 0001 00:00:00 +0000

Redis Stack's triggers and functions feature provides configuration options to control its operation. These options can be set when the module is bootstrapped and, in some cases, at runtime.

The following sections describe the configuration options and how to set them.

Bootstrap configuration

You can set your configuration options when the module is loaded. When the module is loaded at start time, the module configuration can be defined in the Redis configuration file. When loading the module at runtime the configuration can be given to the MODULE LOADEX command. Each configuration must be prefixed with the module name, redisgears_2.<configuration name>.

Create a Bedrock agent

Mon, 01 Jan 0001 00:00:00 +0000

With Amazon Bedrock, users can access foundational AI models from a variety of vendors through a single API, streamlining the process of leveraging generative artificial intelligence.

Define data pipeline

Mon, 01 Jan 0001 00:00:00 +0000

After you have prepared your source database and connection information, you can set up your new pipeline. To do this:

Define the source connection by entering all required source database information.
Define the data pipeline by selecting the data that you want to sync from your source database to the target database.

Define source connection

In the Redis Cloud console, go to your target database and select the Data Pipeline tab.

Developer notes

Mon, 01 Jan 0001 00:00:00 +0000

Developing RediSearch features involves setting up a development environment (which can be either Linux-based or macOS-based), building the module, running tests and benchmarks, and debugging both the module and its tests.

Cloning the git repository

Run the following command to clone the RediSearch module and its submodules:

Full-text search

Mon, 01 Jan 0001 00:00:00 +0000

A full-text search finds words or phrases within larger texts. You can search within a specific text field or across all text fields.

This article provides a good overview of the most relevant full-text search capabilities. Please find further details about all the full-text search features in the reference documentation.

The examples in this article use a schema with the following fields:

Field name	Field type
`brand`	`TEXT`
`model`	`TEXT`
`description`	`TEXT`

Single word

To search for a word (or word stem) across all text fields, you can construct the following simple query:

Geospatial indexing

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports two different schema types for geospatial data:

GEO: This uses a simple format where individual geospatial points are specified as numeric longitude-latitude pairs.
GEOSHAPE: This uses a subset of the Well-Known Text (WKT) format to specify both points and polygons using either geographical coordinates or Cartesian coordinates.

The sections below explain how to index these schema types. See the Geospatial reference page for a full description of both types.

`GEO`

The following command creates a GEO index for JSON objects that contain the geospatial data in a field called location:

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Redis Query Engine lets you index vector fields in hash or JSON objects (see the Vectors reference page for more information). Among other things, vector fields can store text embeddings, which are AI-generated vector representations of the semantic information in pieces of text. The vector distance between two embeddings indicates how similar they are semantically. By comparing the similarity of an embedding generated from some query text with embeddings stored in hash or JSON fields, Redis can retrieve documents that closely match the query in terms of their meaning.

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Redis Query Engine lets you index vector fields in hash or JSON objects (see the Vectors reference page for more information).

Vector fields can store text embeddings, which are AI-generated vector representations of text content. The vector distance between two embeddings measures their semantic similarity. When you compare the similarity of a query embedding with stored embeddings, Redis can retrieve documents that closely match the query's meaning.

In the example below, we use the @xenova/transformers library to generate vector embeddings to store and index with Redis Query Engine. The code is first demonstrated for hash documents with a separate section to explain the differences with JSON documents.

Install on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

This tutorial shows how to install Redis Insight on Kubernetes (K8s). This is an easy way to use Redis Insight with a Redis Enterprise K8s deployment.

Create the Redis Insight deployment and service

Below is an annotated YAML file that will create a Redis Insight deployment and a service in a K8s cluster.

LLM Caching

Mon, 01 Jan 0001 00:00:00 +0000

This notebook demonstrates how to use RedisVL's SemanticCache to cache LLM responses based on semantic similarity. Semantic caching can significantly reduce API costs and latency by retrieving cached responses for semantically similar prompts instead of making redundant API calls.

Key features covered:

Basic cache operations (store, check, clear)
Customizing semantic similarity thresholds
TTL policies for cache expiration
Performance benchmarking
Access controls with tags and filters for multi-user scenarios

Prerequisites:

Ensure redisvl is installed in your Python environment
Have a running instance of Redis Stack or Redis Cloud
OpenAI API key for the examples

First, we will import OpenAI to use their API for responding to user prompts. We will also create a simple ask_openai helper method to assist.

Redis Lua API reference

Mon, 01 Jan 0001 00:00:00 +0000

Redis includes an embedded Lua 5.1 interpreter. The interpreter runs user-defined ephemeral scripts and functions. Scripts run in a sandboxed context and can only access specific Lua packages. This page describes the packages and APIs available inside the execution's context.

Sandbox context

The sandboxed Lua context attempts to prevent accidental misuse and reduce potential threats from the server's environment.

Path

Mon, 01 Jan 0001 00:00:00 +0000

Paths let you access specific elements within a JSON document. Since no standard for JSON path syntax exists, Redis JSON implements its own. JSON's syntax is based on common best practices and intentionally resembles JSONPath.

JSON supports two query syntaxes: JSONPath syntax and the legacy path syntax from the first version of JSON.

JSON knows which syntax to use depending on the first character of the path query. If the query starts with the character $, it uses JSONPath syntax. Otherwise, it defaults to the legacy path syntax.

Pipeline configuration file

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Prepare Microsoft SQL Server on AWS RDS for RDI

Mon, 01 Jan 0001 00:00:00 +0000

Prepare Microsoft SQL Server on AWS RDS databases to work with Redis Data Integration.

Quick Start

Mon, 01 Jan 0001 00:00:00 +0000

You can launch RIOT with the following command:

riot

This will show usage help, which you can also get by running:

riot --help

Tip:

You can use --help on any command and sub-command:

riot command --help
riot command sub-command --help

Full documentation is available at redis.github.io/riot.

Redis 8.0 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 8.0, organized by functional group

Redis Copilot FAQ

Mon, 01 Jan 0001 00:00:00 +0000

General questions

What is Redis Copilot?

Redis Copilot is an AI-powered developer assistant that helps you learn about Redis, explore your Redis data, and build search queries in a conversational manner. It is available in our flagship visual GUI developer tool, Redis Insight, as well as within the Redis public documentation (general chatbot).

Install Redis Open Source on Linux

Mon, 01 Jan 0001 00:00:00 +0000

Install Redis Open Source on Rocky Linux 8 and 9, or AlmaLinux 8 and 9 using RPM

Follow these steps to install Redis Open Source.

Index management best practices for Redis Query Engine

Mon, 01 Jan 0001 00:00:00 +0000

Introduction to managing Redis Query Engine indexes

The Redis Query Engine (RQE) is a powerful tool for executing complex search and query operations on structured, semi-structured, and unstructured data. Indexes are the backbone of this functionality, enabling fast and efficient data retrieval. Proper management of these indexes is essential for optimal performance, scalability, and resource utilization.

Sync and async

Mon, 01 Jan 0001 00:00:00 +0000

By default, each time a function is invoked, it is executed synchronously. This ensures the atomicity property, meaning that no other commands will be executed on Redis while the function is running. The atomicity property offers several advantages:

Multiple keys can be updated simultaneously, guaranteeing that other clients see the complete update rather than partial updates.
The data in Redis remains unchanged while it is being processed.

However, the major disadvantage of the atomicity property is that Redis is blocked throughout the entire invocation, preventing it from serving other clients.

Redis as a vector database quick start guide

Mon, 01 Jan 0001 00:00:00 +0000

This quick start guide helps you to:

Understand what a vector database is
Create a Redis vector database
Create vector embeddings and store vectors
Query data and perform a vector search

Note:

This guide uses RedisVL, which is a Python client library for Redis that is highly specialized for vector processing. You may also be interested in the vector query examples for our other client libraries:

Redis 8.4

Mon, 01 Jan 0001 00:00:00 +0000

Redis 8.4 builds on the foundation of Redis 8.2 with significant enhancements to cluster operations, string manipulation, and stream processing capabilities.

This release delivers major improvements across multiple areas:

Atomic cluster slot migration for zero-downtime operations
Enhanced string operations with atomic compare-and-set functionality
Advanced stream processing with idle entry claiming
Hybrid search capabilities combining multiple ranking algorithms
High-performance SIMD optimizations for bit operations and vector processing
Improved JSON handling with better memory efficiency

Below is a detailed breakdown of these updates.

Install Redis Stack on Windows

Mon, 01 Jan 0001 00:00:00 +0000

To install Redis Stack on Windows, you will need to have Docker installed. When Docker is up and running, open Windows PowerShell and follow the instructions described in Run Redis Stack on Docker. Then, use Docker to connect with redis-cli as explained in that topic.

About using WSL and Ubuntu for Windows :

If you attempt to use Windows Subsystem for Linux (WSL) or Ubuntu for Windows to follow Linux instructions, you will get a systemd error telling you System has not been booted with systemd as init system (PID 1). Can't operate. Do not fret. Just use Docker.

RedisInsight v2.12.0, October 2022

Thu, 29 Sep 2022 00:00:00 +0000

2.12.0 (October 2022)

This is the General Availability (GA) release of RedisInsight 2.12.

Redis Enterprise for Kubernetes 7.2.4-12 (January 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-118. For information on supported distributions, breaking changes, and limitations, see the previous (7.2.4-12 release notes)/docs/latest/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-10-24/.

Redis Enterprise for Kubernetes 7.22.0-11 (June 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.22.0-95. For version changes, supported distributions, and known limitations, see the release notes for 7.22.0-7 (April 2025).

Redis Enterprise for Kubernetes 7.4.6-6 (March 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-232. For version changes, supported distributions, and known limitations, see the release notes for 7.4.6.

Redis Enterprise for Kubernetes 7.8.6-2 (June 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 7.8.6-2 (June 2025) is a maintenance release that includes support for Redis Software 7.8.6-95.

For supported distributions, known limitations, and API changes, see Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes.

Downloads

Redis Enterprise: redislabs/redis:7.8.6-95
Operator: redislabs/operator:7.8.6-2
Services Rigger: redislabs/k8s-controller:7.8.6-2
OLM operator bundle : v7.8.6-2.2

Known limitations

See 7.8.6 releases for information on known limitations.

FT.AGGREGATE order of operations

Mon, 01 Jan 0001 00:00:00 +0000

Overview

FT.AGGREGATE is a powerful Redis Query Engine (RQE) command for performing advanced data aggregation, filtering, sorting, and transformations on indexed hash or JSON documents. This reference page provides a structured breakdown of syntax, ordering rules, and best practices.

Cluster support

Mon, 01 Jan 0001 00:00:00 +0000

Notice: On a Redis Open Source cluster, before executing any gears function, you must send a REDISGEARS_2.REFRESHCLUSTER command to all the shards so that they will be aware of the cluster topology. Without this step, each shard will act as a single Redis Open Source instance.

Triggers and functions support cross-shard operation on Redis clusters. This means that it is possible to call a function that will be invoked on another shard. We call such a function a remote function.

Debugging Lua scripts in Redis

Mon, 01 Jan 0001 00:00:00 +0000

Starting with version 3.2 Redis includes a complete Lua debugger, that can be used in order to make the task of writing complex Redis scripts much simpler.

The Redis Lua debugger, codenamed LDB, has the following important features:

It uses a server-client model, so it's a remote debugger. The Redis server acts as the debugging server, while the default client is redis-cli. However other clients can be developed by following the simple protocol implemented by the server.
By default every new debugging session is a forked session. It means that while the Redis Lua script is being debugged, the server does not block and is usable for development or in order to execute multiple debugging sessions in parallel. This also means that changes are rolled back after the script debugging session finished, so that's possible to restart a new debugging session again, using exactly the same Redis data set as the previous debugging session.
An alternative synchronous (non forked) debugging model is available on demand, so that changes to the dataset can be retained. In this mode the server blocks for the time the debugging session is active.
Support for step by step execution.
Support for static and dynamic breakpoints.
Support from logging the debugged script into the debugger console.
Inspection of Lua variables.
Tracing of Redis commands executed by the script.
Pretty printing of Redis and Lua values.
Infinite loops and long execution detection, which simulates a breakpoint.

Quick start

A simple way to get started with the Lua debugger is to watch this video introduction:

Development

Mon, 01 Jan 0001 00:00:00 +0000

To aid in the development of new libraries of triggers and functions, you can use the type declaration files for the triggers and functions API, which allows your preferred development environment to provide autocompletion and type checking. You can install this information using the following command:

npm install https://gitpkg.now.sh/RedisGears/RedisGears/js_api --save-dev

Or you can manually add it as a devDependency to your package.json file:

"devDependencies": {
  "@redis/gears-api": "https://gitpkg.now.sh/RedisGears/RedisGears/js_api"
}

Example project setup

Create an empty directory for your new triggers and functions project, my_first_project. Navigate to the folder and run the following command:

Run Redis Stack on Docker

Mon, 01 Jan 0001 00:00:00 +0000

To get started with Redis Stack using Docker, you first need to select a Docker image:

redis/redis-stack contains both Redis Stack server and Redis Insight. This container is best for local development because you can use the embedded Redis Insight to visualize your data.
redis/redis-stack-server provides Redis Stack server only. This container is best for production deployment.

Getting started

redis/redis-stack-server

To start Redis Stack server using the redis-stack-server image, run the following command in your terminal:

Documentation

Mon, 01 Jan 0001 00:00:00 +0000

Full documentation for RIOT is available at redis.github.io/riot.

Geospatial queries

Mon, 01 Jan 0001 00:00:00 +0000

The geospatial feature in Redis Open Source allows you to query for data associated with geographic locations. You can either query for locations within a specific radius or based on geometric shapes, such as polygons. A polygon shape could, for instance, represent a lake or the layout of a building.

The examples in this article use the following schema:

Field name	Field type
`store_location`	`GEO`
`pickup_zone`	`GEOSHAPE`

Note:

Redis version 7.2.0 or higher is required to use the GEOSHAPE field type.

Radius

You can construct a radius query by passing the center coordinates (longitude, latitude), the radius, and the distance unit to the FT.SEARCH command.

High availability with Redis Sentinel

Mon, 01 Jan 0001 00:00:00 +0000

Redis Sentinel provides high availability for Redis when not using Redis Cluster.

Redis Sentinel also provides other collateral tasks such as monitoring, notifications and acts as a configuration provider for clients.

This is the full list of Sentinel capabilities at a macroscopic level (i.e. the big picture):

Monitoring. Sentinel constantly checks if your master and replica instances are working as expected.
Notification. Sentinel can notify the system administrator, or other computer programs, via an API, that something is wrong with one of the monitored Redis instances.
Automatic failover. If a master is not working as expected, Sentinel can start a failover process where a replica is promoted to master, the other additional replicas are reconfigured to use the new master, and the applications using the Redis server are informed about the new address to use when connecting.
Configuration provider. Sentinel acts as a source of authority for clients service discovery: clients connect to Sentinels in order to ask for the address of the current Redis master responsible for a given service. If a failover occurs, Sentinels will report the new address.

Sentinel as a distributed system

Redis Sentinel is a distributed system:

Install on AWS EC2

Mon, 01 Jan 0001 00:00:00 +0000

This tutorial shows you how to install Redis Insight on an AWS EC2 instance and manage ElastiCache Redis instances using Redis Insight. To complete this tutorial you must have access to the AWS Console and permissions to launch EC2 instances.

Step 1: Launch EC2 Instance

Next, launch an EC2 instance.

Redis keyspace notifications

Mon, 01 Jan 0001 00:00:00 +0000

Keyspace notifications allow clients to subscribe to Pub/Sub channels in order to receive events affecting the Redis data set in some way.

Examples of events that can be received are:

All the commands affecting a given key.
All the keys receiving an LPUSH operation.
All the keys expiring in the database 0.

Note: Redis Pub/Sub is fire and forget; that is, if your Pub/Sub client disconnects, and reconnects later, all the events delivered during the time the client was disconnected are lost.

Redis serialization protocol specification

Mon, 01 Jan 0001 00:00:00 +0000

To communicate with the Redis server, Redis clients use a protocol called Redis Serialization Protocol (RESP). While the protocol was designed specifically for Redis, you can use it for other client-server software projects.

RESP is a compromise among the following considerations:

Simple to implement.
Fast to parse.
Human readable.

RESP can serialize different data types including integers, strings, and arrays. It also features an error-specific type. A client sends a request to the Redis server as an array of strings. The array's contents are the command and its arguments that the server should execute. The server's reply type is command-specific.

RAG with Redis

Mon, 01 Jan 0001 00:00:00 +0000

What is Retrieval Augmented Generation (RAG)?

Large Language Models (LLMs) generate human-like text but are limited by the data they were trained on. RAG enhances LLMs by integrating them with external, domain-specific data stored in a Redis vector database.

RDI in Redis Insight

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration (RDI) and its ingest pipeline capability is an end-to-end solution for mirroring your application's primary database in Redis. RDI employs a capture data change mechanism and a stream processor to map and transform source data such as relational tables into fast Redis data structures that match your use cases. You can read more about RDI's ingest architecture on these pages.

As of version 2.54.0, Redis Insight includes RDI connectivity, which allows you to connect to RDI management planes, create, test, and deploy RDI pipelines, and view RDI statistics.

Redis 7.4 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 7.4, organized by functional group

Redis 8.2 release notes and breaking changes

Mon, 01 Jan 0001 00:00:00 +0000

Redis 8.2 builds on the foundation of Redis 8.0 with significant performance and memory optimizations, enhanced streaming capabilities, and improved cluster management tools. For more information on the changes in Redis 8.2, see What's new in Redis 8.2 and review the Redis Open Source 8.2 release notes.

Breaking changes

When new versions of Redis Open Source change existing commands, upgrading your database to a new version can potentially break some functionality. Before you upgrade, read the provided list of breaking changes that affect Redis Cloud and update any applications that connect to your database to handle these changes.

Install Redis Open Source on Linux

Mon, 01 Jan 0001 00:00:00 +0000

Install Redis Open Source on Ubuntu Linux using Snap

To install Redis via snap, run the following commands:

Use cases

Mon, 01 Jan 0001 00:00:00 +0000

You can of course use Redis native data structures to store JSON objects, and that's a common practice. For example, you can serialize JSON and save it in a Redis String.

However, Redis JSON provides several benefits over this approach.

Access and retrieval of subvalues

With JSON, you can get nested values without having to transmit the entire object over the network. Being able to access sub-objects can lead to greater efficiencies when you're storing large JSON objects in Redis.

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

A Redis vector set lets you store a set of unique keys, each with its own associated vector. You can then retrieve keys from the set according to the similarity between their stored vectors and a query vector that you specify.

You can use vector sets to store any type of numeric vector but they are particularly optimized to work with text embedding vectors (see Redis for AI to learn more about text embeddings). The example below shows how to generate vector embeddings and then store and retrieve them using a vector set with Jedis.

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

You can use vector sets to store any type of numeric vector but they are particularly optimized to work with text embedding vectors (see Redis for AI to learn more about text embeddings). The example below shows how to use the @xenova/transformers library to generate vector embeddings and then store and retrieve them using a vector set with node-redis.

Vectorizers

Mon, 01 Jan 0001 00:00:00 +0000

In this notebook, we will show how to use RedisVL to create embeddings using the built-in text embedding vectorizers. Today RedisVL supports:

OpenAI
HuggingFace
Vertex AI
Cohere
Mistral AI
Amazon Bedrock
Bringing your own vectorizer
VoyageAI

Before running this notebook, be sure to

Have installed redisvl and have that environment active for this notebook.
Have a running Redis Stack instance with RediSearch > 2.4 active.

For example, you can run Redis Stack locally with Docker:

View and edit data pipeline

Mon, 01 Jan 0001 00:00:00 +0000

Use the Data pipeline tab in your database to view and edit your data pipeline.

The Data pipeline tab gives an overview of your data pipeline and lets you view your data stream metrics.

The Status table shows statistics for the whole data pipeline:

Status: The status of the data pipeline. Possible statuses include:

Status	Description
Initial Sync	The data pipeline is ingesting all records from the source database into the target database.
Streaming	The data pipeline is capturing new changes from the source database as they happen. Changes in the source database are added to the target database within a few seconds.
Stopped	The data pipeline has been stopped.
Error	There is an error in the data pipeline. Reset the pipeline and contact support if the issue persists.

Total ingested: Total number of records ingested from the source database.
Total inserted: Total number of records inserted into the target database.
Total filtered: Total number of records filtered from being inserted into the target database.
Total rejected: Total number of records that could not be parsed or inserted into the target database.

The Data stream metrics table shows the following metrics for each data stream:

Redis 8.2

Mon, 01 Jan 0001 00:00:00 +0000

Redis 8.2 builds on the foundation of Redis 8.0 with significant performance and memory optimizations, enhanced streaming capabilities, and improved cluster management tools.

This release delivers major improvements across multiple areas:

Enhanced Redis Streams with new commands for better consumer group management
New bitmap operations for advanced bit manipulation
Advanced cluster monitoring with per-slot usage metrics
Optimized vector search with new compression algorithms
Enhanced keyspace notifications with new event types
More than 15 performance and resource utilization improvements

Below is a detailed breakdown of these updates.

RedisInsight v1.14, may 2023

Tue, 02 May 2023 00:00:00 +0000

1.14.0 (May 2023)

RedisInsight version 1.X was retired on April 30, 2023, and will no longer be supported. To continue using the best RedisInsight features and capabilities, download the latest RedisInsight version 2.Y from our website or install it from an app store.

RedisInsight v2.10.0, September 2022

Thu, 29 Sep 2022 00:00:00 +0000

2.10.0 (September 2022)

This is the General Availability (GA) release of RedisInsight 2.10.

Redis Enterprise for Kubernetes 7.2.4-12 (October 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-117.

Redis Enterprise for Kubernetes 7.22.0-7 (April 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

New in the release

Redis Enterprise for Kubernetes 7.22.0-7 is a feature release that includes enhancements, platform updates, and support for Redis Software 7.22.0-28.

Redis Enterprise for Kubernetes 7.4.6-2 (October 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-77. For version changes, supported distributions, and known limitations, see the release notes for 7-4-6-2 (July 2024).

Redis Enterprise for Kubernetes 7.4.6-6 (Dec 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-102. This version also contains a suggested fix needed to upgrade to newer versions. For version changes, supported distributions, and known limitations, see the release notes for 7-4-6-2 (July 2024).

Redis Enterprise for Kubernetes 7.8.6-1 (May 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes 7.8.6-1 (May 2025) is a maintenance release that includes support for Redis Software 7.8.6-60.

For supported distributions, known limitations, and API changes, see Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes.

Downloads

Redis Enterprise: redislabs/redis:7.8.6-60
Operator: redislabs/operator:7.8.6-1
Services Rigger: redislabs/k8s-controller:7.8.6-1
OLM operator bundle : v7.8.6-1.2

Known limitations

See 7.8.6 releases for information on known limitations.

Access management

Mon, 01 Jan 0001 00:00:00 +0000

The Access management screen helps you manage:

The team of users allowed to access your subscription and its databases.
The API keys that authenticate application access to your account.
Single sign-on (SSO) with SAML.

Here, you learn how to manage your team's users and control their level of access.

For help managing API keys, see Manage API keys.

Manage team access

The Team tab lets you manage the people allowed to access your account. Each authorized person is assigned to a role that specifies their privileges.

Build and run Redis Open Source on AlmaLinux/Rocky Linux 8.10

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running AlmaLinux and Rocky Linux 8.10.

Note:

Docker images used to produce these build notes:

AlmaLinux:
- almalinux:8.10
- almalinux:8.10-minimal
Rocky Linux:
- rockylinux/rockylinux:8.10
- rockylinux/rockylinux:8.10-minimal

1. Prepare the system

Note:

For 8.10-minimal, you'll need to install sudo and dnf as follows:

Install Redis Stack from binaries

Mon, 01 Jan 0001 00:00:00 +0000

Start Redis Stack Server

Install the openssl libraries for your platform. For example, on a Debian or Ubuntu instance run:

Redis client handling

Mon, 01 Jan 0001 00:00:00 +0000

This document provides information about how Redis handles clients at the network layer level: connections, timeouts, buffers, and other similar topics are covered here.

The information contained in this document is only applicable to Redis version 2.6 or greater.

Accepting Client Connections

Redis accepts clients connections on the configured TCP port and on the Unix socket if enabled. When a new client connection is accepted the following operations are performed:

Redis Insight configuration settings

Mon, 01 Jan 0001 00:00:00 +0000

Configuration environment variables

Variable	Purpose	Default	Additional info
RI_APP_PORT	The port that Redis Insight listens on.	Docker: 5540 desktop: 5530	See Express Documentation
RI_APP_HOST	The host that Redis Insight connects to.	Docker: 0.0.0.0 desktop: 127.0.0.1	See Express Documentation
RI_SERVER_TLS_KEY	Private key for HTTPS.	n/a	Private key in PEM format. Can be a path to a file or a string in PEM format.
RI_SERVER_TLS_CERT	Certificate for supplied private key.	n/a	Public certificate in PEM format. Can be a path to a file or a string in PEM format.
RI_ENCRYPTION_KEY	Key to encrypt data with.	n/a	Available only for Docker. Redis insight stores sensitive information (database passwords, Workbench history, etc.) locally (using sqlite3). This variable allows you to store sensitive information encrypted using the specified encryption key. Note: The same encryption key should be provided for subsequent `docker run` commands with the same volume attached to decrypt the information.
RI_LOG_LEVEL	Configures the log level of the application.	`info`	Supported logging levels are prioritized from highest to lowest: error warn info http verbose debug silly
RI_FILES_LOGGER	Logs to file.	`true`	By default, you can find log files in the following folders: Docker: `/data/logs` desktop: `<user-home-dir>/.redisinsight-app/logs`
RI_STDOUT_LOGGER	Logs to STDOUT.	`true`
RI_PROXY_PATH	Configures a subpath for a proxy.	n/a	Available only for Docker.
RI_DATABASE_MANAGEMENT	When set to `false`, this disables the ability to manage database connections (adding, editing, or deleting).	`true`
RI_ACCEPT_TERMS_AND_CONDITIONS	This environment variable allows you to accept the End User License Agreement (EULA) without displaying it in the UI. By setting this variable, you acknowledge that your use of Redis Insight is governed either by your signed agreement with Redis or, if none exists, by the Redis Enterprise Software Subscription Agreement. If neither applies, your use is subject to the Server Side Public License (SSPL).	`true`

Preconfigure database connections

Redis Insight allows you to preconfigure database connections using environment variables or a JSON file, enabling centralized and efficient configuration. There are two ways to preconfigure database connections in Redis Insight Electron and Docker:

Create an Active-Active database

Mon, 01 Jan 0001 00:00:00 +0000

Active-Active databases store data across multiple regions and availability zones. This improves scalability, performance, and availability, especially when compared to standalone databases. See Active-Active Redis for more information.

To deploy Active-Active databases in Redis Cloud, you need a Redis Cloud Pro plan that enables Active-Active Redis and defines the regions for each copy of your databases.

Active-Active databases consist of multiple copies (also called instances) deployed to different regions throughout the world.

Create an Essentials database

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud Essentials is cost-efficient and designed for low-throughput scenarios. You can quickly scale up your Essentials database as your application grows.

Before creating a Redis Cloud database, you need to create an account.

To create a database in your Redis Cloud account:

Sign in to the Redis Cloud console.
Select the New database button.

This displays the Create database screen.

Select the type of subscription you need. For this guide, select Essentials.

Create a LangCache service

Mon, 01 Jan 0001 00:00:00 +0000

Redis LangCache provides vector search capabilities and efficient caching for AI-powered applications. This guide walks you through creating and configuring a LangCache service in Redis Cloud.

Prerequisites

To create a LangCache service, you will need:

Debugging

Mon, 01 Jan 0001 00:00:00 +0000

Overview

There are two methods you can use to debug your Redis Stack functions:

Default user

Mon, 01 Jan 0001 00:00:00 +0000

Password-based authentication is a basic but essential Redis security feature. When you create a Redis Cloud database, your database is given a randomly generated password called the Default user password.

This password appears in the Security section of the Configuration tab of the database details screen.

Use the copy button to copy the password to the clipboard:

Function flags

Mon, 01 Jan 0001 00:00:00 +0000

When registering a function, it is possible to include additional information about its behavior. This information is known as function flags. Function flags are an optional argument that can be specified after the function implementation. The following flags are supported:

redis.functionFlags.NO_WRITES: This flag indicates that the function does not perform any write commands. Enabling this flag allows a function to be executed on read-only replicas or in out-of-memory (OOM) situations. Redis enforces this flag's behavior, meaning that any attempt to call a write command within a function that has this flag set will result in an exception.
redis.functionFlags.ALLOW_OOM: By default, Redis prevents any function from running in an OOM scenario. However, this flag allows overriding this behavior and running a function even when there is a memory shortage. Enabling this flag is considered unsafe and may cause Redis to exceed the maxmemory limit. Users should only enable this flag if they are certain that their function does not consume additional memory. For example, it is safe to run a function that only deletes data during an OOM situation.
redis.functionFlags.RAW_ARGUMENTS: By default, Redis attempts to decode all function arguments as JS Strings. If the decoding fails, an error is returned to the client. However, when this flag is set, Redis avoids string decoding and passes the argument as a JS ArrayBuffer instead.

The following example shows how to set the redis.functionFlags.NO_WRITES flag:

Get started with monitoring Redis Enterprise Software

Mon, 01 Jan 0001 00:00:00 +0000

You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.

Hash vs JSON Storage

Mon, 01 Jan 0001 00:00:00 +0000

Out of the box, Redis provides a variety of data structures that can adapt to your domain specific applications and use cases. In this notebook, we will demonstrate how to use RedisVL with both Hash and JSON data.

Before running this notebook, be sure to

Have installed redisvl and have that environment active for this notebook.
Have a running Redis Stack or Redis Enterprise instance with RediSearch > 2.4 activated.

For example, you can run Redis Stack locally with Docker:

Configure Ingress for external routing

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

Before creating an Ingress, you'll need:

Issue commands

Mon, 01 Jan 0001 00:00:00 +0000

Unlike the other client libraries, hiredis doesn't provide an extensive API to construct the many different Redis commands. However, it does provide a lightweight and flexible API to help you construct commands and parse their replies from your own code.

The sections below describe the available functions in detail.

Construct synchronous commands

Use the redisCommand() function to send commands to the server:

Manage Redis Enterprise databases for Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise database (REDB) lifecycle

A Redis Enterprise database (REDB) is created with a custom resource file. The custom resource defines the size, name, and other specifications for the REDB. The database is created when you apply the custom resource file.

Out-of-order / backfilled ingestion performance considerations

Mon, 01 Jan 0001 00:00:00 +0000

When an older timestamp is inserted into a time series, the chunk of memory corresponding to the new sample’s time frame will potentially have to be retrieved from the main memory (you can read more about these chunks here). When this chunk is a compressed chunk, it will also have to be decoded before we can insert/update to it. These are memory-intensive—and in the case of decoding, compute-intensive—operations that will influence the overall achievable ingestion rate.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

To execute commands in a pipeline, you first create a pipeline object and then add commands to it using methods that resemble the standard command methods (for example, set() and get()). The commands are buffered in the pipeline and only execute when you call the sync() method on the pipeline object.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

There are two ways to execute commands in a pipeline. Firstly, node-redis will automatically pipeline commands that execute within the same "tick" of the event loop. You can ensure that commands happen in the same tick very easily by including them in a Promise.all() call, as shown in the following example. The chained then(...) callback is optional and you can often omit it for commands that write data and only return a status result.

Probabilistic data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports several probabilistic data types that let you calculate values approximately rather than exactly. The types fall into two basic categories:

Set operations: These types let you calculate (approximately) the number of items in a set of distinct values, and whether or not a given value is a member of a set.
Statistics: These types give you an approximation of statistics such as the quantiles, ranks, and frequencies of numeric data points in a list.

To see why these approximate calculations would be useful, consider the task of counting the number of distinct IP addresses that access a website in one day.

Probabilistic data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports several probabilistic data types that let you calculate values approximately rather than exactly. The types fall into two basic categories:

Set operations: These types let you calculate (approximately) the number of items in a set of distinct values, and whether or not a given value is a member of a set.
Statistics: These types give you an approximation of statistics such as the quantiles, ranks, and frequencies of numeric data points in a list.

To see why these approximate calculations would be useful, consider the task of counting the number of distinct IP addresses that access a website in one day.

Quickstart

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Recommended security practices

Mon, 01 Jan 0001 00:00:00 +0000

Deployment security

When deploying Redis Enterprise Software to production, we recommend the following practices:

Redis 7.2 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 7.2, organized by functional group

Redis 8.0 release notes and breaking changes

Mon, 01 Jan 0001 00:00:00 +0000

Redis 8.0 introduces powerful new capabilities, including the beta release of the Vector Set data structure, designed for AI use cases such as semantic search and recommendation systems. Redis 8 also merges Redis Stack and Redis Community Edition into a single unified distribution: Redis Open Source. For more information on the changes in Redis 8.0, see What's new in Redis 8.0.

Breaking changes

Redis replication

Mon, 01 Jan 0001 00:00:00 +0000

At the base of Redis replication (excluding the high availability features provided as an additional layer by Redis Cluster or Redis Sentinel) there is a leader follower (master-replica) replication that is simple to use and configure. It allows replica Redis instances to be exact copies of master instances. The replica will automatically reconnect to the master every time the link breaks, and will attempt to be an exact copy of it regardless of what happens to the master.

Requirements summary

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Install Redis from Source

Mon, 01 Jan 0001 00:00:00 +0000

You can compile and install Redis from source on variety of platforms and operating systems including Linux and macOS. Redis has no dependencies other than a C compiler and libc.

Downloading the source files

The Redis source files are available from the Download page. You can verify the integrity of these downloads by checking them against the digests in the redis-hashes git repository.

Manage streams and consumer groups in Redis Insight

Mon, 01 Jan 0001 00:00:00 +0000

A stream is an append-only log file. When you add data to it, you cannot change it. That may seem like a disadvantage; however, a stream serves as a log or single source of truth. It can also be used as a buffer between processes that work at different speeds and do not need to know about each other. For more conceptual information about streams, see Redis Streams.

In this topic, you will learn how to add and work with streams as well as consumer groups in Redis Insight.

Use cases

Mon, 01 Jan 0001 00:00:00 +0000

Monitoring (data center)

Modern data centers have a lot of moving pieces, such as infrastructure (servers and networks) and software systems (applications and services) that need to be monitored around the clock.

Redis Time Series allows you to plan for new resources upfront, optimize the utilization of existing resources, reconstruct the circumstances that led to outages, and identify application performance issues by analyzing and reporting on the following metrics:

Maximum CPU utilization per server
Maximum network latency between two services
Average IO bandwidth utilization of a storage system
99th percentile of the response time of a specific application outages

Weather analysis (environment)

Vector search

Mon, 01 Jan 0001 00:00:00 +0000

This article gives you a good overview of how to perform vector search queries with the Redis Query Engine, which is part of Redis Open Source. See the Redis as a vector database quick start guide for more information about Redis as a vector database. You can also find more detailed information about all the parameters in the vector reference documentation.

A vector search query on a vector field allows you to find all vectors in a vector space that are close to a given vector. You can query for the k-nearest neighbors or vectors within a given radius.

Redis 8.0

Mon, 01 Jan 0001 00:00:00 +0000

Redis 8.0 introduces powerful new capabilities, including the beta release of the Vector Set data structure, designed for AI use cases such as semantic search and recommendation systems.

This release also delivers over 30 performance improvements, including:

Up to 87% faster command execution
Up to 18% faster replication

Additionally, the Redis Community Edition has been renamed to Redis Open Source, marking a shift toward a unified, modern distribution. This version offers the full power of Redis — no modules, no fragmentation — just Redis.

When to use RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

RedisInsight v2.8.0, August 2022

Tue, 23 Aug 2022 00:00:00 +0000

2.8.0 (August 2022)

This is the General Availability (GA) release of RedisInsight 2.8.0

Redis Enterprise for Kubernetes 7.2.4-12 (August 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-109.

Redis Enterprise for Kubernetes 7.4.2-12 (May 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This release has many enhancements, most notably support for persistent volume expansion in the REC. Also, some essential changes in module handling support newer capabilities prompted by changes in the underlying Redis Enterprise around versioning.

Redis Enterprise for Kubernetes 7.4.6-2 (October 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.4.6-102. For version changes, supported distributions, and known limitations, see the release notes for 7-4-6-2 (July 2024).

Redis Enterprise for Kubernetes 7.8.6-1 (April 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

New in the release

Redis Enterprise for Kubernetes 7.8.6-1 (April 2025) is a maintenance release that includes support for Redis Software 7.8.6-36.

Redis Insight debugging information

Mon, 01 Jan 0001 00:00:00 +0000

If you are experiencing errors or other issues when using Redis Insight, follow the steps below to learn more about the errors and to identify root cause.

Connection issues

If you experience connection issues, try these steps.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

node-redis uses promises for error handling. Most Redis JavaScript examples throughout the documentation mainly show the "happy path" and omit error handling for brevity. This page shows how to apply error handling techniques in node-redis for real world code. For an overview of some common general error types and strategies for handling them, see Error handling. See also Production usage for more information on connection management, timeouts, and other aspects of app reliability.

Key eviction

Mon, 01 Jan 0001 00:00:00 +0000

Redis is commonly used as a cache to speed up read accesses to a slower server or database. Since cache entries are copies of persistently-stored data, it is usually safe to evict them when the cache runs out of memory (they can be cached again in the future if necessary).

Redis lets you specify an eviction policy to evict keys automatically when the size of the cache exceeds a set memory limit. Whenever a client runs a new command that adds more data to the cache, Redis checks the memory usage. If it is greater than the limit, Redis evicts keys according to the chosen eviction policy until the total memory used is back below the limit.

Install Redis Open Source on macOS

Mon, 01 Jan 0001 00:00:00 +0000

Install Redis Open Source on macOS using Homebrew

Note:

Installation using Homebrew is only supported on macOS.

To install Redis Open Source on macOS, use Homebrew. Make sure that you have Homebrew installed before starting on the installation instructions below.

Library configuration

Mon, 01 Jan 0001 00:00:00 +0000

When writing a library, you may want to provide a loading configuration so that different users can use the same library with slightly different behaviour, without changing the base code. For example, assume you write a library that adds a __last_updated__ field to a hash (you can see how it can also be done with keyspace triggers), the code will look like this:

#!js api_version=1.0 name=lib

redis.registerFunction("hset", function(client, key, field, val){
    // get the current time in ms
    var curr_time = client.call("time")[0];
    return client.call('hset', key, field, val, "__last_update__", curr_time);
});

Run example:

Redis JSON RAM Usage

Mon, 01 Jan 0001 00:00:00 +0000

Note:

Because of ongoing feature additions, improvements, and optimizations, JSON memory consumption may vary depending on the Redis version. Redis 8 in Redis Open Source was used for the examples on this page.

Every key in Redis takes memory and requires at least the amount of RAM to store the key name, as well as some per-key overhead that Redis uses. On top of that, the value in the key also requires RAM.

Redis 6.2 Commands Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete list of all Redis commands available in version 6.2, organized by functional group

Rerankers

Mon, 01 Jan 0001 00:00:00 +0000

In this notebook, we will show how to use RedisVL to rerank search results (documents or chunks or records) based on the input query. Today RedisVL supports reranking through:

A re-ranker that uses pre-trained Cross-Encoders which can use models from Hugging Face cross encoder models or Hugging Face models that implement a cross encoder function (example: BAAI/bge-reranker-base).
The Cohere /rerank API.
The VoyageAI /rerank API.

Before running this notebook, be sure to:

Have installed redisvl and have that environment active for this notebook.
Have a running Redis Stack instance with RediSearch > 2.4 active.

For example, you can run Redis Stack locally with Docker:

Guide for migrating from RESP2 to RESP3 replies

Mon, 01 Jan 0001 00:00:00 +0000

In RESP3, the default value of the optional path argument was changed from . to $. Due to this change, the replies of some commands have slightly changed. This page provides a brief comparison between RESP2 and RESP3 responses for JSON commands to help developers in migrating their clients from RESP2 to RESP3.

JSON command replies comparison

The types are described using a "TypeScript-like" syntax. Array<a> denotes an array where the type of elements is known, but the number of elements is not.

Scale with Redis Cluster

Mon, 01 Jan 0001 00:00:00 +0000

Redis scales horizontally with a deployment topology called Redis Cluster. This topic will teach you how to set up, test, and operate Redis Cluster in production. You will learn about the availability and consistency characteristics of Redis Cluster from the end user's point of view.

If you plan to run a production Redis Cluster deployment or want to understand better how Redis Cluster works internally, consult the Redis Cluster specification. To learn how Redis Enterprise handles scaling, see Linear Scaling with Redis Enterprise.

RedisInsight v1.13, Aug 2022

Wed, 24 Aug 2022 00:00:00 +0000

1.13.1 (November 2022)

This is the maintenance release of RedisInsight 1.13 (v1.13.1).

Redis Enterprise for Kubernetes 7.2.4-12 (March 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release to support Redis Enterprise Software version 7.2.4-105.

Redis Enterprise for Kubernetes 7.4.2-2 (March 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

The primary purpose of this release is to support Redis Enterprise 7.4.2, which is a maintenance release of Redis Enterprise Software.

Redis Enterprise for Kubernetes 7.4.6-2 (July 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

The primary purpose of this release is to support Redis Enterprise Software version 7.4.6. It also includes updates to supported platform distributions.

Redis Enterprise for Kubernetes 7.8.6-1 (March 2025) release notes

Mon, 01 Jan 0001 00:00:00 +0000

New in the release

Redis Enterprise for Kubernetes 7.8.6-1 is a feature release that includes enhancements, bug fixes, platform updates, and support for Redis Software 7.8.6-13.

Autocomplete with Redis

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Redis Query Engine provides an autocomplete feature using suggestions that are stored in a trie-based data structure. This feature allows you to store and retrieve ranked suggestions based on user input prefixes, making it useful for applications like search boxes, command completion, and chatbot responses.

Redis command arguments

Mon, 01 Jan 0001 00:00:00 +0000

The COMMAND DOCS command returns documentation-focused information about available Redis commands. The map reply that the command returns includes the arguments key. This key stores an array that describes the command's arguments.

Every element in the arguments array is a map with the following fields:

name: the argument's name, always present. The name of an argument is given for identification purposes alone. It isn't displayed during the command's syntax rendering. The same name can appear more than once in the entire argument tree, but it is unique compared to other sibling arguments' names. This allows obtaining a unique identifier for each argument (the concatenation of all names in the path from the root to any argument).
display_text: the argument's display string, present in arguments that have a displayable representation (all arguments that aren't oneof/block). This is the string used in the command's syntax rendering.
type: the argument's type, always present. An argument must have one of the following types:
- string: a string argument.
- integer: an integer argument.
- double: a double-precision argument.
- key: a string that represents the name of a key.
- pattern: a string that represents a glob-like pattern.
- unix-time: an integer that represents a Unix timestamp.
- pure-token: an argument is a token, meaning a reserved keyword, which may or may not be provided. Not to be confused with free-text user input.
- oneof: the argument is a container for nested arguments. This type enables choice among several nested arguments (see the XADD example below).
- block: the argument is a container for nested arguments. This type enables grouping arguments and applying a property (such as optional) to all (see the XADD example below).
key_spec_index: this value is available for every argument of the key type. It is a 0-based index of the specification in the command's key specifications that corresponds to the argument.
token: a constant literal that precedes the argument (user input) itself.
summary: a short description of the argument.
since: the debut Redis version of the argument (or for module commands, the module version).
deprecated_since: the Redis version that deprecated the command (or for module commands, the module version).
flags: an array of argument flags. Possible flags are:
- optional: denotes that the argument is optional (for example, the GET clause of the SET command).
- multiple: denotes that the argument may be repeated (such as the key argument of DEL).
- multiple-token: denotes the possible repetition of the argument with its preceding token (see SORT's GET pattern clause).
value: the argument's value. For arguments types other than oneof and block, this is a string that describes the value in the command's syntax. For the oneof and block types, this is an array of nested arguments, each being a map as described in this section.

Example

The trimming clause of XADD, i.e., [MAXLEN|MINID [=|~] threshold [LIMIT count]], is represented at the top-level as block-typed argument.

Developer notes

Mon, 01 Jan 0001 00:00:00 +0000

Developing Redis JSON involves setting up the development environment (which can be either Linux-based or macOS-based), building RedisJSON (the Redis module providing JSON), running tests and benchmarks, and debugging both the JSON module and its tests.

Cloning the git repository

To clone the RedisJSON module and its submodules, run:

Triggers and functions examples

Mon, 01 Jan 0001 00:00:00 +0000

Redis Stack's triggers and functions feature enables the detection of changes to data as they happen and guarantee seamless execution of business logic at the data source. This ensures that new options to manipulate the data are possible and can be delivered for all the clients at the same time, while deployment and maintenance are simplified. Let's explore some industry-specific use cases where these capabilities shine:

Retail: In the retail sector, a function can be developed to update the inventory immediately upon order receipt. This empowers businesses to accurately predict stock requirements for specific warehouses on any given day.
Travel: For the travel industry, a trigger can be utilized to detect new flight bookings and efficiently load the relevant information into a queue for different consumers. Services can then leverage this data to provide recommendations for hotels, restaurants, car rental services, and more. Leveraging Redis geometries, powerful recommendation systems can offer localized and personalized suggestions.
Subscription services: In the realm of subscription services, employing a keyspace trigger can automatically identify users whose subscriptions have been renewed, seamlessly changing their status to active. Further operations can be performed on these users, such as adding them to a queue for the delivery of notifications or executing additional actions.

These examples highlight the practical application of triggers and functions in different industries, showcasing their value in streamlining processes and delivering efficient solutions.

LLM Message History

Mon, 01 Jan 0001 00:00:00 +0000

Large Language Models are inherently stateless and have no knowledge of previous interactions with a user, or even of previous parts of the current conversation. While this may not be noticeable when asking simple questions, it becomes a hindrance when engaging in long running conversations that rely on conversational context.

The solution to this problem is to append the previous conversation history to each subsequent call to the LLM.

This notebook will show how to use Redis to structure and store and retrieve this conversational message history.

LLM Session Memory

Mon, 01 Jan 0001 00:00:00 +0000

Large Language Models are inherently stateless and have no knowledge of previous interactions with a user, or even of previous parts of the current conversation. While this may not be noticable when asking simple questions, it becomes a hinderance when engaging in long running conversations that rely on conversational context.

The solution to this problem is to append the previous conversation history to each subsequent call to the LLM.

This notebook will show how to use Redis to structure and store and retrieve this conversational session memory.

Module lifecycle

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software follows the Redis Enterprise lifecycle. (For complete details, see the Redis Enterprise Software subscription agreement.)

The modules included in Redis Stack also follow a release lifecycle and schedule. Here, you'll find the "end-of-life" dates for each module and release.

Module release numbering

Redis modules use a three-place numbering scheme to identify released versions.

Redis persistence

Mon, 01 Jan 0001 00:00:00 +0000

Persistence refers to the writing of data to durable storage, such as a solid-state disk (SSD). Redis provides a range of persistence options. These include:

RDB (Redis Database): RDB persistence performs point-in-time snapshots of your dataset at specified intervals.
AOF (Append Only File): AOF persistence logs every write operation received by the server. These operations can then be replayed again at server startup, reconstructing the original dataset. Commands are logged using the same format as the Redis protocol itself.
No persistence: You can disable persistence completely. This is sometimes used when caching.
RDB + AOF: You can also combine both AOF and RDB in the same instance.

If you'd rather not think about the tradeoffs between these different persistence strategies, you may want to consider Redis Enterprise's persistence options, which can be pre-configured using a UI.

Subpath proxy

Mon, 01 Jan 0001 00:00:00 +0000

You can enable the subpath proxy by setting the RI_PROXY_PATH environment variable.

When RI_PROXY_PATH is being set with a path, Redis Insight is accessible only on that subpath. The default routes are given the provided prefix subpath. There isn’t any way to add another proxy behind this one unless the same subpath is used for the new one.

Note:

Once you set the static subpath environment variable, Redis Insight is only reachable on the provided subpath. The default endpoint won't work.

Using Redis Insight behind a reverse proxy

When you configure Redis Insight to run behind a reverse proxy like NGINX, set the request timeout to over 30 seconds on the reverse proxy because some requests can be long-running.

RESP & JavaScript

Mon, 01 Jan 0001 00:00:00 +0000

When running Redis commands from within a function using the client.call API, the reply is parsed as a resp3 reply and converted to a JS object using the following rules:

resp 3	JS object type
`status`	`StringObject` with a field called `__reply_type` and value `status` (or error if failed to convert to utf8)
`bulk string`	JS `String` (or error if failed to convert to utf8)
`Error`	Raise JS exception
`long`	JS big integer
`double`	JS number
`array`	JS array
`map`	JS object
`set`	JS set
`bool`	JS boolean
`big number`	`StringObject` with a field called `__reply_type` and value `big_number`
`verbatim string`	`StringObject` with 2 additional fields: 1. `__reply_type` and value `verbatim` 2. `__format` with the value of the ext in the verbatim string (or error if failed to convert to utf8)
`null`	JS null

When running Redis commands from within a function using the client.callRaw API, the reply is parsed as a resp3 reply and converted to a JS object using the following rules:

Run Redis Open Source on Windows using Docker

Mon, 01 Jan 0001 00:00:00 +0000

Run Redis Open Source on Windows using Docker

To install Redis Open Source on Windows, you will need to have Docker installed. When Docker is up and running, open Windows PowerShell and follow the instructions described in Run Redis Open Source on Docker. Then, use Docker to connect with redis-cli as explained in that topic.

RedisInsight v2.6.0, July 2022

Mon, 25 Jul 2022 00:00:00 +0000

2.6.0 (July 2022)

This is the General Availability (GA) release of RedisInsight 2.6.0

Redis Enterprise for Kubernetes 7.2.4-12 (Dec 2023) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a maintenance release with a few enhancements/fixes on the Kubernetes product and a newer Redis Enterprise container version.

Redis Enterprise for Kubernetes 7.4.2-2 (Feb 2024) release notes

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

The primary purpose of this release is to support Redis Enterprise 7.4.2, which is a major update to Redis Enterprise Software. As such, we have limited the scope of changes to focus on supporting RS 7.4 changes, in addition to implementing a few enhancements and major fixes.

Binary data

Mon, 01 Jan 0001 00:00:00 +0000

By default, triggers and functions will decode all data as a string and will raise error on failures. Though useful for most users, sometimes there is a need to work with binary data. In order to do so, the library developer has to consider the following:

Binary function arguments
Binary command results
Binary key names on keyspace triggers
Binary data on stream triggers

Binary function arguments

It is possible to instruct triggers and functions not to decode function arguments as JS Strings using the redis.functionFlags.RAW_ARGUMENTS function flag. In this case, the function arguments will be given as JS ArrayBuffer. Example:

Create a Redis Flex database

Mon, 01 Jan 0001 00:00:00 +0000

Redis Flex databases have a tiered solid state drive (SSD) and RAM architecture. Using SSDs instead of RAM significantly reduces infrastructure costs, which means developers can build applications that require large datasets using the same Redis API.

Redis Flex databases are compatible with most existing Redis applications, except for applications that use Search and Query and Time Series.

Redis Flex is available on both Redis Cloud Essentials and Redis Cloud Pro.

Redis Enterprise and Redis Open Source feature compatibility

Mon, 01 Jan 0001 00:00:00 +0000

This article describes compatibility between Redis Enterprise features and Redis Open Source features. Version numbers indicate the minimum module version required for feature support.

Supported Redis Open Source features

The following table shows which Redis Open Source features are supported by Redis Enterprise Software and Redis Cloud.

Known limitations

Mon, 01 Jan 0001 00:00:00 +0000

Limited write options

JavaScript remote functions are limited to read operations only. Any attempt to perform a write operation of the following functions on a shard different than the one executing the function will result in an error.

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Semantic Routing

Mon, 01 Jan 0001 00:00:00 +0000

RedisVL provides a SemanticRouter interface to utilize Redis' built-in search & aggregation in order to perform KNN-style classification over a set of Route references to determine the best match.

This notebook will go over how to use Redis as a Semantic Router for your applications

Define the Routes

Below we define 3 different routes. One for technology, one for sports, and another for entertainment. Now for this example, the goal here is surely topic "classification". But you can create routes and references for almost anything.

Redis signal handling

Mon, 01 Jan 0001 00:00:00 +0000

This document provides information about how Redis reacts to different POSIX signals such as SIGTERM and SIGSEGV.

The information in this document only applies to Redis version 2.6 or greater.

SIGTERM and SIGINT

The SIGTERM and SIGINT signals tell Redis to shut down gracefully. When the server receives this signal, it does not immediately exit. Instead, it schedules a shutdown similar to the one performed by the SHUTDOWN command. The scheduled shutdown starts as soon as possible, specifically as long as the current command in execution terminates (if any), with a possible additional delay of 0.1 seconds or less.

RedisInsight v2.4.0, June 2022

Mon, 27 Jun 2022 00:00:00 +0000

2.4.0 (June 2022)

This is the General Availability (GA) release of RedisInsight 2.4.0

Redis Enterprise for Kubernetes release notes 7.2.4-7 (Oct 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

This is a minor maintenance release with a few enhancement/fixes on the Kubernetes product, and a newer Redis Enterprise container version.

Redis cluster specification

Mon, 01 Jan 0001 00:00:00 +0000

Welcome to the Redis Cluster Specification. Here you'll find information about the algorithms and design rationales of Redis Cluster. This document is a work in progress as it is continuously synchronized with the actual implementation of Redis.

Main properties and rationales of the design

Redis Cluster goals

Redis Cluster is a distributed implementation of Redis with the following goals in order of importance in the design:

Combined queries

Mon, 01 Jan 0001 00:00:00 +0000

A combined query is a combination of several query types, such as:

You can use logical query operators to combine query expressions for numeric, tag, and text fields. For vector fields, you can combine a KNN query with a pre-filter.

Note:

The operators are interpreted slightly differently depending on the query dialect used. The default dialect is DIALECT 1; see this article for information on how to change the dialect version. This article uses the second version of the query dialect, DIALECT 2, and uses additional brackets ((...)) to help clarify the examples. Further details can be found in the query syntax documentation.

The examples in this article use the following schema:

Extend existing search and query features

Mon, 01 Jan 0001 00:00:00 +0000

RediSearch supports an extension mechanism, much like Redis supports modules. The API is very minimal at the moment, and it does not yet support dynamic loading of extensions on a running server. Instead, extensions must be written in C (or a language that has an interface with C) and compiled into dynamic libraries that can be loaded at start up.

There are two kinds of extension APIs at the moment:

SVS-VAMANA Vector Search

Mon, 01 Jan 0001 00:00:00 +0000

In this notebook, we will explore SVS-VAMANA (Scalable Vector Search with VAMANA graph algorithm), a graph-based vector search algorithm that is optimized to work with compression methods to reduce memory usage. It combines the Vamana graph algorithm with advanced compression techniques (LVQ and LeanVec) and is optimized for Intel hardware.

How it works

Vamana builds a single-layer proximity graph and prunes edges during construction based on tunable parameters, similar to HNSW but with a simpler structure. The compression methods apply per-vector normalization and scalar quantization, learning parameters directly from the data to enable fast, on-the-fly distance computations with SIMD-optimized layout Vector quantization and compression.

Threshold Optimization

Mon, 01 Jan 0001 00:00:00 +0000

After setting up SemanticRouter or SemanticCache it's best to tune the distance_threshold to get the most performance out of your system. RedisVL provides helper classes to make this light weight optimization easy.

Note: Threshold optimization relies on python > 3.9.

CacheThresholdOptimizer

Let's say you setup the following semantic cache with a distance_threshold of X and store the entries:

Troubleshooting Redis

Mon, 01 Jan 0001 00:00:00 +0000

This page tries to help you with what to do if you have issues with Redis. Part of the Redis project is helping people that are experiencing problems because we don't like to leave people alone with their issues.

If you have latency problems with Redis, that in some way appears to be idle for some time, read our Redis latency troubleshooting guide.
Redis stable releases are usually very reliable, however in the rare event you are experiencing crashes the developers can help a lot more if you provide debugging information. Please read our Debugging Redis guide.
We have a long history of users experiencing crashes with Redis that actually turned out to be servers with broken RAM. Please test your RAM using redis-server --test-memory in case Redis is not stable in your system. Redis built-in memory test is fast and reasonably reliable, but if you can you should reboot your server and use memtest86.

For every other problem please drop a message to the Redis Google Group. We will be glad to help.

RedisInsight v2.2.0, May 2022

Thu, 26 May 2022 00:00:00 +0000

2.2.0 (May 2022)

This is the General Availability (GA) release of RedisInsight 2.2.0

Redis Enterprise for Kubernetes release notes 7.2.4-2 (Aug 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Highlights

The primary purpose this release is supporting Redis Enterprise 7.2.4, which is a major Redis Enterprise Software update. As such, we reduced the scope of changes to support the underlying change of RS 7.2 and a few significant fixes.

add_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

add_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Aggregation queries

Mon, 01 Jan 0001 00:00:00 +0000

An aggregation query allows you to perform the following actions:

Apply simple mapping functions.
Group data based on field values.
Apply aggregation functions on the grouped data.

This article explains the basic usage of the FT.AGGREGATE command. For further details, see the command specification and the aggregations reference documentation.

The examples in this article use a schema with the following fields:

Field name	Field type
`condition`	`TAG`
`price`	`NUMERIC`

Simple mapping

The APPLY clause allows you to apply a simple mapping function to a result set that is returned based on the query expression.

Build and run Redis Open Source on AlmaLinux/Rocky Linux 9.5

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running AlmaLinux and Rocky Linux 9.5.

Note:

Docker images used to produce these build notes:

AlmaLinux:
- almalinux:9.5
- almalinux:9.5-minimal
Rocky Linux:
- rockylinux/rockylinux:9.5
- rockylinux/rockylinux:9.5-minimal

1. Prepare the system

Note:

For 9.5-minimal, you'll need to install sudo and dnf as follows:

Use the LangCache API and SDK

Mon, 01 Jan 0001 00:00:00 +0000

Use the LangCache API from your client app to store and retrieve LLM, RAG, or agent responses.

You can use any standard REST client or library to access the API. If your app is written in Python or Javascript, you can also use the LangCache Software Development Kits (SDKs) to access the API:

Authentication

To access the LangCache API, you need:

Write-behind architecture

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Auth0 SAML integration guide

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure Auth0 as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your identity provider (IdP)

Specify the SAML owner

AWS IAM Identity Center SAML integration guide

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure AWS IAM Identity Center as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Setup your identity provider (IdP)

Create the AWS IAM Identity Center SAML application

Basic deployment examples

Mon, 01 Jan 0001 00:00:00 +0000

This page provides complete YAML examples for a basic Redis Enterprise deployment on Kubernetes. These examples include all the essential components you need to deploy a Redis Enterprise cluster and create a database.

For complete deployment instructions, see Deploy on Kubernetes.

Service account

The service account provides an identity for the Redis Enterprise operator.

Bloom filter

Mon, 01 Jan 0001 00:00:00 +0000

A Bloom filter is a probabilistic data structure in Redis Open Source that enables you to check if an element is present in a set using a very small memory space of a fixed size.

Instead of storing all the items in a set, a Bloom Filter stores only the items' hashed representations, thus sacrificing some precision. The trade-off is that Bloom Filters are very space-efficient and fast.

A Bloom filter can guarantee the absence of an item from a set, but it can only give an estimation about its presence. So when it responds that an item is not present in a set (a negative answer), you can be sure that indeed is the case. But one out of every N positive answers will be wrong. Even though it looks unusual at first glance, this kind of uncertainty still has its place in computer science. There are many cases out there where a negative answer will prevent more costly operations, for example checking if a username has been taken, if a credit card has been reported as stolen, if a user has already seen an ad and much more.

Caching Embeddings

Mon, 01 Jan 0001 00:00:00 +0000

RedisVL provides an EmbeddingsCache that makes it easy to store and retrieve embedding vectors with their associated text and metadata. This cache is particularly useful for applications that frequently compute the same embeddings, enabling you to:

Reduce computational costs by reusing previously computed embeddings
Decrease latency in applications that rely on embeddings
Store additional metadata alongside embeddings for richer applications

This notebook will show you how to use the EmbeddingsCache effectively in your applications.

cassandra.write

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Cluster management commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

Clustering in Redis Enterprise Software and Redis Cloud differs from the Redis Open Source cluster and works with all standard Redis clients.

Redis Enterprise blocks most cluster commands. If you try to use a blocked cluster command, it returns an error.

Command	Redis Software	Redis Cloud	Notes
ASKING	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER ADDSLOTS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER ADDSLOTSRANGE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER BUMPEPOCH	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER COUNT-FAILURE-REPORTS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER COUNTKEYSINSLOT	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER DELSLOTS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER DELSLOTSRANGE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER FAILOVER	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER FLUSHSLOTS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER FORGET	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER GETKEYSINSLOT	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER HELP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Only supported with the OSS cluster API.
CLUSTER INFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Only supported with the OSS cluster API.
CLUSTER KEYSLOT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Only supported with the OSS cluster API.
CLUSTER LINKS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER MEET	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER MYID	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER MYSHARDID	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER NODES	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Only supported with the OSS cluster API.
CLUSTER REPLICAS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER REPLICATE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER RESET	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SAVECONFIG	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SET-CONFIG-EPOCH	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SETSLOT	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SHARDS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SLAVES	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	Deprecated as of Redis v5.0.0.
CLUSTER SLOT-STATS	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLUSTER SLOTS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Only supported with the OSS cluster API. Deprecated as of Redis v7.0.0.
READONLY	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
READWRITE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active

Cluster settings

Mon, 01 Jan 0001 00:00:00 +0000

You can view and set various cluster settings, such as cluster name, email service, time zone, and license, on the Cluster > Configuration page.

General configuration tab

Upload cluster license key

After purchasing a cluster license and if your account has the "Admin" role, you can upload the cluster license key, either during initial cluster creation or at any time afterward. The license key defines various cluster settings, such as the maximum number of shards you can have in the cluster. For more detailed information see Cluster license keys.

Database clustering

Mon, 01 Jan 0001 00:00:00 +0000

Source available Redis is a single-threaded process to provide speed and simplicity. A single Redis process is bound by the CPU core that it is running on and available memory on the server.

Redis Enterprise Software supports database clustering to allow customers to spread the load of a Redis process over multiple cores and the RAM of multiple servers. A database cluster is a set of Redis processes where each process manages a subset of the database keyspace.

Search and query commands

Mon, 01 Jan 0001 00:00:00 +0000

The following table lists search and query commands. See the command links for more information about each command's syntax, arguments, and examples.

Command	Redis Enterprise Software	Redis Cloud Flexible & Annual	Redis Cloud Free & Fixed	Description
FT.AGGREGATE	✅ Supported	✅ Supported	✅ Supported	Runs a search query on an index and groups, sorts, transforms, limits, and/or filters the results.
FT.ALIASADD	✅ Supported	✅ Supported	✅ Supported	Adds an alias to an index.
FT.ALIASDEL	✅ Supported	✅ Supported	✅ Supported	Removes an alias from an index.
FT.ALIASUPDATE	✅ Supported	✅ Supported	✅ Supported	Adds an alias to an index. If the alias already exists for a different index, it updates the alias to point to the specified index instead.
FT.ALTER	✅ Supported	✅ Supported	✅ Supported	Adds a new field to an index.
FT.CONFIG GET	❌ Not supported	⚠️ Not supported²	❌ Not supported	Displays configuration options.
FT.CONFIG HELP	❌ Not supported	❌ Not supported	❌ Not supported	Describes configuration options.
FT.CONFIG SET	⚠️ Not supported¹	⚠️ Not supported²	❌ Not supported	Sets configuration options.
FT.CREATE	✅ Supported	✅ Supported	✅ Supported	Creates an index.
FT.CURSOR DEL	✅ Supported	✅ Supported	✅ Supported	Deletes a cursor.
FT.CURSOR READ	✅ Supported	✅ Supported	✅ Supported	Reads the next results from an existing cursor.
FT.DICTADD	✅ Supported	✅ Supported	✅ Supported	Adds terms to a dictionary.
FT.DICTDEL	✅ Supported	✅ Supported	✅ Supported	Deletes terms from a dictionary.
FT.DICTDUMP	✅ Supported	✅ Supported	✅ Supported	Returns all terms in the specified dictionary.
FT.DROPINDEX	✅ Supported	✅ Supported	✅ Supported	Deletes an index.
FT.EXPLAIN	✅ Supported	✅ Supported	✅ Supported	Returns the execution plan for a complex query as a string.
FT.EXPLAINCLI	✅ Supported	✅ Supported	✅ Supported	Returns the execution plan for a complex query as an array.
FT.INFO	✅ Supported	✅ Supported	✅ Supported	Returns index information and statistics.
FT._LIST	✅ Supported	✅ Supported	✅ Supported	Lists all indexes.
FT.PROFILE	✅ Supported	✅ Supported	✅ Supported	Runs FT.SEARCH or FT.AGGREGATE and reports performance information.
FT.SEARCH	✅ Supported	✅ Supported	✅ Supported	Searches an index for a text query and returns matching documents or document IDs.
FT.SPELLCHECK	✅ Supported	✅ Supported	✅ Supported	Suggests spelling corrections for misspelled terms in a query.
FT.SYNDUMP	✅ Supported	✅ Supported	✅ Supported	Returns a list of synonym terms and their synonym group IDs.
FT.SYNUPDATE	✅ Supported	✅ Supported	✅ Supported	Creates or updates a synonym group with additional terms.
FT.TAGVALS	✅ Supported	✅ Supported	✅ Supported	Returns all distinct values indexed in a tag field.

Use rladmin or the REST API to change search and query configuration for Redis Enterprise Software. See search and query configuration compatibility with Redis Enterprise for more information and examples.

Write-behind configuration guide

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Basic connection

The following example shows the simplest way to connect to a Redis server:

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Basic connection

Connect to a locally-running server on the standard port (6379) with the following code:

Connect to the admin console

Mon, 01 Jan 0001 00:00:00 +0000

The username and password for the Redis Enterprise Software admin console are stored in a Kubernetes secret. After retrieving your credentials, you can use port forwarding to connect to the admin console.

Note:

There are several methods for accessing the admin console. Port forwarding is the simplest, but not the most efficient method for long-term use. You could also use a load balancer service or Ingress.

Switch to the namespace with your Redis Enterprise cluster (REC).

Connection management commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following tables show which Redis Open Source connection management commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Command	Redis Software	Redis Cloud	Notes
AUTH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT CACHING	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT GETNAME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT GETREDIR	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLIENT ID	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Because Redis Enterprise clustering allows multiple active proxies, `CLIENT ID` cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
CLIENT INFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT KILL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT LIST	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT NO-EVICT	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLIENT NO-TOUCH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT PAUSE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
CLIENT REPLY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT SETINFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT SETNAME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT TRACKING	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT TRACKINGINFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT UNBLOCK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
CLIENT UNPAUSE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
ECHO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HELLO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PING	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
QUIT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v7.2.0.
RESET	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
SELECT	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	Redis Enterprise does not support shared databases due to potential negative performance impacts and blocks any related commands. The `SELECT` command is supported solely for compatibility with Redis Open Source but does not perform any operations in Redis Enterprise.

Create a Redis Enterprise Software database

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software lets you create databases and distribute them across a cluster of nodes using the Cluster Manager UI or the REST API.

Cluster Manager UI method

To create a new database using the Cluster Manager UI:

Create and manage subscriptions

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Cloud REST API lets you create and manage all kinds of subscriptions.

Redis Cloud Essentials

Create an Essentials subscription

Use POST /v1/fixed/subscriptions to create an Essentials subscription.

Create certificates

Mon, 01 Jan 0001 00:00:00 +0000

When you first install Redis Enterprise Software, self-signed certificates are created to enable encryption for Redis Enterprise endpoints. These certificates expire after a year (365 days) and must be renewed.

You can renew these certificates by replacing them with new self-signed certificates or by replacing them with certificates signed by a certificate authority (CA).

Renew self-signed certificates

As of v6.2.18-70, Redis Enterprise Software includes a script to generate self-signed certificates.

Create a Pro database with a new subscription

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud Pro supports more databases, larger databases, greater throughput, and unlimited connections compared to Redis Cloud Essentials. Redis Cloud Pro databases are perfect for teams building mission-critical systems in the cloud.

Before creating a Redis Cloud database, you need to create an account.

To create a database in your Redis Cloud account:

Sign in to the Redis Cloud console.
Select the New database button.

This displays the Create database screen.

Create a database with Replica Of

Mon, 01 Jan 0001 00:00:00 +0000

Replica databases copy data from source databases (previously known as master), which enable read-only connections from apps and clients located in different geographic locations.

To create a replica connection, you define a database as a replica of a source database. Replica Of databases (also known as Active-Passive databases) synchronize in the background.

Sources databases can be:

Located in the same Redis Enterprise Software cluster
Located in a different Redis Enterprise cluster
Hosted by a different deployment, e.g. Redis Cloud
Redis Open Source databases

Your apps can connect to the source database to read and write data; they can also use any replica for read-only access.

Create users

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

Before you create other users:

Data type conversion

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Data type commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following tables show which Redis Open Source data type commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Bitmap commands

Command	Redis Software	Redis Cloud
BITCOUNT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BITFIELD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BITFIELD_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BITOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BITPOS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GETBIT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SETBIT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Geospatial indices commands

Command	Redis Software	Redis Cloud	Notes
GEOADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GEODIST	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GEOHASH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GEOPOS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GEORADIUS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
GEORADIUS_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
GEORADIUSBYMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
GEORADIUSBYMEMBER_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
GEOSEARCH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GEOSEARCHSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Hash commands

Command	Redis Software	Redis Cloud	Notes
HDEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HEXISTS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HEXPIRE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HEXPIREAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HEXPIRETIME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HGET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HGETALL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HGETDEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HGETEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HINCRBY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HINCRBYFLOAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HKEYS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HLEN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HMGET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HMSET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v4.0.0.
HPERSIST	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HPEXPIRE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HPEXPIREAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HPEXPIRETIME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HPTTL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HRANDFIELD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HSCAN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HSET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HSETEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HSETNX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HSTRLEN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HTTL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
HVALS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

HyperLogLog commands

Command	Redis Software	Redis Cloud
PFADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PFCOUNT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PFDEBUG	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
PFMERGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PFSELFTEST	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active

List commands

Command	Redis Software	Redis Cloud	Notes
BLMOVE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BLMPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BLPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BRPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BRPOPLPUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
LINDEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LINSERT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LLEN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LMOVE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LMPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LPOS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LPUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LPUSHX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LREM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LSET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LTRIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
RPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
RPOPLPUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
RPUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
RPUSHX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Set commands

Command	Redis Software	Redis Cloud
SADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SDIFF	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SDIFFSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SINTER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SINTERCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SINTERSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SISMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SMEMBERS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SMISMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SMOVE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SRANDMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SREM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SSCAN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SUNION	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SUNIONSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Sorted set commands

Command	Redis Software	Redis Cloud	Notes
BZMPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BZPOPMAX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
BZPOPMIN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZCOUNT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZDIFF	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZDIFFSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZINCRBY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZINTER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZINTERCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZINTERSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZLEXCOUNT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZMPOP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZMSCORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZPOPMAX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZPOPMIN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZRANDMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZRANGEBYLEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
ZRANGEBYSCORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
ZRANGESTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZRANK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZREM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZREMRANGEBYLEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZREMRANGEBYRANK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZREMRANGEBYSCORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZREVRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
ZREVRANGEBYLEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
ZREVRANGEBYSCORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
ZREVRANK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZSCAN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZSCORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZUNION	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
ZUNIONSTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Stream commands

Command	Redis Software	Redis Cloud
XACK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XACKDEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XAUTOCLAIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XCLAIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XDEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XDELEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XGROUP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XINFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XLEN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XPENDING	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XREAD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XREADGROUP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XREVRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XSETID	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
XTRIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

String commands

Command	Redis Software	Redis Cloud	Notes
APPEND	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
DECR	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
DECRBY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GETDEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GETEX	✅ Standard ✅ Active-Active*	✅ Standard ✅ Active-Active*	*Not supported for HyperLogLog.
GETRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
GETSET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Deprecated as of Redis v6.2.0.
INCR	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
INCRBY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
INCRBYFLOAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
LCS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
MGET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
MSET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
MSETNX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PSETEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SET	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SETEX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SETNX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SETRANGE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
STRALGO	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	Deprecated as of Redis v7.0.0.
STRLEN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SUBSTR	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	Deprecated as of Redis v2.0.0.

Vector set commands

Command	Redis Software	Redis Cloud
VADD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VDIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VEMB	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VGETATTR	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VINFO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VISMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VLINKS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VRANDMEMBER	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VREM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VSETATTR	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
VSIM	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Configure database defaults

Mon, 01 Jan 0001 00:00:00 +0000

Database defaults are cluster-wide policies that determine default settings when creating new databases.

Edit database defaults

To edit default database configuration using the Cluster Manager UI:

Debugging

Mon, 01 Jan 0001 00:00:00 +0000

Redis is developed with an emphasis on stability. We do our best with every release to make sure you'll experience a stable product with no crashes. However, if you ever need to debug the Redis process itself, read on.

When Redis crashes, it produces a detailed report of what happened. However, sometimes looking at the crash report is not enough, nor is it possible for the Redis core team to reproduce the issue independently. In this scenario, we need help from the user who can reproduce the issue.

Develop applications with Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

Developing geo-distributed, multi-master applications can be difficult. Application developers may have to understand a large number of race conditions between updates to various sites, network, and cluster failures that could reorder the events and change the outcome of the updates performed across geo-distributed writes.

Active-Active databases (formerly known as CRDB) are geo-distributed databases that span multiple Redis Enterprise Software (RS) clusters. Active-Active databases depend on multi-master replication (MMR) and Conflict-free Replicated Data Types (CRDTs) to power a simple development experience for geo-distributed applications. Active-Active databases allow developers to use existing Redis data types and commands, but understand the developers intent and automatically handle conflicting concurrent writes to the same key across multiple geographies. For example, developers can simply use the INCR or INCRBY method in Redis in all instances of the geo-distributed application, and Active-Active databases handle the additive nature of INCR to reflect the correct final value. The following example displays a sequence of events over time : t1 to t9. This Active-Active database has two member Active-Active databases : member CRDB1 and member CRDB2. The local operations executing in each member Active-Active database is listed under the member Active-Active database name. The "Sync" even represent the moment where synchronization catches up to distribute all local member Active-Active database updates to other participating clusters and other member Active-Active databases.

Develop applications with Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

Enable the API

Mon, 01 Jan 0001 00:00:00 +0000

If you have a Redis Cloud account, you can use a REST API to manage your subscriptions and databases programmatically.

For security reasons, the Redis Cloud API is inactive by default.

To enable the API:

Sign in to your Redis Cloud account as an account owner.
From the menu, choose Access Management.
When the Access Management screen appears, select the API Keys tab.
If a Copy button appears to the right of the API account key, the API is enabled. This button copies the account key to the Clipboard.

Eviction policy

Mon, 01 Jan 0001 00:00:00 +0000

The eviction policy determines what happens when a database reaches its memory limit.

To make room for new data, older data is evicted (removed) according to the selected policy.

To prevent this from happening, make sure your database is large enough to hold all desired keys.

Eviction Policy	Description
noeviction	New values aren't saved when memory limit is reached When a database uses replication, this applies to the primary database
allkeys-lru	Keeps most recently used keys; removes least recently used (LRU) keys
allkeys-lfu	Keeps frequently used keys; removes least frequently used (LFU) keys
allkeys-random	Randomly removes keys
volatile-lru	Removes least recently used keys with `expire` field set to true
volatile-lfu	Removes least frequently used keys with `expire` field set to true
volatile-random	Randomly removes keys with `expire` field set to true
volatile-ttl	Removes least frequently used keys with `expire` field set to true and the shortest remaining time-to-live (TTL) value

Eviction policy defaults

volatile-lru is the default eviction policy for most databases.

filter

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

filter

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Filter expressions

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Filtered search lets you combine vector similarity search with scalar filtering. You can associate JSON attributes with elements in a vector set, and then filter results using those attributes during VSIM queries.

Google Workspace SAML integration guide

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure Google Workspace as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your identity provider (IdP)

Create the Google Workspace SAML application

Redis and the Gopher protocol

Mon, 01 Jan 0001 00:00:00 +0000

** Note: Support for Gopher was removed in Redis 7.0 **

Redis contains an implementation of the Gopher protocol, as specified in the RFC 1436.

The Gopher protocol was very popular in the late '90s. It is an alternative to the web, and the implementation both server and client side is so simple that the Redis server has just 100 lines of code in order to implement this support.

What do you do with Gopher nowadays? Well Gopher never really died, and lately there is a movement in order for the Gopher more hierarchical content composed of just plain text documents to be resurrected. Some want a simpler internet, others believe that the mainstream internet became too much controlled, and it's cool to create an alternative space for people that want a bit of fresh air.

Handle command replies

Mon, 01 Jan 0001 00:00:00 +0000

The redisCommand() and redisCommandArgv() functions return a pointer to a redisReply object when you issue a command (see Issue commands for more information). This type supports all reply formats defined in the RESP2 and RESP3 protocols, so its content varies greatly between calls.

A simple example is the status response returned by the SET command. The code below shows how to get this from the redisReply object:

redisReply *reply = redisCommand(c, "SET greeting Hello");

// Check and free the reply.
if (reply != NULL) {
    printf("Reply: %s\n", reply->str);
    freeReplyObject(reply);
    reply = NULL;
}

A null reply indicates an error, so you should always check for this. If an error does occur, then the redisContext object will have a non-zero error number in its integer err field and a textual description of the error in its errstr field.

How agents work

Mon, 01 Jan 0001 00:00:00 +0000

How AI agents work

AI agents are autonomous systems that go far beyond simple chatbots. They combine large language models (LLMs) with external tools, memory, and planning capabilities to accomplish complex tasks.

Import data into a database

Mon, 01 Jan 0001 00:00:00 +0000

You can import, export, or backup files of a specific Redis Enterprise Software database to restore data. You can either import from a single file or from multiple files, such as when you want to import from a backup of a clustered database.

Warning:

Importing data erases all existing content in the database.

Import data into a database

Cluster Manager UI method

To import data into a database using the Cluster Manager UI:

Install a module on a cluster

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software comes packaged with several modules that provide additional Redis capabilities such as search and query, JSON, time series, and probabilistic data structures. As of version 8.0, Redis Enterprise Software includes multiple feature sets, compatible with different Redis database versions. You can view the installed modules, their versions, and their minimum compatible Redis database versions from Cluster > Modules in the Cluster Manager UI.

To use other modules or upgrade an existing module to a more recent version, you need to install the new module package on your cluster.

Install Redis Enterprise Software on Linux

Mon, 01 Jan 0001 00:00:00 +0000

After you download a Redis Enterprise Software installation package, install it on one of the nodes in the cluster.

For installation on machines without an internet connection, see Offline installation.

Install on Linux

To install Redis Enterprise Software, use the command line:

Install on VMs

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Install

Mon, 01 Jan 0001 00:00:00 +0000

Access a Redis server using any MCP client.

Install Write-behind CLI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

key

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Key commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following table shows which Redis Open Source key (generic) commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Command	Redis Software	Redis Cloud	Notes
COPY	✅ Standard ✅ Active-Active*	✅ Standard ✅ Active-Active*	For Active-Active or clustered databases, the source and destination keys must be in the same hash slot. *Not supported for stream consumer group info.
DEL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
DUMP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EXISTS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EXPIRE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EXPIREAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EXPIRETIME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
KEYS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
MIGRATE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
MOVE	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	Redis Enterprise does not support shared databases due to potential negative performance impacts and blocks any related commands.
OBJECT ENCODING	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
OBJECT FREQ	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
OBJECT IDLETIME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
OBJECT REFCOUNT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PERSIST	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PEXPIRE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PEXPIREAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PEXPIRETIME	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PTTL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
RANDOMKEY	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
RENAME	✅ Standard ✅ Active-Active*	✅ Standard ✅ Active-Active*	For Active-Active or clustered databases, the original key and new key must be in the same hash slot. *Not supported for stream consumer group info.
RENAMENX	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	For Active-Active or clustered databases, the original key and new key must be in the same hash slot.
RESTORE	✅ Standard ❌ Active-Active*	✅ Standard ❌ Active-Active*	*Only supported for module keys.
SCAN	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SORT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SORT_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
TOUCH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
TTL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
TYPE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
UNLINK	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
WAIT	✅ Standard ❌ Active-Active*	❌ Standard** ❌ Active-Active	For Active-Active databases, `WAIT` commands are supported for primary and replica shard replication. You can contact support to enable `WAIT` for local replicas only. `WAIT` is not supported for cross-instance replication. *`WAIT` commands are supported on Redis Cloud Flexible subscriptions.
WAITAOF	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Keys and values

Mon, 01 Jan 0001 00:00:00 +0000

Every data object that you store in a Redis database has its own unique key. The key is a string that you pass to Redis commands to retrieve the corresponding object or modify its data. The data object associated with a particular key is known as the value and the two together are known as as key-value pair.

Content of keys

A key is typically a textual name that has some meaning within your data model. Unlike variable names in a programming language, Redis keys have few restrictions on their format, so keys with whitespace or punctuation characters are mostly fine (for example, "1st Attempt", or "% of price in $"). Redis doesn't support namespaces or other categories for keys, so you must take care to avoid name collisions. However, there is a convention for using the colon ":" character to split keys into sections (for example, "person:1", "person:2", "office:London", "office:NewYork:1"). You can use this as a simple way to collect keys together into categories.

Deploy Redis Enterprise Software for Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

To deploy Redis Enterprise Software for Kubernetes and start your Redis Enterprise cluster (REC), you need to do the following:

Create a new namespace in your Kubernetes cluster.
Download the operator bundle.
Apply the operator bundle and verify it's running.
Create a Redis Enterprise cluster (REC).

This guide works with most supported Kubernetes distributions. If you're using OpenShift, see Redis Enterprise on OpenShift. For details on what is currently supported, see supported distributions.

Upgrade Redis Enterprise for Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:

Prerequisites

Before upgrading, ensure you have the minimum versions of all components necessary for your target version. Without these minimum versions, the upgrade may freeze and require manual recovery.

Manage regions in Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

You can add and edit regions for an Active-Active deployment after it has been created by going to the Regions tab of the subscription page.

Add a new region

To add a new region to an Active-Active deployment:

map

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

map

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Microsoft Entra (formerly Azure Active Directory) SAML integration guide

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure Microsoft Entra (formerly Azure Active Directory) as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

To learn more about Redis Cloud support for SAML, see SAML single sign on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your identity provider (IdP)

To create the Microsoft Entra SAML Toolkit integration application:

Migrate from ioredis

Mon, 01 Jan 0001 00:00:00 +0000

Redis previously recommended the ioredis client library for development with Node.js, but this library is now deprecated in favor of node-redis. This guide outlines the main similarities and differences between the two libraries. You may find this information useful if you are an ioredis user and you want to start a new Node.js project or migrate an existing ioredis project to node-redis.

Comparison of `ioredis` and `node-redis`

The tables below summarize how ioredis and node-redis implement some key features of Redis. See the following sections for more information about each feature.

Monitor certificates

Mon, 01 Jan 0001 00:00:00 +0000

You can monitor certificates used by Redis Enterprise Software.

Monitor certificates with Prometheus

Redis Enterprise Software exposes the expiration time (in seconds) of each certificate on each node. To learn how to monitor Redis Enterprise Software metrics using Prometheus, see the Prometheus integration quick start.

Okta SAML integration guide (Generic)

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure Okta as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

Learn how to use the generic application template. You can also refer to the Org2Org application template.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your demo identity provider (IdP)

To create the Okta SAML integration application:

Okta SAML integration guide (Org2Org)

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure Okta as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

This guide shows how to use the Org2Org application template. You can also use the Generic application template.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your identity provider

Create the Okta SAML integration application

Create an Okta "Org2Org" SAML integration appliction.

PingIdentity SAML integration guide

Mon, 01 Jan 0001 00:00:00 +0000

This guide shows how to configure PingIdentity as a SAML single sign-on identity provider (IdP) for your Redis Cloud account.

To learn more about Redis Cloud support for SAML, see SAML single sign-on.

Before completing this guide, you must verify ownership of any domains you want to associate with your SAML setup.

Step 1: Set up your identity provider (IdP)

Add the `redisAccountMapping` attribute

Log in into your Ping Identity account. Open Administrators > Identities > User Attributes and select Add Attribute.

Prepare participating clusters

Mon, 01 Jan 0001 00:00:00 +0000

Prepare participating clusters

Before you prepare your clusters to participate in an Active-Active database, make sure you've completed all the following steps and have gathered the information listed below each step.

Pub/sub commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following table shows which Redis Open Source pub/sub commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Command	Redis Software	Redis Cloud
PSUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBLISH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBSUB CHANNELS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBSUB NUMPAT	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBSUB NUMSUB	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBSUB SHARDCHANNELS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUBSUB SHARDNUMSUB	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
PUNSUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SPUBLISH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SSUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SUNSUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
UNSUBSCRIBE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

RedisGears JVM quick start

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

For this quick start, you need:

RedisGears Python quick start

Mon, 01 Jan 0001 00:00:00 +0000

For this tutorial, you need:

Either:
- A Redis Enterprise cluster with the RedisGears module and Python plugin installed and enabled on a database
- A Redis Open Source database with the RedisGears module
redis-cli with connectivity to a Redis database

RedisGears basics

In this quick start guide, we'll see how to use RedisGears to perform batch processing and event processing.

Redis Cloud quick start

Mon, 01 Jan 0001 00:00:00 +0000

If you're new to Redis Cloud, this quick start helps you get up and running.

You'll learn how to:

Create an account and a free database
Connect to your database

If you already have an account, see Create an Essentials database to create a Free 30 MB Essentials database. Free plans are a type of Essentials plans; this provides an easy upgrade path when you need it.

If you already have a database, see Manage databases.

Quickstart

Mon, 01 Jan 0001 00:00:00 +0000

In this tutorial you will learn how to install RDI and set up a pipeline to ingest live data from a PostgreSQL database into a Redis database.

Prerequisites

A Redis Enterprise database that will serve as the pipeline target. The dataset that will be ingested is quite small in size, so a single shard database should be enough. RDI also needs to maintain its own database on the cluster to store state information. This requires Redis Enterprise v6.4 or greater.
Redis Insight to edit your pipeline
A virtual machine (VM) with one of the following operating systems:
- RHEL 8 or 9
- Ubuntu 20.04, 22.04, or 24.04

Overview

The following diagram shows the structure of the pipeline we will create (see the architecture overview to learn how the pipeline works):

Redis Data Integration configuration file

Mon, 01 Jan 0001 00:00:00 +0000

Configuration file for Redis Data Integration (RDI) source collectors and target connections

Properties

Name	Type	Description
sources (Source collectors)	`object`	Defines source collectors and their configurations. Each key represents a unique source identifier, and its value contains specific configuration for that collector
processors (Data processing configuration)	`object`, `null`	Configuration settings that control how data is processed, including batch sizes, error handling, and performance tuning
targets (Target connections)	`object`	Configuration for target Redis databases where processed data will be written
secret-providers (Secret providers)	`object`

Redis 7.4 release notes and breaking changes

Mon, 01 Jan 0001 00:00:00 +0000

Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see What's new in Redis 7.4.

Breaking changes

When new versions of Redis Community Edition change existing commands, upgrading your database to a new version can potentially break some functionality. Before you upgrade, read the provided list of breaking changes that affect Redis Cloud and update any applications that connect to your database to handle these changes.

redis-di

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di [OPTIONS] COMMAND [ARGS]...

Options

version:

redis-di

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di add-context

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di add-context [OPTIONS] CONTEXT_NAME

Options

context_name (REQUIRED):

redis-di add-context

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di configure

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di configure-rdi

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di configure-rdi [OPTIONS]

Options

log_level:

redis-di create

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di delete

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di delete-all-contexts

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di delete-all-contexts [OPTIONS]

Options

log_level:

redis-di delete-all-contexts

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di delete-context

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di delete-context [OPTIONS] CONTEXT_NAME

Options

log_level:

redis-di delete-context

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di deploy

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di deploy [OPTIONS]

Options

log_level:

redis-di deploy

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di describe-job

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di describe-job [OPTIONS] JOB_NAME

Options

log_level:

redis-di describe-job

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di dump-support-package

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di dump-support-package [OPTIONS]

Options

log_level:

redis-di dump-support-package

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di get-rejected

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di get-rejected [OPTIONS]

Options

log_level:

redis-di get-rejected

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di install

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di install [OPTIONS]

Options

log_level:

redis-di list-contexts

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di list-contexts [OPTIONS]

Options

help:

redis-di list-contexts

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di list-jobs

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di list-jobs [OPTIONS]

Options

log_level:

redis-di list-jobs

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di monitor

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di reset

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di reset [OPTIONS]

Options

log_level:

redis-di reset

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di scaffold

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di scaffold [OPTIONS]

Options

log_level:

redis-di scaffold

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di set-context

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di set-context [OPTIONS] CONTEXT_NAME

Options

log_level:

redis-di set-context

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di set-secret

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di set-secret [OPTIONS] {RDI_REDIS_USERNAME|RDI_REDIS_PASSWORD|RD
                           I_REDIS_CACERT|RDI_REDIS_CERT|RDI_REDIS_KEY|RDI_RED
                           IS_KEY_PASSPHRASE|SOURCE_DB_USERNAME|SOURCE_DB_PASS
                           WORD|SOURCE_DB_CACERT|SOURCE_DB_CERT|SOURCE_DB_KEY|
                           SOURCE_DB_KEY_PASSWORD|TARGET_DB_USERNAME|TARGET_DB
                           _PASSWORD|TARGET_DB_CACERT|TARGET_DB_CERT|TARGET_DB
                           _KEY|TARGET_DB_KEY_PASSWORD|JWT_SECRET_KEY} [VALUE]

Options

log_level:

redis-di set-secret

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di start

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di start [OPTIONS]

Options

log_level:

redis-di start

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di status

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di status [OPTIONS]

Options

log_level:

redis-di status

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di stop

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di stop [OPTIONS]

Options

log_level:

redis-di stop

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di trace

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di trace [OPTIONS]

Options

log_level:

redis-di trace

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis-di upgrade

Mon, 01 Jan 0001 00:00:00 +0000

Usage

Usage: redis-di upgrade [OPTIONS]

Options

log_level:

redis-di upgrade

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis.lookup

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

redis.write

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

relational.write

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

remove_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

remove_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

rename_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

rename_field

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Enable Role-based access control

Mon, 01 Jan 0001 00:00:00 +0000

Role-based access control (RBAC) lets you define roles with specific sets of permissions. You can then assign users to these roles to provide appropriate levels of access.

RBAC effectively lets you implement the principle of least privilege. For example, you can provide read-only access to an application whose only job is to display Redis data. Similarly, you can prevent new developers from running dangerous administrative commands.

Set up RBAC

To set up RBAC, first navigate to the Data Access Control screen.

Scripting commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following table shows which Redis Open Source scripting and function commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Function commands

Command	Redis Software	Redis Cloud
FCALL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FCALL_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION DELETE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION DUMP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION FLUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION HELP	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION KILL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION LIST	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION LOAD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION RESTORE	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
FUNCTION STATS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Scripting commands

Command	Redis Software	Redis Cloud
EVAL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EVAL_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EVALSHA	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EVALSHA_RO	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SCRIPT DEBUG	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active
SCRIPT EXISTS	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SCRIPT FLUSH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SCRIPT KILL	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
SCRIPT LOAD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Server management commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following tables show which Redis Open Source server management commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Access control commands

Several access control list (ACL) commands are not available in Redis Enterprise. Instead, you can manage access controls from the Redis Enterprise Software Cluster Manager UI and the Redis Cloud console.

Set up a new cluster

Mon, 01 Jan 0001 00:00:00 +0000

A Redis Enterprise Software cluster typically consists of several nodes. For production deployments, we recommend an uneven number of nodes, with a minimum of three.

Note:

In a cluster that consists of only one node, some features and capabilities are not enabled, such as database replication that provides high availability.

To set up a new cluster, you must first install the Redis Enterprise Software package and then set up the cluster as described below. After the cluster is created you can add multiple nodes to the cluster.

Redis Cloud shared responsibility model

Mon, 01 Jan 0001 00:00:00 +0000

The security of all Redis Cloud deployments is a shared responsibility. Redis, the public cloud providers (Amazon Web Services [AWS], Google Cloud, and Microsoft Azure), and our customers all help ensure the security of these deployments.

Redis responsibility

Redis Cloud's offerings are managed by Redis and deployed on AWS, Azure, and Google Cloud infrastructure.

Social login

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud supports the following social logins:

Note:

If your Google and GitHub accounts share an email address (such as Gmail), you can use either one to sign in to the same Redis Cloud account.

To set up Google login:

Redis Strings

Mon, 01 Jan 0001 00:00:00 +0000

Redis strings store sequences of bytes, including text, serialized objects, and binary arrays. As such, strings are the simplest type of value you can associate with a Redis key. They're often used for caching, but they support additional functionality that lets you implement counters and perform bitwise operations, too.

Since Redis keys are strings, when we use the string type as a value too, we are mapping a string to another string. The string data type is useful for a number of use cases, like caching HTML fragments or pages.

Supported connection clients

Mon, 01 Jan 0001 00:00:00 +0000

You can connect to Redis Enterprise Software databases programmatically using client libraries.

Redis client libraries

To connect an application to a Redis database hosted by Redis Enterprise Software, use a client library appropriate for your programming language.

Supported Kubernetes distributions

Mon, 01 Jan 0001 00:00:00 +0000

We thoroughly test each release of Redis Enterprise for Kubernetes against a set of Kubernetes distributions. The table below lists Redis Enterprise for Kubernetes versions and the Kubernetes distributions they support.

Note:

x86 is currently the only computer architecture supported by Redis Enterprise for Kubernetes. Support for ARM architecture is coming in future releases.

✅ Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.

Tokenization

Mon, 01 Jan 0001 00:00:00 +0000

Full-text search works by comparing words, URLs, numbers, and other elements of the query against the text in the searchable fields of each document. However, it would be very inefficient to compare the entire text of the query against the entire text of each field over and over again, so the search system doesn't do this. Instead, it splits the document text into short, significant sections called tokens during the indexing process and stores the tokens as part of the document's index data.

Transaction commands compatibility

Mon, 01 Jan 0001 00:00:00 +0000

The following table shows which Redis Open Source transaction commands are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.

Command	Redis Software	Redis Cloud
DISCARD	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
EXEC	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
MULTI	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
UNWATCH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
WATCH	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Use the LangCache API on Redis Cloud

Mon, 01 Jan 0001 00:00:00 +0000

You can use the LangCache API and SDK from your client app to store and retrieve LLM, RAG, or agent responses.

To access the LangCache API, you need:

LangCache API base URL
LangCache service API key
Cache ID

For LangCache on Redis Cloud, the base URL and cache ID are available in the LangCache service's Configuration page in the Connectivity section.

The LangCache API key is only available immediately after you create the LangCache service. If you lost this value, you will need to replace the service API key to be able to use the LangCache API.

Redis 7.4

Mon, 01 Jan 0001 00:00:00 +0000

Redis 7.4 introduces several new features and improvements aimed at enhancing memory efficiency, performance, and ease of use for various applications. These updates include support for hash field expiration, new memory-efficient data types for AI workloads, simplified secondary indexing, and time series optimizations. Additionally, Redis 7.4 brings several behavior and component changes. Below is a detailed breakdown of these updates.

New features

Hash field expiration support

Redis 7.4 adds the ability to set expiration times for individual hash fields or adjust their remaining TTL. This feature, long-requested by users, improves memory efficiency and performance, especially in caching and session storage scenarios.

Write-behind configuration file

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

RedisInsight v1.12, May 2022

Tue, 24 May 2022 00:00:00 +0000

1.12.1 (July 2022)

This is the maintenance release of RedisInsight 1.12 (v1.12.1)!

Advanced Query Types

Mon, 01 Jan 0001 00:00:00 +0000

In this notebook, we will explore advanced query types available in RedisVL:

TextQuery: Full text search with advanced scoring
AggregateHybridQuery: Combines text and vector search for hybrid retrieval
MultiVectorQuery: Search over multiple vector fields simultaneously

These query types are powerful tools for building sophisticated search applications that go beyond simple vector similarity search.

Prerequisites:

Ensure redisvl is installed in your Python environment.
Have a running instance of Redis Stack or Redis Cloud.

Setup and Data Preparation

First, let's create a schema and prepare sample data that includes text fields, numeric fields, and vector fields.

ARM support

Mon, 01 Jan 0001 00:00:00 +0000

Redis versions 4.0 and above support the ARM processor in general, and the Raspberry Pi specifically, as a main platform. Every new release of Redis is tested on the Pi environment, and we update this documentation page with information about supported devices and other useful information. While Redis does run on Android, in the future we look forward to extend our testing efforts to Android to also make it an officially supported platform.

Install Redis Enterprise Helm chart

Mon, 01 Jan 0001 00:00:00 +0000

Helm charts provide a simple way to install the Redis Enterprise for Kubernetes operator in just a few steps. For more information about Helm, go to https://helm.sh/docs/.

Prerequisites

A supported distribution of Kubernetes.
At least three worker nodes.
Kubernetes client (kubectl).
Helm 3.10 or later or 3.18 for migrating from a non-Helm installation.

If you suspect your file descriptor limits are below 100,000, you must either manually increase limits or Allow automatic resource adjustment. Most major cloud providers and standard container runtime configurations set default file descriptor limits well above the minimum required by Redis Enterprise. In these environments, you can safely run without enabling automatic resource adjustment.

RedisInsight v2.0, Nov 2021

Tue, 23 Nov 2021 00:00:00 +0000

2.0.6 (April 2022)

This is the General Availability (GA) release of RedisInsight 2.0.6

Document payloads

Mon, 01 Jan 0001 00:00:00 +0000

Warning:

The payload feature is deprecated in 2.0

Usually, Redis Open Source stores documents as hashes or JSON. But if you want to access some data for aggregation or scoring functions, Redis can store that data as an inline payload. This will allow us to evaluate the properties of a document for scoring purposes at a very low cost.

Stop words

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source has a default list of stop words. These are words that are usually so common that they do not add much information to search, but take up a lot of space and CPU time in the index.

When indexing, stop words are discarded and not indexed. When searching, they are also ignored and treated as if they were not sent to the query processor. This is done when parsing the query.

Create roles with cluster access only

Mon, 01 Jan 0001 00:00:00 +0000

Roles with cluster access allow access to the Cluster Management UI and REST API.

Default management roles

Redis Enterprise Software includes five predefined roles that determine a user's level of access to the Cluster Manager UI and REST API.

Audit connection events

Mon, 01 Jan 0001 00:00:00 +0000

Starting with version 6.2.18, Redis Enterprise Software lets you audit database connection and authentication events. This helps you track and troubleshoot connection activity.

The following events are tracked:

Database connection attempts
Authentication requests, including requests for new and existing connections
Database disconnects

When tracked events are triggered, notifications are sent via TCP to an address and port defined when auditing is enabled. Notifications appear in near real time and are intended to be consumed by an external listener, such as a TCP listener, third-party service, or related utility.

Search and query configuration compatibility with Redis Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

To configure RediSearch in Redis Enterprise Software or Redis Cloud, use one of the following methods instead of FT.CONFIG SET.

Configure search in Redis Cloud

For Redis Cloud:

Configure permissions with Redis ACLs

Mon, 01 Jan 0001 00:00:00 +0000

You can define custom Redis ACL rules to assign to a data access role or use predefined Redis ACLs.

Redis provides three predefined ACL rules, which are marked with the Redis logo and can not be changed:

Full-Access: Allows all commands.
Read-Write: Allows read and write commands and excludes dangerous commands.
Read-Only: Allows read commands only.

ACLs that are not marked with the Redis logo are user-defined ACL rules.

To configure a Redis ACL that you can assign to a data access role:

Configure modules

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise modules extend Redis functionality with additional data types, commands, and capabilities. Redis Enterprise versions 8.0.2 and later include several bundled modules that are automatically enabled for compatible database types. You can also add user-defined modules for additional functionality.

Prerequisites

Before you begin, verify the following:

Connect to Azure Managed Redis

Mon, 01 Jan 0001 00:00:00 +0000

The go-redis-entraid package lets you authenticate your app to Azure Managed Redis (AMR) using Microsoft Entra ID. You can authenticate using a system-assigned or user-assigned managed identity or a service principal, letting go-redis-entraid fetch and renew the authentication tokens for you automatically.

Install

Install go-redis if you have not already done so. Note that go-redis-entraid requires go-redis v9.9.0 or above, so you should upgrade if you are using an earlier version.

Create a Pro database in an existing subscription

Mon, 01 Jan 0001 00:00:00 +0000

Note:

This guide shows how to create a Pro database in an existing subscription.

If you don't yet have a Pro subscription, see Create a Pro database with a new subscription.
If you'd rather create an Essentials database, see Create an Essentials database.

To create a database in an already existing Pro subscription:

Create roles with database access only

Mon, 01 Jan 0001 00:00:00 +0000

Roles with database access grant the ability to access and interact with a database's data. Database access privileges are determined by defining Redis ACLs and adding them to roles.

To create a role that grants database access without granting access to the Redis Enterprise Cluster Manager UI and REST API:

Define Redis ACLs that determine database access privileges.
Create a role with ACLs added and leave the Management role as None.

Build and run Redis Open Source on Debian 12 (Bookworm)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running Debian 12 (Bookworm).

Note:

Docker images used to produce these build notes:

debian:bookworm
debian:bookworm-slim

1. Install required dependencies

First, update your package lists and install the development tools and libraries needed to build Redis:

View and edit databases

Mon, 01 Jan 0001 00:00:00 +0000

Use the Databases menu of the Redis Cloud console to manage your databases.

To view the details of a database:

Sign in to the Redis Cloud console. (Create an account if you don't already have one.)
Select the Databases menu to display a searchable list of all databases.
Locate the database in the list.
Select the database name to open the Database page.

The Database screen lets you review:

Internode encryption

Mon, 01 Jan 0001 00:00:00 +0000

As of v6.2.4, Redis Enterprise Software supports internode encryption, which encrypts internal communication between nodes. This improves the security of data as it travels within a cluster.

Internode encryption is enabled for the control plane, which manages the cluster and its databases.

Internode encryption is supported for the data plane, which encrypts communication used to replicate shards between nodes and proxy communication with shards located on different nodes.

The following diagram shows how this works.

Multi-factor authentication

Mon, 01 Jan 0001 00:00:00 +0000

To reduce the chances of unauthorized access, Redis Cloud allows users to enable multi-factor authentication (MFA).

When MFA is enabled, users must enter their username, password, and an authentication code when signing in. MFA requires a mobile device that can receive these authentication codes over text messaging. In addition, you may use an authenticator app such as Google Authenticator as one of your factors.

To further increase the security of the account, the account owner can require MFA enforcement for all users.

Use OpenShift routes for external database access

Mon, 01 Jan 0001 00:00:00 +0000

OpenShift routes allow requests to be routed to the database or cluster API from outside the cluster. For more information about routes, see OpenShift documentation.

Prerequisites

Before you can connect to your database from outside the cluster, you'll need the root CA certificate of the DMC Proxy server to validate the server certificate.

Performance

Mon, 01 Jan 0001 00:00:00 +0000

Query performance

Vector similarity queries using the VSIM are threaded by default. Redis uses up to 32 threads to process these queries in parallel.

Redis 7.2 release notes and breaking changes

Mon, 01 Jan 0001 00:00:00 +0000

Redis 7.2 introduces several changes to existing Redis commands. For more information on the changes in Redis 7.2, see What's new in Redis 7.2.

Breaking changes

Redis 7.2 breaking changes

When new major versions of open source Redis change existing commands, upgrading your database to a new version can potentially break some functionality. Before you upgrade, make sure to read the provided list of breaking changes that affect Redis Enterprise and update any applications that connect to your database to handle these changes.

Change database upgrade configuration

Mon, 01 Jan 0001 00:00:00 +0000

Database upgrade configuration includes cluster-wide policies that affect default database upgrades.

Edit upgrade configuration

To edit database upgrade configuration using the Cluster Manager UI:

Redis Open Source 8.4 release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source 8.4.0 (November 2025)

This is the General Availability (GA) release of Redis 8.4 in Redis Open Source.

View and edit LangCache service

Mon, 01 Jan 0001 00:00:00 +0000

After you have created your first LangCache service, selecting LangCache from the Redis Cloud Console menu will take you to the LangCache Services page.

This page displays a list of all LangCache services associated with your account.

Select your LangCache service from the list to view the service's details.

Configuration tab

The Configuration tab lets you view the details of your LangCache service. It contains the following sections:

Create roles with combined access

Mon, 01 Jan 0001 00:00:00 +0000

To create a role that grants database access privileges and allows access to the Cluster Management UI and REST API:

Define Redis ACLs that determine database access privileges.
Create a role with ACLs added and choose a Management role other than None.

Define Redis ACLs

You can use the Cluster Manager UI or the REST API to define Redis ACL rules that you can assign to roles.

Query dialects

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source currently supports four query dialects for use with the FT.SEARCH, FT.AGGREGATE, and other Redis Query Engine commands. Dialects provide for enhancing the query API incrementally, introducing innovative behaviors and new features that support new use cases in a way that does not break the API for existing applications.

Note:

Dialects 1, 3, and 4 are deprecated in Redis 8 in Redis Open Source. However, DIALECT 1 remains the default.

`DIALECT 1` (Deprecated)

Dialect version 1 was the default query syntax dialect from the first release of search and query until dialect version 2 was introduced with version 2.4. This dialect is also the default dialect. See below for information about changing the default dialect.

Use Redis Flex on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

Note:

This page applies to Redis Enterprise for Kubernetes version 8.0.2-2 and later. If you use version 7.22.2-22 or earlier, see Auto Tiering.

Overview

Redis Flex (previously known as Redis on Flash) extends your node memory to use both RAM and flash storage. Solid state drives (SSDs) store infrequently used (warm) values, while RAM stores your keys and frequently used (hot) values. This approach improves performance and lowers costs for large datasets.

Manage database tags

Mon, 01 Jan 0001 00:00:00 +0000

You can create custom tags to categorize databases in a Redis Software cluster.

The Databases screen shows tags for each database in the list.

Add database tags

You can add tags when you create a database or edit an existing database's configuration.

Manage databases in multiple namespaces

Mon, 01 Jan 0001 00:00:00 +0000

Multiple Redis Enterprise database resources (REDBs) can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces.

To learn more about designing a multi-namespace Redis Enterprise cluster, see flexible deployment options.

Note:

Multi-namespace installations now support Active-Active databases (REAADB) with certain configuration requirements. For details, see Multi-namespace Active-Active databases.

Prerequisites

Before configuring a multi-namespace deployment, you must have a running Redis Enterprise cluster (REC). See more information in the deployment section.

Manage node resources

Mon, 01 Jan 0001 00:00:00 +0000

Node eviction thresholds

Kubernetes uses node-pressure eviction to terminate pods and free up node resources. Redis Enterprise for Kubernetes works best when you use the recommendations below.

Overview of Redis ACLs in Redis Enterprise Software

Mon, 01 Jan 0001 00:00:00 +0000

Redis access control lists (Redis ACLs) allow you to define named permissions for specific Redis commands, keys, and pub/sub channels. You can use defined Redis ACLs for multiple databases and roles.

Predefined Redis ACLs

Redis Enterprise Software provides one predefined Redis ACL named Full Access. This ACL allows all commands on all keys and cannot be edited.

Query syntax

Mon, 01 Jan 0001 00:00:00 +0000

Note:

The query syntax that RediSearch uses has improved over time, adding new features and making queries simpler to write. However, changing the syntax like this could potentially break existing queries that rely on an older version of the syntax. To avoid this problem, RediSearch supports different query syntax dialects to ensure backward compatibility. Any breaking changes to the syntax are introduced in a new dialect, while RediSearch continues to support older dialects. This means you can always choose the correct dialect to support the query you are using. See Query dialects for full details of the dialects and the RediSearch versions that introduced them.

Basic syntax

You can use simple syntax for complex queries using these rules:

Add a node

Mon, 01 Jan 0001 00:00:00 +0000

When you install Redis Enterprise Software on the first node of a cluster, you create the new cluster. After you install the first node, you can add more nodes to the cluster.

Prerequisites

Before you add a node to the cluster:

Configure client apps

Mon, 01 Jan 0001 00:00:00 +0000

Access a Redis server using any MCP client.

Configure the query performance factor for Redis Query Engine in Redis Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

Query performance factors are intended to increase the performance of queries, including vector search. When enabled, it allows you to increase a database's compute capacity and query throughput by allocating more virtual CPUs per shard. This is in addition to horizontal scaling with more shards which enables a higher throughput of key value operations. This document describes how to configure the query performance factor.

Note:

Some use cases might not scale effectively. Redis experts can help determine if vertical scaling with the Redis Query Engine will boost performance for your use case and guide you on whether to use vertical scaling, horizontal scaling, or both.

Prerequisites

Redis Query Engine requires a cluster running Redis Enterprise Software version 7.4.2-54 or later.

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Basic connection

You can connect to the server simply by passing a string of the form "hostname:port" to the Connect() method (for example, "localhost:6379"). However, you can also connect using a ConfigurationOptions parameter. Use this to specify a username, password, and many other options:

Connect to the server

Mon, 01 Jan 0001 00:00:00 +0000

Basic connection

Connect to localhost on port 6379, set a value in Redis, and retrieve it. All responses are returned as bytes in Python. To receive decoded strings, set decode_responses=True. For more connection options, see these examples.

Consistency during replication

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software comes with the ability to replicate data to another database instance for high availability and persist in-memory data on disk permanently for durability. With the WAIT command, you can control the consistency and durability guarantees for the replicated and persisted database.

Non-blocking Redis write operation

Any updates that are issued to the database are typically performed with the following flow:

Create and manage databases

Mon, 01 Jan 0001 00:00:00 +0000

You can use the Redis Cloud REST API to create and manage databases.

Redis Cloud Essentials

Create an Essentials database

To create a Redis Cloud Essentials database, use POST /fixed/subscriptions/{subscriptionId}/databases.

Assign permissions to roles

Mon, 01 Jan 0001 00:00:00 +0000

To assign Redis ACLs to a data access role:

Go to Data Access Control from the Redis Cloud console menu.
Select the Roles tab.
Select + to create a new role or point to an existing role and select the pencil icon to edit it.
Enter a name for the role.
Select an ACL rule to assign to the role.

Cuckoo filter

Mon, 01 Jan 0001 00:00:00 +0000

A Cuckoo filter, just like a Bloom filter, is a probabilistic data structure in Redis Open Source that enables you to check if an element is present in a set in a very fast and space efficient way, while also allowing for deletions and showing better performance than Bloom in some scenarios.

While the Bloom filter is a bit array with flipped bits at positions decided by the hash function, a Cuckoo filter is an array of buckets, storing fingerprints of the values in one of the buckets at positions decided by the two hash functions. A membership query for item x searches the possible buckets for the fingerprint of x, and returns true if an identical fingerprint is found. A cuckoo filter's fingerprint size will directly determine the false positive rate.

Data transformation pipeline

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Build and run Redis Open Source on Debian 11 (Bullseye)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running Debian 11 (Bullseye).

Note:

Docker images used to produce these build notes:

debian:bullseye
debian:bullseye-slim

1. Install required dependencies

First, update your package lists and install the development tools and libraries needed to build Redis:

Download a Redis Enterprise Software installation package

Mon, 01 Jan 0001 00:00:00 +0000

To download the installation package for any of the supported platforms:

Go to the Redis download page.
Sign in with your Redis credentials or create a new account.
In the Downloads section for Redis Enterprise Software, select the installation package for your platform then select Go.

Note:

Before you install the Linux package or AWS AMI on an AWS EC2 instance, review the configuration requirements for AWS EC2 instances.

Export data from a database

Mon, 01 Jan 0001 00:00:00 +0000

You can export the data from a specific database at any time. The following destinations are supported:

FTP server
SFTP server
Amazon AWS S3
Local mount point
Azure Blob Storage
Google Cloud Storage

If you export a database configured for database clustering, export files are created for each shard.

Storage space requirements

Before exporting data, verify that you have enough space available in the storage destination and on the local storage associated with the node hosting the database.

Redis for GenAI apps

Mon, 01 Jan 0001 00:00:00 +0000

Redis enables high-performance, scalable, and reliable data management, making it a key component for GenAI apps, chatbots, and AI agents. By leveraging Redis for fast data retrieval, caching, and vector search capabilities, you can enhance AI-powered interactions, reduce latency, and improve user experience.

Redis excels in storing and indexing vector embeddings that semantically represent unstructured data. With vector search, Redis retrieves similar questions and relevant data, lowering LLM inference costs and latency. It fetches pertinent portions of chat history, enriching context for more accurate and relevant responses. These features make Redis an ideal choice for RAG systems and GenAI apps requiring fast data access.

Get started with Redis Enterprise Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

To get started, this article will help you set up an Active-Active database, formerly known as CRDB (conflict-free replicated database), spanning across two Redis Enterprise Software clusters for test and development environments. Here are the steps:

Run two Redis Enterprise Software Docker containers.
Set up each container as a cluster.
Create a new Redis Enterprise Active-Active database.
Test connectivity to the Active-Active database.

To run an Active-Active database on installations from the Redis Enterprise Software download package, set up two Redis Enterprise Software installations and continue from Step 2.

Hardware requirements

Mon, 01 Jan 0001 00:00:00 +0000

The hardware requirements for Redis Enterprise Software are different for development and production environments.

In a development environment, you can test your application with a live database.

If you want to test your application under production conditions, use the production environment requirements.
In a production environment, you must have enough resources to handle the load on the database and recover from failures.

Development environment

You can build your development environment with non-production hardware, such as a laptop, desktop, or small VM or instance, and with these hardware requirements:

Import data into a database

Mon, 01 Jan 0001 00:00:00 +0000

You can import an existing dataset into your Redis Cloud instance from an existing Redis server or an RDB file.

Warning:

Data imported into an existing database overwrites existing data.

If you import a dataset into the target database of an Active-Passive setup, the dataset will be overwritten by any changes to the source database.
If you import a dataset into one region in an Active-Active database, the dataset will also be replicated across regions.

Note:

Expired keys are not imported. As a result, the number of keys in the source and destination databases can be different after the import is complete.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v9.8.0 onwards, go-redis uses query dialect 2 by default. Redis query engine methods such as FTSearch() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the go-redis client library if you haven't already done so.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v3.0.0 onwards, Predis uses query dialect 2 by default. Redis query engine methods such as ftSearch() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the Predis client library if you haven't already done so.

Install RedisGears and the JVM plugin

Mon, 01 Jan 0001 00:00:00 +0000

Before you can use RedisGears with the JVM, you need to install the RedisGears module and JVM plugin on your Redis Enterprise cluster and enable them for a database.

Prerequisites

Redis Enterprise v6.0.12 or later

Install RedisGears and the Python plugin

Mon, 01 Jan 0001 00:00:00 +0000

Before you can use RedisGears with Python, you need to install the RedisGears module and Python plugin on your Redis Enterprise cluster and enable them for a database.

Prerequisites

Redis Enterprise v6.0.12 or later

Install on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Installation script command-line options

Mon, 01 Jan 0001 00:00:00 +0000

Run ./install.sh --help to view command-line options supported by the installation script.

The following options are supported:

Option	Description
`-y`	Automatically answers `yes` to all install prompts, accepting all default values See Manage install questions
`-c <answer file>`	Specify answer file used to respond to install prompts See Manage install questions
`-s <socket dir>`	Specify directory for redislabs unix sockets (new installs only)
`--install-dir <dir>`	Specifies installation directory (new installs only) See Customize install locations
`--config-dir <dir>`	Configuration file directory (new installs only) See Customize install locations
`--var-dir <dir>`	Var directory used for installation (new installs only) See Customize install locations
`--os-user <user>`	Operating system user account associated with install; default: `redislabs` See Customize user and group (new installs only)
`--os-group <group>`	Operating system group associated with install; default: `redislabs` See Customize user and group (new installs only)
`--skip-dns-port-verification`	Skip DNS port verification during installation
`--update-env-path`	Add paths related to Redis Enterprise Software to root's PATH environment variable See Manage install questions

Configure Istio for external routing

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise for Kubernetes has the ability to use an Istio Ingress gateway as an alternative to NGINX or HaProxy Ingress controllers.

Istio can also understand Ingress resources, but using that mechanism takes away the advantages and options that the native Istio resources provide. Istio offers its own configuration methods using custom resources.

To configure Istio to work with the Redis Kubernetes operator, we will use two custom resources: a Gateway and a VirtualService. Then you'll be able to establish external access to your database.

Cluster license keys

Mon, 01 Jan 0001 00:00:00 +0000

The cluster license key enables Redis Enterprise Software features and determines shard usage and limits. You can add or update a cluster key at any time.

Trial mode

Trial mode allows all features to be enabled during the trial period.

Redis lists

Mon, 01 Jan 0001 00:00:00 +0000

Redis lists are linked lists of string values. Redis lists are frequently used to:

Implement stacks and queues.
Build queue management for background worker systems.

Basic commands

LPUSH adds a new element to the head of a list; RPUSH adds to the tail.
LPOP removes and returns an element from the head of a list; RPOP does the same but from the tails of a list.
LLEN returns the length of a list.
LMOVE atomically moves elements from one list to another.
LRANGE extracts a range of elements from a list.
LTRIM reduces a list to the specified range of elements.

Blocking commands

Lists support several blocking commands. For example:

Manage API keys

Mon, 01 Jan 0001 00:00:00 +0000

Every REST API request must include the following API keys:

The Account key identifies the account associated with the Redis Cloud subscription.
The User key identifies the user and (optionally) the context of a request. Generated by account owners.

Use the API Keys tab of the Access Management screen to manage your keys:

Sign in to your Redis Cloud account as an account owner.
From the menu, choose Access Management and then select the API Keys tab.

Database memory limits

Mon, 01 Jan 0001 00:00:00 +0000

When you set a database's memory limit, you define the maximum size the database can reach in the cluster, across all database replicas and shards, including both primary and replica shards.

If the total size of the database in the cluster reaches the memory limit, the data eviction policy is applied.

Factors for sizing

Factors to consider when sizing your database:

Monitor a LangCache service

Mon, 01 Jan 0001 00:00:00 +0000

You can monitor a LangCache service's performance from the Metrics tab of the service's page.

The Metrics tab provides a series of graphs showing performance data for your LangCache service.

You can switch between hourly, daily, and weekly stats using the Hour, Day, and Week buttons at the top of the page. Each graph also includes minimum, average, maximum, and latest values.

Upgrade Redis Enterprise with OpenShift CLI

Mon, 01 Jan 0001 00:00:00 +0000

Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:

Prerequisites

The following steps ensure you have the minimum versions of all components necessary to upgrade to 7.8.2-6 or later. Without these minimum versions, the upgrade will freeze and require manual recovery.

Enable OSS Cluster API

Mon, 01 Jan 0001 00:00:00 +0000

Review Redis OSS Cluster API to determine if you should enable this feature for your database.

Prerequisites

The Redis OSS Cluster API is supported only when a database meets specific criteria.

Redis patterns example

Mon, 01 Jan 0001 00:00:00 +0000

This article describes the design and implementation of a very simple Twitter clone written using PHP with Redis as the only database. The programming community has traditionally considered key-value stores as a special purpose database that couldn't be used as a drop-in replacement for a relational database for the development of web applications. This article will try to show that Redis data structures on top of a key-value layer are an effective data model to implement many kinds of applications.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

There is no command to explicitly start a pipeline with hiredis, but if you issue a command with the redisAppendCommand() function, it will be added to an output buffer without being sent immediately to the server.

Redis pipelining

Mon, 01 Jan 0001 00:00:00 +0000

Redis pipelining is a technique for improving performance by issuing multiple commands at once without waiting for the response to each individual command. Pipelining is supported by most Redis clients. This document describes the problem that pipelining is designed to solve and how pipelining works in Redis.

Request/Response protocols and round-trip time (RTT)

Redis is a TCP server using the client-server model and what is called a Request/Response protocol.

Graph quick start

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

For this quick start tutorial, you need:

Redis Enterprise Software REST API quick start

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software includes a REST API that allows you to automate certain tasks. This article shows you how to send a request to the Redis Enterprise Software REST API.

Fundamentals

No matter which method you use to send API requests, there are a few common concepts to remember.

Rack awareness examples

Mon, 01 Jan 0001 00:00:00 +0000

This page provides YAML examples for deploying Redis Enterprise with rack awareness. Rack awareness distributes Redis Enterprise nodes and database shards across different availability zones or failure domains to improve high availability and fault tolerance.

Prerequisites

Label Kubernetes nodes with zone information
Typically uses the standard label topology.kubernetes.io/zone
Verify node labels: kubectl get nodes -o custom-columns="name:metadata.name","rack\\zone:metadata.labels.topology\.kubernetes\.io/zone"
Install the Redis Enterprise operator

For complete deployment instructions, see Deploy on Kubernetes.

Recover a Redis Enterprise cluster on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

When a Redis Enterprise cluster loses contact with more than half of its nodes either because of failed nodes or network split, the cluster stops responding to client connections. When this happens, you must recover the cluster to restore the connections.

You can also perform cluster recovery to reset cluster nodes, to troubleshoot issues, or in a case of active/passive failover.

The Redis Enterprise for Kubernetes automates these recovery steps:

Scalability

Mon, 01 Jan 0001 00:00:00 +0000

Multi-instance scalability

Vector sets can scale horizontally by sharding your data across multiple Redis instances. This is done by partitioning the dataset manually across keys and nodes.

Upgrade a standalone Redis instance to Redis 8

Mon, 01 Jan 0001 00:00:00 +0000

Note:

The supported upgrade paths are:

Redis Open Source 7.x (with or without modules) to Redis 8 in Redis Open Source
Redis Stack 7.2 or 7.4 to Redis 8 in Redis Open Source

Note:

It's essential to practice upgrading Redis in a controlled environment before upgrading it in a production environment. Docker is an excellent tool to use for this purpose.

Follow these instructions to upgrade a single-node Redis server. This guide assumes you have installed Redis using one of the supported methods listed here.

Test client connection

Mon, 01 Jan 0001 00:00:00 +0000

In various scenarios, such as after creating a new cluster or upgrading the cluster, you should verify clients can connect to the database.

To test client connectivity:

After you create a Redis database, copy the database endpoint, which contains the cluster name (FQDN).

To view and copy endpoints for a database in the cluster, see the database’s Configuration > General section in the Cluster Manager UI:
Try to connect to the database endpoint from your client of choice, and run database commands.

Transport Layer Security (TLS)

Mon, 01 Jan 0001 00:00:00 +0000

Transport Layer Security (TLS) uses encryption to secure network communications.

Paid Redis Cloud Essentials plans and Redis Cloud Pro plans can use TLS to encrypt data communications between applications and Redis databases.

Note:

TLS is not available for Free Redis Cloud Essentials plans.

TLS recommendations

TLS is not enabled by default.

Replica Of Repeatedly Fails

Mon, 01 Jan 0001 00:00:00 +0000

Problem: The Replica Of process repeatedly fails and restarts

Diagnostic: A log entry in the Redis log of the source database shows repeated failures and restarts.

Cause: The Redis "client-output-buffer-limit" setting on the source database is configured to a relatively small value, which causes the connection drop.

Resolution: Reconfigure the buffer on the source database to a bigger value:

If the source is a Redis database on a Redis Enterprise Software cluster, increase the replica buffer size of the source database with:

Update certificates

Mon, 01 Jan 0001 00:00:00 +0000

Warning:

When you update the certificates, the new certificate replaces the same certificates on all nodes in the cluster.

How to update certificates

You can use the rladmin command-line interface (CLI) or the REST API to update certificates. The Cluster Manager UI lets you update proxy, syncer, and internode encryption certificates on the Cluster > Security > Certificates screen.

Redis Open Source 8.2 release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source 8.2.3 (November 2025)

Update urgency: SECURITY: There is a security fix in the release.

Redis 7.2

Mon, 01 Jan 0001 00:00:00 +0000

Redis version 7.2 introduces new capabilities, including improved geospatial queries, and streamlined JSON data manipulation. Performance optimizations, client-side enhancements, and behavioral refinements further improve the efficiency, security, and usability of Redis. Below is a detailed breakdown of these updates.

New features

Geospatial queries with polygon search

Redis Query Engine now supports querying geospatial data using polygon search, enabling developers to efficiently filter and retrieve data within complex geographic boundaries.

Considerations for planning Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

In Redis Enterprise, Active-Active geo-distribution is based on conflict-free replicated data type (CRDT) technology. Compared to databases without geo-distribution, Active-Active databases have more complex replication and networking, as well as a different data type.

Because of the complexities of Active-Active databases, there are special considerations to keep in mind while planning your Active-Active database.

See Active-Active Redis for more information about geo-distributed replication. For more info on other high availability features, see Durability and high availability.

Query attributes

Mon, 01 Jan 0001 00:00:00 +0000

Query attributes

As of v1.2.0, you can apply specific query modifying attributes to specific clauses of the query.

Back up and export a database

Mon, 01 Jan 0001 00:00:00 +0000

The backup options for Redis Cloud databases depend on your plan:

Redis Cloud Pro subscriptions can back up or export a database on-demand and schedule daily backups that occur during a set hour.
Paid Redis Cloud Essentials plans can back up or export a database on-demand and schedule backups that occur every 24 hours.
Free plans cannot back up or export a database through the Redis Cloud console.

Note:

The number of database backups that can run simultaneously on a subscription is limited to 4 by default.

Backups are saved to predefined storage locations available to your subscription. Backup locations need to be available before you turn on database backups. To learn more, see Set up backup storage locations.

Best practices for scalable Redis Query Engine

Mon, 01 Jan 0001 00:00:00 +0000

Vertical scaling of Redis Query Engine requires configuring query performance factors. With careful crafting of search indexes and queries, query performance factors allow throughput scaling up to 16X. The following recommendations can help optimize your indexes and queries to maximize the performance benefits from additional CPUs allocated by query performance factors.

Best candidates for query performance factor improvements

Query types:

Probabilistic data structure commands

Mon, 01 Jan 0001 00:00:00 +0000

The following tables list probabilistic data structure commands. See the command links for more information about each command's syntax, arguments, and examples.

Bloom filter commands

Command	Redis Enterprise	Redis Cloud	Description
BF.ADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds an item to the filter.
BF.EXISTS	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Checks if an item exists in the filter.
BF.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns information about a Bloom filter.
BF.INSERT	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds multiple items to a filter. If the key does not exist, it creates a new filter.
BF.LOADCHUNK	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Restores a Bloom filter previously saved with BF.SCANDUMP.
BF.MADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds multiple items to the filter.
BF.MEXISTS	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	For multiple items, checks if each item exists in the filter.
BF.RESERVE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Creates a Bloom filter. Sets the false positive rate and capacity.
BF.SCANDUMP	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Starts an incremental save of a Bloom filter.

Cuckoo filter commands

Command	Redis Enterprise	Redis Cloud	Description
CF.ADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds an item to a filter.
CF.ADDNX	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds an item to a filter only if the item does not already exist.
CF.COUNT	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the probable number of times an item occurs in the filter.
CF.DEL	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes one instance of an item from the filter.
CF.EXISTS	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Checks if an item exists in the filter.
CF.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns information about a cuckoo filter.
CF.INSERT	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds multiple items to a filter. Optionally sets the capacity if the filter does not already exist.
CF.INSERTNX	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds multiple items to a filter if they do not already exist. Optionally sets the capacity if the filter does not already exist.
CF.LOADCHUNK	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Restores a cuckoo filter previously saved with CF.SCANDUMP.
CF.MEXISTS	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	For multiple items, checks if each item exists in the filter.
CF.RESERVE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Creates a cuckoo filter and sets its capacity.
CF.SCANDUMP	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Starts an incremental save of a cuckoo filter.

Count-min sketch commands

Command	Redis Enterprise	Redis Cloud	Description
CMS.INCRBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Increases item counts.
CMS.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns width, depth, and total count of the sketch.
CMS.INITBYDIM	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Initializes a count-min sketch to the specified dimensions (width and depth).
CMS.INITBYPROB	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Initializes a count-min sketch to allow the specified overestimation percent for the item count and the probability of overestimation.
CMS.MERGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Merges several sketches into one sketch.
CMS.QUERY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the count for one or more items in a sketch.

Top-k commands

Command	Redis Enterprise	Redis Cloud	Description
TOPK.ADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds an item to the data structure.
TOPK.COUNT	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns probable item counts.
TOPK.INCRBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Increases the score of an item by the specified number.
TOPK.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the number of required items (k), width, depth, and decay values.
TOPK.LIST	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the keys of items in the top-k list. Optionally returns their item counts.
TOPK.QUERY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Checks whether an item is one of top-k items.
TOPK.RESERVE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Initializes a top-k with the specified number of top occurring items to keep, width, depth, and decay.

T-digest sketch commands

Command	Redis Enterprise	Redis Cloud	Description
TDIGEST.ADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Adds one or more samples to a t-digest sketch.
TDIGEST.CDF	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Estimates the fraction of all observations which are less than or equal to the specified value.
TDIGEST.CREATE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Allocates memory and initializes a t-digest sketch.
TDIGEST.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns information about the t-digest sketch.
TDIGEST.MAX	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the maximum value from the sketch.
TDIGEST.MERGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Copies values from one sketch to another.
TDIGEST.MIN	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the minimum value from the sketch.
TDIGEST.QUANTILE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Estimates one or more cutoffs.
TDIGEST.RESET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Resets the sketch and reinitializes it.
TDIGEST.TRIMMED_MEAN	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Estimates the mean value from the sketch, excluding values outside the specified range.

Graph commands

Mon, 01 Jan 0001 00:00:00 +0000

The following table lists graph commands. See the command links for more information about each command's syntax, arguments, and examples.

Command	Redis Enterprise Software	Redis Cloud Flexible & Annual	Redis Cloud Free & Fixed	Description
GRAPH.CONFIG GET	❌ Not supported	⚠️ Not supported²	❌ Not supported	Returns the current value of a RedisGraph configuration parameter.
GRAPH.CONFIG SET	⚠️ Not supported¹	⚠️ Not supported²	❌ Not supported	Changes the value of a RedisGraph configuration parameter.
GRAPH.DELETE	✅ Supported	✅ Supported	✅ Supported	Removes the graph and its entities.
GRAPH.EXPLAIN	✅ Supported	✅ Supported	✅ Supported	Displays the query execution plan but does not run the query.
GRAPH.LIST	✅ Supported	✅ Supported	✅ Supported	Lists all graph keys.
GRAPH.PROFILE	✅ Supported	✅ Supported	✅ Supported	Runs a query and displays the execution plan with metrics for each operation.
GRAPH.QUERY	✅ Supported	✅ Supported	✅ Supported	Runs a query against a graph. Supports a variety of clauses and functions.
GRAPH.RO_QUERY	✅ Supported	✅ Supported	✅ Supported	Runs a read-only query against a graph.
GRAPH.SLOWLOG	✅ Supported	✅ Supported	✅ Supported	Returns the slowest 10 queries run against a specific graph.

Use rladmin or the REST API to change RedisGraph configuration for Redis Enterprise Software. See RedisGraph configuration compatibility with Redis Enterprise for more information and examples.

JSON commands

Mon, 01 Jan 0001 00:00:00 +0000

The following table lists JSON commands. See the command links for more information about each command's syntax, arguments, and examples.

Command	Redis Enterprise	Redis Cloud	Description
JSON.ARRAPPEND	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Appends an element to a JSON array.
JSON.ARRINDEX	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the index of a value's first occurrence in a JSON array.
JSON.ARRINSERT	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Inserts JSON values into a JSON array before the given index.
JSON.ARRLEN	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the length of a JSON array.
JSON.ARRPOP	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes and returns an element located at the index in the JSON array.
JSON.ARRTRIM	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Trims a JSON array so that it contains only the specified inclusive range of elements.
JSON.CLEAR	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Clears container values (arrays/objects) and sets numeric values to 0.
JSON.DEBUG	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Debugging container command.
JSON.DEBUG HELP	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns helpful information about the JSON.DEBUG command.
JSON.DEBUG MEMORY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Reports a JSON element's memory usage in bytes.
JSON.DEL	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes a JSON element.
JSON.FORGET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes a JSON element, the same as JSON.DEL.
JSON.GET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the value of an element in JSON-serialized form.
JSON.MGET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the values of multiple elements.
JSON.NUMINCRBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Increments the number stored at path by the specified number.
JSON.NUMMULTBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Multiplies the number stored at path by the specified number. (deprecated as of RedisJSON v2.0)
JSON.OBJKEYS	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the keys contained in the specified JSON object.
JSON.OBJLEN	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the number of keys in the specified JSON object.
JSON.RESP	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns a JSON element in Redis Serialization Protocol (RESP) format.
JSON.SET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Sets the value of a JSON element.
JSON.STRAPPEND	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Appends the given string to the specified key's existing strings.
JSON.STRLEN	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the length of a string.
JSON.TOGGLE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	If the boolean is `true`, changes it to `false`. If the boolean is `false`, changes it to `true`.
JSON.TYPE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns a JSON element's type.

Time series commands

Mon, 01 Jan 0001 00:00:00 +0000

The following table lists time series commands. See the command links for more information about each command's syntax, arguments, and examples.

Command	Redis Enterprise	Redis Cloud	Description
TS.ADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Appends a sample to a time series.
TS.ALTER	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Updates the retention, chunk size, duplicate policy, or labels for an existing time series.
TS.CREATE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Creates a new time series.
TS.CREATERULE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Creates a compaction rule for downsampling.
TS.DECRBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Decreases the value of the latest sample in a time series by the specified number. Either modifies the existing sample or adds the decreased value as a new sample, depending on the timestamp option.
TS.DEL	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes all samples between two timestamps for a given time series.
TS.DELETERULE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Removes a compaction rule.
TS.GET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the last sample in a time series.
TS.INCRBY	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Increases the value of the latest sample in a time series by the specified number. Either modifies the existing sample or adds the increased value as a new sample, depending on the timestamp option.
TS.INFO	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns time series information and statistics.
TS.MADD	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Appends multiple samples to one or more time series.
TS.MGET	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns multiple samples with labels that match the filter.
TS.MRANGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	For multiple time series, runs a query against samples within a range of timestamps, from earliest to latest. Supports filtering and aggregation.
TS.MREVRANGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	For multiple time series, runs a query against samples within a range of timestamps in reverse order, from latest to earliest. Supports filtering and aggregation.
TS.QUERYINDEX	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	Returns the keys of all time series with labels that match the given filters.
TS.RANGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	From the start of a single time series, runs a query against samples within a range of timestamps. Supports filtering and aggregation.
TS.REVRANGE	✅ Supported	✅ Flexible & Annual ✅ Free & Fixed	From the end of a single time series, runs a query against samples within a range of timestamps in reverse order. Supports filtering and aggregation.

Connect to Azure Managed Redis

Mon, 01 Jan 0001 00:00:00 +0000

The redis-entra-id package lets you authenticate your app to Azure Managed Redis (AMR) using Microsoft Entra ID. You can authenticate using a system-assigned or user-assigned managed identity or a service principal, letting redis-entra-id fetch and renew the authentication tokens for you automatically.

Install

Install redis-py first, if you have not already done so. Then, install redis-entra-id with the following command:

Create an Active-Active geo-replicated database

Mon, 01 Jan 0001 00:00:00 +0000

Active-Active geo-replicated databases (formerly known as CRDBs) give applications write access to replicas of the dataset in different geographical locations.

The participating Redis Enterprise Software clusters that host the instances can be distributed in different geographic locations. Every instance of an Active-Active database can receive write operations, and all operations are synchronized to all instances without conflict.

Steps to create an Active-Active database

Create a service account - On each participating cluster, create a dedicated user account with the Admin role.
Confirm connectivity - Confirm network connectivity between the participating clusters.
Create Active-Active database - Connect to one of your clusters and create a new Active-Active database.
Add participating clusters - Add the participating clusters to the Active-Active database with the user credentials for the service account.
Verify creation - Log in to each of the participating clusters and verify your Active-Active database was created on them.
Confirm Active-Active database synchronization - Test writing to one cluster and reading from a different cluster.

Prerequisites

Two or more machines with the same version of Redis Enterprise Software installed
Network connectivity and cluster FQDN name resolution between all participating clusters
Network time service listener (ntpd) configured and running on each node in all clusters

Create an Active-Active database

Create service accounts on each participating cluster:

Create and edit database users

Mon, 01 Jan 0001 00:00:00 +0000

Before you create a database user, you must create a data access role to assign to that user.

Create a user

To create a user:

Enable role-based LDAP

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software uses a role-based mechanism to enable LDAP authentication and authorization.

When a user attempts to access Redis Enterprise resources using LDAP credentials, the credentials are passed to the LDAP server in a bind request. If the request succeeds, the user’s groups are searched for a group that authorizes access to the original resource.

Role-based LDAP lets you authorize cluster management users (previously known as external users) and database users. As with any access control role, you can define the level of access authorized by the role.

Manage installation questions

Mon, 01 Jan 0001 00:00:00 +0000

Several questions are displayed during the Redis Enterprise Software installation process.

Here, you'll find a list of these questions and learn how to automatically answer these questions to perform a silent install.

Installation questions

Several questions appear during installation:

Memory optimization

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Redis vector sets are efficient, but vector similarity indexing and graph traversal require memory tradeoffs. This guide helps you manage memory use through quantization, graph tuning, and attribute choices.

Sorting by indexed fields

Mon, 01 Jan 0001 00:00:00 +0000

As of RediSearch 0.15, you can bypass the scoring function mechanism and order search results by the value of different document attributes (fields) directly, even if the sorting field is not used by the query. For example, you can search for first name and sort by last name.

Declaring sortable fields

When creating an index with FT.CREATE, you can declare TEXT, TAG, NUMERIC, and GEO attributes as SORTABLE. When an attribute is sortable, you can order the results by its values with relatively low latency. When an attribute is not sortable, it can still be sorted by its values, but with increased latency. For example, in the following schema:

Build and run Redis Open Source on Ubuntu 20.04 (Focal)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running Ubuntu 20.04 (Focal).

Note:

Docker images used to produce these build notes:

ubuntu:20.04

1. Install required dependencies

Update your package lists and install the necessary development tools and libraries:

Redis Open Source version management

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source provides comprehensive version management that prioritizes customer control over major changes.

Redis version structure

Redis uses a MAJOR.MINOR.PATCH versioning scheme:

Connect to your Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

With the Redis database created, you are ready to connect to your database to store data. You can use one of the following ways to test connectivity to your database:

Connect with redis-cli, the built-in command-line tool
Connect with a Hello World application written in Python

Remember we have two member Active-Active databases that are available for connections and concurrent reads and writes. The member Active-Active databases are using bi-directional replication to for the global Active-Active database.

Tag fields

Mon, 01 Jan 0001 00:00:00 +0000

Tag fields provide exact match search capabilities with high performance and memory efficiency. Use tag fields when you need to filter documents by specific values without the complexity of full-text search tokenization.

Tag fields interpret text as a simple list of tags delimited by a separator character. This approach enables simpler tokenization and encoding, making tag indexes much more efficient than full-text indexes. Note: even though tag and text fields both use text, they are two separate field types and so you don't query them the same way.

Active-Active examples

Mon, 01 Jan 0001 00:00:00 +0000

This page provides YAML examples for deploying Active-Active Redis Enterprise databases across multiple Kubernetes clusters. Active-Active databases provide multi-master replication with conflict resolution, enabling global distribution and local read/write access.

For complete deployment instructions, see Active-Active databases.

Applying the configuration

To deploy Active-Active databases using these YAML files, follow Create Active-Active database (REAADB), which provides detailed instructions for preparing clusters, creating RERC resources, and deploying REAADB configurations.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Configure CIDR allow list

Mon, 01 Jan 0001 00:00:00 +0000

The CIDR allow list lets you restrict traffic to your Redis Cloud database. When you configure an allow list, only the IP addresses defined in the list can connect to the database. Traffic from all other IP addresses is blocked.

Note:

To use the CIDR allow list, you must be on either paid Redis Cloud Essentials or on Redis Cloud Pro. This feature is not supported on free Redis Cloud Essentials plans.

Define CIDR allow list

To define the CIDR allow list for a database:

Client-side caching introduction

Mon, 01 Jan 0001 00:00:00 +0000

Client-side caching reduces network traffic between a Redis client and the server, which generally improves performance.

By default, an application server (which sits between the user app and the database) contacts the Redis database server through the client library for every read request. The diagram below shows the flow of communication from the user app, through the application server to the database and back again:

When you use client-side caching, the client library maintains a local cache of data items as it retrieves them from the database. When the same items are needed again, the client can satisfy the read requests from the cache instead of the database:

Probabilistic data structure configuration compatibility with Redis Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

Configure probabilistic data structures in Redis Software

Redis Enterprise Software lets you manually change any RedisBloom configuration setting.

Graph configuration compatibility with Redis Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

You cannot use GRAPH.CONFIG SET to configure RedisGraph in Redis Enterprise Software or Redis Cloud. Instead, use one of the following methods.

For Redis Cloud:

Flexible or Annual subscriptions: contact support to request a configuration change.
Free or Fixed subscriptions: you cannot change RedisGraph configuration.

For Redis Enterprise Software, use either:

rladmin tune db:

$ rladmin tune db db:<ID|name> module_name graph \
    module_config_params "setting-name setting-value"

Configure module REST API request:

POST /v1/modules/config/bdb/<ID>
{
  "modules": [
    {
      "module_name": "graph",
      "module_args": "setting-name setting-value"
    }
  ]
}

Setting	Redis Enterprise	Redis Cloud	Notes
CACHE_SIZE	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 25
MAX_QUEUED_QUERIES	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 25
NODE_CREATION_BUFFER	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 16384
OMP_THREAD_COUNT	✅ Supported	✅ Flexible & Annual* ❌ Free & Fixed	* Updates automatically when you change your plan. Redis Enterprise default: Set by plan Redis Cloud defaults: • Flexible & Annual: Set by plan • Free & Fixed: 1
QUERY_MEM_CAPACITY	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 100000000
RESULTSET_SIZE	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 10000
THREAD_COUNT	✅ Supported	✅ Flexible & Annual* ❌ Free & Fixed	* Updates automatically when you change your plan. Redis Enterprise default: Set by plan Redis Cloud defaults: • Flexible & Annual: Set by plan • Free & Fixed: 1
TIMEOUT	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 100
VKEY_MAX_ENTITY_COUNT	✅ Supported	✅ Flexible & Annual ❌ Free & Fixed	Default: 100000

Time series configuration compatibility with Redis Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

Configure time series in Redis Software

Redis Enterprise Software lets you manually change any RedisTimeSeries configuration setting.

Create Active-Active database (REAADB)

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

To create an Active-Active database, make sure you've completed all the following steps and have gathered the information listed below each step.

Customize installation directories

Mon, 01 Jan 0001 00:00:00 +0000

When you install Redis Enterprise Software on Red Hat Enterprise Linux, you can customize the installation directories.

The files are installed in the redislabs directory located in the path that you specify.

Considerations

When you install with custom directories, the installation does not run as an RPM file.

Data denormalization

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Discovery service

Mon, 01 Jan 0001 00:00:00 +0000

The Discovery Service provides an IP-based connection management service used when connecting to Redis Enterprise Software databases. When used in conjunction with Redis Enterprise Software's other high availability features, the Discovery Service assists an application scope with topology changes such as adding, removing of nodes, node failovers and so on. It does this by providing your application with the ability to easily discover which node hosts the database endpoint. The API used for discovery service is compliant with the Redis Sentinel API.

Enable a module for a database

Mon, 01 Jan 0001 00:00:00 +0000

Modules add additional functionality to Redis databases for specific use cases. You can enable modules when you create a database.

Automatically enabled capabilities in Redis 8

Databases created with or upgraded to Redis version 8 or later automatically enable the capabilities (modules) bundled with Redis Enterprise Software as follows:

Encrypt REST API requests

Mon, 01 Jan 0001 00:00:00 +0000

Require HTTPS for API endpoints

By default, the Redis Enterprise Software API supports communication over HTTP and HTTPS. However, you can turn off support for HTTP to ensure that API requests are encrypted.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v1.0.0 onwards, NRedisStack uses query dialect 2 by default. Redis query engine methods such as FT().Search() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the NRedisStack client library if you haven't already done so.

Index and query documents

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to create a search index for JSON documents and run queries against the index. It then goes on to show the slight differences in the equivalent code for hash documents.

Note:

From v6.0.0 onwards, redis-py uses query dialect 2 by default. Redis query engine methods such as ft().search() will explicitly request this dialect, overriding the default set for the server. See Query dialects for more information.

Initialize

Make sure that you have Redis Open Source or another Redis server available. Also install the redis-py client library if you haven't already done so.

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Manage Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

You can configure and manage your Active-Active database from either the Cluster Manager UI or the command line.

To change the global configuration of the Active-Active database, use crdb-cli.

If you need to apply changes locally to one database instance, you use the Cluster Manager UI or rladmin.

Database settings

Many Active-Active database settings can be changed after database creation. One notable exception is database clustering. Database clustering can't be turned on or off after the database has been created.

Migrate data between Redis Cloud databases

Mon, 01 Jan 0001 00:00:00 +0000

There are times when you need to migrate data from one Redis Cloud database to another.

Here are two common ways to do this.

Each approach is suitable for different situations and the steps can vary according to your needs.

Transfer via import

The most common way to transfer data to a new database is to import a copy of the data into it.

Network security

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud supports two types of network security: database-level CIDR allow lists and VPC-wide CIDR allow lists.

These features are available in most Redis Cloud configurations, as shown here:

Cloud provider	VPC peering	IP restrictions
AWS	Redis Cloud Pro	Paid Redis Cloud Essentials and Redis Cloud Pro
Google Cloud	Redis Cloud Pro	Paid Redis Cloud Essentials and Redis Cloud Pro
Azure	Redis Cloud Pro	Redis Cloud Pro

IP and subnet restrictions

You can restrict database access to a configurable set of source IP addresses and subnets. This is roughly equivalent to using iptables to limit access to a host.

Configure password complexity rules

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software provides optional password complexity rules that meet common requirements. When enabled, these rules require the password to have:

At least 8 characters
At least one uppercase character
At least one lowercase character
At least one number
At least one special character

These requirements reflect v6.2.12 and later. Earlier versions did not support numbers or special characters as the first or the last character of a password. This restriction was removed in v6.2.12.

Configure database persistence

Mon, 01 Jan 0001 00:00:00 +0000

Data is stored in RAM or a combination of RAM and flash memory (Redis Flex and Auto Tiering), which risks data loss during process or server failures. Redis Enterprise Software supports multiple methods to persist data to disk on a per-database basis to ensure data durability.

You can configure persistence during database creation or by editing an existing database. Although the persistence model can be changed dynamically, the switch can take time depending on the database size and the models being switched.

RedisEnterpriseActiveActiveDatabase API Reference

Mon, 01 Jan 0001 00:00:00 +0000

apiVersion:

app.redislabs.com/v1alpha1

app.redislabs.com/v1alpha1

RedisEnterpriseActiveActiveDatabase is the Schema for the redisenterpriseactiveactivedatabase API

RedisEnterpriseCluster API Reference

Mon, 01 Jan 0001 00:00:00 +0000

apiVersion:

app.redislabs.com/v1

app.redislabs.com/v1

RedisEnterpriseCluster is the Schema for the redisenterpriseclusters API

Establish external routing on the RedisEnterpriseCluster

Mon, 01 Jan 0001 00:00:00 +0000

An Ingress is an API resource that provides a standardized and flexible way to manage external access to services running within a Kubernetes cluster.

Install Ingress controller

Redis Enterprise for Kubernetes supports the Ingress controllers below:

RedisEnterpriseDatabase API Reference

Mon, 01 Jan 0001 00:00:00 +0000

apiVersion:

app.redislabs.com/v1alpha1

app.redislabs.com/v1alpha1

RedisEnterpriseDatabase is the Schema for the redisenterprisedatabases API

Upgrade a Redis cluster to Redis 8

Mon, 01 Jan 0001 00:00:00 +0000

Note:

The supported upgrade paths are:

Redis Open Source 7.x (with or without modules) to Redis 8 in Redis Open Source
Redis Stack 7.2 or 7.4 to Redis 8 in Redis Open Source

Note:

It's essential to practice upgrading Redis in a controlled environment before upgrading it in a production environment. Docker is an excellent tool to use for this purpose.

RedisEnterpriseRemoteCluster API Reference

Mon, 01 Jan 0001 00:00:00 +0000

apiVersion:

app.redislabs.com/v1alpha1

app.redislabs.com/v1alpha1

RedisEntepriseRemoteCluster represents a remote participating cluster.

Row Format

Mon, 01 Jan 0001 00:00:00 +0000

Explanation of the row formats supported by Redis Data Integration jobs.

Search and query Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

Starting with RediSearch 2.x, supported in Redis Enterprise Software (RS) 6.0 and later, you can enable search and query for Active-Active databases at the time of creation.

You can run search operations on any instance of an Active-Active database.

How it works

Create an Active-Active database with RediSearch 2.x enabled. Active-Active databases created with or upgraded to Redis version 8 or later automatically enable search and query.
Create the index on each instance of the database.
If you are using synonyms, you need to add them to each replica.
The index is maintained by each instance outside of the database keyspace, so only updates to the hashes in the databases are synchronized.

Command compatibility

Active-Active databases do not support the following search and query commands:

Redis sets

Mon, 01 Jan 0001 00:00:00 +0000

A Redis set is an unordered collection of unique strings (members). You can use Redis sets to efficiently:

Track unique items (e.g., track all unique IP addresses accessing a given blog post).
Represent relations (e.g., the set of all users with a given role).
Perform common set operations such as intersection, unions, and differences.

Basic commands

SADD adds a new member to a set.
SREM removes the specified member from the set.
SISMEMBER tests a string for set membership.
SINTER returns the set of members that two or more sets have in common (i.e., the intersection).
SCARD returns the size (a.k.a. cardinality) of a set.

See the complete list of set commands.

Shard placement policy

Mon, 01 Jan 0001 00:00:00 +0000

In Redis Enterprise Software, the location of master and replica shards on the cluster nodes can impact the database and node performance. Master shards and their corresponding replica shards are always placed on separate nodes for data resiliency. The shard placement policy helps to maintain optimal performance and resiliency.

In addition to the shard placement policy, considerations that determine shard placement are:

Separation of master and replica shards
Available persistence and Auto Tiering storage
Rack-zone awareness
Memory available to host the database when fully populated

The shard placement policies are:

Supported platforms

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software is supported on several operating systems, cloud environments, and virtual environments.

Supported platforms

✅ Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.

Supported platforms

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software is supported on several operating systems, cloud environments, and virtual environments.

Supported platforms

✅ Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.

Synchronize cluster node clocks

Mon, 01 Jan 0001 00:00:00 +0000

To avoid problems with internal cluster communications that can impact your data integrity, make sure that the clocks on all of the cluster nodes are synchronized using Chrony and/or NTP.

When you install Redis Enterprise Software, the install script checks if Chrony or NTP is running. If they are not, the installation process asks for permission to configure a scheduled Cron job. This should make sure that the node's clock is always synchronized. If you did not confirm configuring this job during the installation process, you must use the Network Time Protocol (NTP) regularly to make sure that all server clocks are synchronized.

Transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis Transactions allow the execution of a group of commands in a single step, they are centered around the commands MULTI, EXEC, DISCARD and WATCH. Redis Transactions make two important guarantees:

All the commands in a transaction are serialized and executed sequentially. A request sent by another client will never be served in the middle of the execution of a Redis Transaction. This guarantees that the commands are executed as a single isolated operation.

Troubleshooting

Mon, 01 Jan 0001 00:00:00 +0000

Common challenges

Vector sets are approximate by design. That makes debugging trickier than with exact match queries. This section helps you understand issues with recall, filtering, and graph structure.

Build and run Redis Open Source on Ubuntu 22.04 (Jammy)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running Ubuntu 22.04 (Jammy).

Note:

Docker images used to produce these build notes:

ubuntu:22.04

1. Install required dependencies

First, update your package lists and install the development tools and libraries needed to build Redis:

Upgrading RDI

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Upgrade a database to Search 2.x

Mon, 01 Jan 0001 00:00:00 +0000

RediSearch 2.x includes some significant architectural changes that improve functionality. The main change is that RediSearch 2.x stores indexes outside of the Redis database that contains the data. This makes commands more efficient and improves replication between clusters because the index changes are managed by the participating clusters rather than being synchronized with the data.

This change allows databases with RediSearch to support:

Active-Active databases
Database cluster re-sharding
Replica Of to a sharded destination database
EXPIRE of documents reflected in the index

In addition, RediSearch 2.x indexes data that already existed in the database at the time that the index was created.

Upgrade a Redis Software cluster

Mon, 01 Jan 0001 00:00:00 +0000

Before you upgrade a cluster to a later Redis Software version, review the supported upgrade paths and prerequisites.

To upgrade a cluster's Redis Software version, use one of the following methods:

In-place upgrade - Directly upgrade Redis Software on each node in the cluster. Although this method is simpler than the rolling upgrade method, it might cause brief service interruptions as each node is upgraded.
Rolling upgrade - Minimize downtime by adding new nodes with an updated Redis Software version to the cluster, one at a time, while keeping the rest of the cluster operational. This method is recommended for production environments that require continuous availability.

Supported upgrade paths for Redis Software

Mon, 01 Jan 0001 00:00:00 +0000

Supported upgrade paths

✅ Supported – You can upgrade directly from the current Redis Software cluster version.

Using SQL CASE

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Redis 6.2

Mon, 01 Jan 0001 00:00:00 +0000

Redis version 6.2 introduces new capabilities designed to improve data indexing, querying, and analytics. This update brings multi-value indexing, expanded wildcard query support, and a new probabilistic data structure for quantile estimation. Additionally, significant enhancements to Redis streams and time series data processing offer greater flexibility for developers working with real-time and historical datasets. Over 25 new commands have been added to Redis that address key feature requests and further extending its capabilities. Below is a detailed breakdown of these improvements.

Write to a Redis hash

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write to a Redis JSON document

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write to a Redis set

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write to a Redis sorted set

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write to a Redis stream

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write to a Redis string

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write-behind foreach example

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Write-behind to Redis Enterprise target example

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Highlighting

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source uses advanced algorithms for highlighting and summarizing, which enable only the relevant portions of a document to appear in response to a search query. This feature allows users to immediately understand the relevance of a document to their search criteria, typically highlighting the matching terms in bold text.

Command syntax

FT.SEARCH ...
    SUMMARIZE [FIELDS {num} {field}] [FRAGS {numFrags}] [LEN {fragLen}] [SEPARATOR {sepstr}]
    HIGHLIGHT [FIELDS {num} {field}] [TAGS {openTag} {closeTag}]

There are two sub-commands used for highlighting. The first is HIGHLIGHT, which surrounds matching text with an open and/or close tag. The second is SUMMARIZE, which splits a field into contextual fragments surrounding the found terms. It is possible to summarize a field, highlight a field, or perform both actions in the same query.

Migrate database shards

Mon, 01 Jan 0001 00:00:00 +0000

To migrate database shards to other nodes in the cluster, you can use the rladmin migrate command or REST API requests.

Use cases for shard migration

Migrate database shards to a different node in the following scenarios:

Manage database tags

Mon, 01 Jan 0001 00:00:00 +0000

Tags are key-value pairs that let you categorize your databases. You can create tags and add them to your databases to associate them with each other. Once you've added tags, you can filter your databases in the database list or in the cost report by tag key or value.

Manage tags

You can manage tags from the Redis Cloud console in the tag manager. You can find the tag manager in the following places:

Key and field expiration behavior

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Query Engine behavior with expiring keys and hash fields has been enhanced starting with Redis 8 to provide more consistent and predictable results.

Key expiration

Expiration times

Before Redis 8: Expiration times were not taken into account when computing the result set.

Delete Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

When you delete an Active-Active database (formerly known as CRDB), all instances of the Active-Active database are deleted from all participating clusters.

Warning:

This action is immediate, non-reversible, and has no rollback.

Because Active-Active databases are made up of instances on multiple participating clusters, to restore a deleted Active-Active database you must create the database again with all of its instances and then restore the data to the database from backup.

Map LDAP groups to roles

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software uses a role-based mechanism to enable LDAP authentication and authorization.

Once LDAP is enabled, you need to map LDAP groups to Redis Enterprise access control roles.

Map LDAP groups to roles

To map LDAP groups to access control roles in the Cluster Manager UI:

Monitor database performance

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud provides a variety of metrics to help you monitor database performance. You can view graphs of performance data at any time and receive emails when performance crosses defined thresholds.

View database metrics

The Metrics tab of the View Database screen provides a series of graphs showing performance data for your database.

Recover a failed database

Mon, 01 Jan 0001 00:00:00 +0000

When a cluster fails or a database is corrupted, you must:

Restore the cluster configuration from the CCS files
Recover the databases with their previous configuration and data

To restore data to databases in the new cluster, you must restore the database persistence files (backup, AOF, or snapshot files) to the databases. These files are stored in the persistence storage location.

The database recovery process includes:

If the cluster failed, recover the cluster.
Identify recoverable databases.
Restore the database data.
Verify that the databases are active.

Prerequisites

Before you start database recovery, make sure that the cluster that hosts the database is healthy. In the case of a cluster failure, you must recover the cluster before you recover the databases.

System logs

Mon, 01 Jan 0001 00:00:00 +0000

The Logs page contains events, alerts, and logs from the activities, databases, and subscriptions associated with your account.

You can:

Sort the list by a specific field in descending or ascending order. Supported fields include Time, Originator, Database name, API key name, and Activity.

Build and run Redis Open Source on Ubuntu 24.04 (Noble)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running Ubuntu 24.04 (Noble).

Note:

Docker images used to produce these build notes:

ubuntu:24.04

1. Install required dependencies

First, update your package lists and install the development tools and libraries needed to build Redis:

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

You can use vector sets to store any type of numeric vector but they are particularly optimized to work with text embedding vectors (see Redis for AI to learn more about text embeddings). The example below shows how to use the Hugot library to generate vector embeddings and then store and retrieve them using a vector set with go-redis.

Delete databases

Mon, 01 Jan 0001 00:00:00 +0000

When you delete a database, both the database configuration and data are removed.

To delete a database from the Cluster Manager UI:

From the Databases list, select the database, then select Configuration.
Select Delete.
In the Delete database dialog, confirm deletion.

Scoring documents

Mon, 01 Jan 0001 00:00:00 +0000

When searching, documents are scored based on their relevance to the query. The score is a floating point number between 0.0 and 1.0, where 1.0 is the highest score. The score is returned as part of the search results and can be used to sort the results.

Redis Open Source comes with a few scoring functions to evaluate document relevance. They are all based on document scores and term frequency. This is regardless of the ability to use sortable fields. Scoring functions are specified by adding the SCORER {scorer_name} argument to a search query.

Redis Cloud changelog (December 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Logs Viewer role

You can now add a user with the Logs Viewer role in the Access Management screen. Logs Viewers can only use the Redis Cloud API GET logs/ endpoint.

Download and analyze cost report

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Cloud cost report gives you a detailed breakdown of your Redis Cloud subscription usage and associated charges. You can use it to track, audit, and optimize your Redis Cloud spending across Essentials and Pro subscription plans.

You can download the cost report from the Billing and payments and Usage reports pages. You can also use the Redis Cloud REST API to get a cost report in FOCUS format.

Select the Cost report button to download a report of all shard costs in CSV format.

Add new fields to a key

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with a primary database in near real time.

Block public endpoints

Mon, 01 Jan 0001 00:00:00 +0000

By default, you can connect to Redis Cloud databases through the database's public endpoint, or through the database's private endpoint with a private connectivity method.

Public endpoints are accessible from the public internet and don't require a private connectivity method. While this makes Redis Cloud databases convenient to use, it also exposes the databases to potential unauthorized access or brute force attacks, even with a database password in place. Some organizations may want to block public access to their databases to comply with security policies or to better meet stringent compliance standards.

Customize system user and group

Mon, 01 Jan 0001 00:00:00 +0000

By default, Redis Enterprise Software is installed with the user:group redislabs:redislabs.

During installation, you can specify the user and group that own all Redis Enterprise Software processes.

Considerations

Custom installation user is supported on Red Hat Enterprise Linux and compatible distributions.

Database backup and import

Mon, 01 Jan 0001 00:00:00 +0000

Back up a database

When you create or update a database, you can specify the (optional) periodicBackupPath parameter with a backup path. This parameter enables periodic and on-demand backup operations for the specified database.

Edit participating clusters for Active-Active database

Mon, 01 Jan 0001 00:00:00 +0000

Note:

This feature is supported for general availability in releases 6.4.2-6 and later. Some of these features were available as a preview in 6.4.2-4 and 6.4.2-5. Please upgrade to 6.4.2-6 for the full set of general availability features and bug fixes. and later.

Add a participating cluster

Use the following steps to add a participating cluster to an existing Redis Enterprise Active-Active database (REAADB) for Kubernetes.

Enable TLS

Mon, 01 Jan 0001 00:00:00 +0000

You can use TLS authentication for one or more of the following types of communication:

Communication from clients (applications) to your database
Communication from your database to other clusters for replication using Replica Of
Communication to and from your database to other clusters for synchronization using Active-Active

Note:

When you enable or turn off TLS, the change applies to new connections but does not affect existing connections. Clients must close existing connections and reconnect to apply the change.

Enable TLS for client connections

To enable TLS for client connections:

Encryption at rest

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud databases write their data to disk whenever persistence is enabled.

Redis Cloud deployments are always encrypted at rest.

Encryption at rest on AWS

Persistent data is written to encrypted EBS volumes. For more information, see Amazon EBS encryption.

Ensure port availability

Mon, 01 Jan 0001 00:00:00 +0000

Before installing Redis Enterprise Software, make sure all required ports are available.

If ports that Redis assigns to the database are being used by the operating system or other processes, the installation fails.

Follow the relevant sections to configure required ports.

For recommended and optional port configuration, see Network port configurations.

Update `sysctl.conf` to avoid port collisions

To avoid port collision, update /etc/sysctl.conf to include:

Flush database data

Mon, 01 Jan 0001 00:00:00 +0000

To delete the data in a database without deleting the database configuration, you can flush the data from the database.

You can use the Cluster Manager UI to flush data from Active-Active databases.

Warning:

The flush command deletes ALL in-memory and persistence data in the database. We recommend that you back up your database before you flush the data.

Flush data from a database

From the command line, you can flush a database with the redis-cli command or with your favorite Redis client.

Formatting date and time values

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with a primary database in near real time.

Redis hashes

Mon, 01 Jan 0001 00:00:00 +0000

Redis hashes are record types structured as collections of field-value pairs. You can use hashes to represent basic objects and to store groupings of counters, among other things.

Language:

> HSET bike:1 model Deimos brand Ergonom type 'Enduro bikes' price 4972
(integer) 4
> HGET bike:1 model
"Deimos"
> HGET bike:1 price
"4972"
> HGETALL bike:1
1) "model"
2) "Deimos"
3) "brand"
4) "Ergonom"
5) "type"
6) "Enduro bikes"
7) "price"
8) "4972"

"""
Code samples for Hash doc pages:
    https://redis.io/docs/latest/develop/data-types/hashes/
"""
import redis

r = redis.Redis(decode_responses=True)
res1 = r.hset(
    "bike:1",
    mapping={
        "model": "Deimos",
        "brand": "Ergonom",
        "type": "Enduro bikes",
        "price": 4972,
    },
)
print(res1)
# >>> 4

res2 = r.hget("bike:1", "model")
print(res2)
# >>> 'Deimos'

res3 = r.hget("bike:1", "price")
print(res3)
# >>> '4972'

res4 = r.hgetall("bike:1")
print(res4)
# >>> {'model': 'Deimos', 'brand': 'Ergonom', 'type': 'Enduro bikes', 'price': '4972'}



res5 = r.hmget("bike:1", ["model", "price"])
print(res5)
# >>> ['Deimos', '4972']


res6 = r.hincrby("bike:1", "price", 100)
print(res6)
# >>> 5072
res7 = r.hincrby("bike:1", "price", -100)
print(res7)
# >>> 4972



res11 = r.hincrby("bike:1:stats", "rides", 1)
print(res11)
# >>> 1
res12 = r.hincrby("bike:1:stats", "rides", 1)
print(res12)
# >>> 2
res13 = r.hincrby("bike:1:stats", "rides", 1)
print(res13)
# >>> 3
res14 = r.hincrby("bike:1:stats", "crashes", 1)
print(res14)
# >>> 1
res15 = r.hincrby("bike:1:stats", "owners", 1)
print(res15)
# >>> 1
res16 = r.hget("bike:1:stats", "rides")
print(res16)
# >>> 3
res17 = r.hmget("bike:1:stats", ["crashes", "owners"])
print(res17)
# >>> ['1', '1']

import assert from 'assert';
import { createClient } from 'redis';

const client = createClient();
await client.connect();
const res1 = await client.hSet(
  'bike:1',
  {
    'model': 'Deimos',
    'brand': 'Ergonom',
    'type': 'Enduro bikes',
    'price': 4972,
  }
)
console.log(res1) // 4

const res2 = await client.hGet('bike:1', 'model')
console.log(res2)  // 'Deimos'

const res3 = await client.hGet('bike:1', 'price')
console.log(res3)  // '4972'

const res4 = await client.hGetAll('bike:1')
console.log(res4)  
/*
{
  brand: 'Ergonom',
  model: 'Deimos',
  price: '4972',
  type: 'Enduro bikes'
}
*/


const res5 = await client.hmGet('bike:1', ['model', 'price'])
console.log(res5)  // ['Deimos', '4972']


const res6 = await client.hIncrBy('bike:1', 'price', 100)
console.log(res6)  // 5072
const res7 = await client.hIncrBy('bike:1', 'price', -100)
console.log(res7)  // 4972


const res11 = await client.hIncrBy('bike:1:stats', 'rides', 1)
console.log(res11)  // 1
const res12 = await client.hIncrBy('bike:1:stats', 'rides', 1)
console.log(res12)  // 2
const res13 = await client.hIncrBy('bike:1:stats', 'rides', 1)
console.log(res13)  // 3
const res14 = await client.hIncrBy('bike:1:stats', 'crashes', 1)
console.log(res14)  // 1
const res15 = await client.hIncrBy('bike:1:stats', 'owners', 1)
console.log(res15)  // 1
const res16 = await client.hGet('bike:1:stats', 'rides')
console.log(res16)  // 3
const res17 = await client.hmGet('bike:1:stats', ['crashes', 'owners'])
console.log(res17)  // ['1', '1']

package io.redis.examples;

import redis.clients.jedis.UnifiedJedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class HashExample {

  public void run() {
    try (UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379")) {

      Map<String, String> bike1 = new HashMap<>();
      bike1.put("model", "Deimos");
      bike1.put("brand", "Ergonom");
      bike1.put("type", "Enduro bikes");
      bike1.put("price", "4972");

      Long res1 = jedis.hset("bike:1", bike1);
      System.out.println(res1); // 4

      String res2 = jedis.hget("bike:1", "model");
      System.out.println(res2); // Deimos

      String res3 = jedis.hget("bike:1", "price");
      System.out.println(res3); // 4972

      Map<String, String> res4 = jedis.hgetAll("bike:1");
      System.out.println(res4); // {type=Enduro bikes, brand=Ergonom, price=4972, model=Deimos}


      List<String> res5 = jedis.hmget("bike:1", "model", "price");
      System.out.println(res5); // [Deimos, 4972]


      Long res6 = jedis.hincrBy("bike:1", "price", 100);
      System.out.println(res6); // 5072
      Long res7 = jedis.hincrBy("bike:1", "price", -100);
      System.out.println(res7); // 4972


      Long res8 = jedis.hincrBy("bike:1:stats", "rides", 1);
      System.out.println(res8); // 1
      Long res9 = jedis.hincrBy("bike:1:stats", "rides", 1);
      System.out.println(res9); // 2
      Long res10 = jedis.hincrBy("bike:1:stats", "rides", 1);
      System.out.println(res10); // 3
      Long res11 = jedis.hincrBy("bike:1:stats", "crashes", 1);
      System.out.println(res11); // 1
      Long res12 = jedis.hincrBy("bike:1:stats", "owners", 1);
      System.out.println(res12); // 1
      String res13 = jedis.hget("bike:1:stats", "rides");
      System.out.println(res13); // 3
      List<String> res14 = jedis.hmget("bike:1:stats", "crashes", "owners");
      System.out.println(res14); // [1, 1]

    }
  }
}

package io.redis.examples.async;

import io.lettuce.core.*;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.StatefulRedisConnection;

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class HashExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisAsyncCommands<String, String> asyncCommands = connection.async();

            Map<String, String> bike1 = new HashMap<>();
            bike1.put("model", "Deimos");
            bike1.put("brand", "Ergonom");
            bike1.put("type", "Enduro bikes");
            bike1.put("price", "4972");

            CompletableFuture<Void> setGetAll = asyncCommands.hset("bike:1", bike1).thenCompose(res1 -> {
                System.out.println(res1); // >>> 4
                return asyncCommands.hget("bike:1", "model");
            }).thenCompose(res2 -> {
                System.out.println(res2); // >>> Deimos
                return asyncCommands.hget("bike:1", "price");
            }).thenCompose(res3 -> {
                System.out.println(res3); // >>> 4972
                return asyncCommands.hgetall("bike:1");
            })
                    .thenAccept(System.out::println)
                    // >>> {type=Enduro bikes, brand=Ergonom, price=4972, model=Deimos}
                    .toCompletableFuture();

            CompletableFuture<Void> hmGet = setGetAll.thenCompose(res4 -> {
                return asyncCommands.hmget("bike:1", "model", "price");
            })
                    .thenAccept(System.out::println)
                    // [KeyValue[model, Deimos], KeyValue[price, 4972]]
                    .toCompletableFuture();

            CompletableFuture<Void> hIncrBy = hmGet.thenCompose(r -> {
                return asyncCommands.hincrby("bike:1", "price", 100);
            }).thenCompose(res6 -> {
                System.out.println(res6); // >>> 5072
                return asyncCommands.hincrby("bike:1", "price", -100);
            })
                    .thenAccept(System.out::println)
                    // >>> 4972
                    .toCompletableFuture();

            CompletableFuture<Void> incrByGetMget = asyncCommands.hincrby("bike:1:stats", "rides", 1).thenCompose(res7 -> {
                System.out.println(res7); // >>> 1
                return asyncCommands.hincrby("bike:1:stats", "rides", 1);
            }).thenCompose(res8 -> {
                System.out.println(res8); // >>> 2
                return asyncCommands.hincrby("bike:1:stats", "rides", 1);
            }).thenCompose(res9 -> {
                System.out.println(res9); // >>> 3
                return asyncCommands.hincrby("bike:1:stats", "crashes", 1);
            }).thenCompose(res10 -> {
                System.out.println(res10); // >>> 1
                return asyncCommands.hincrby("bike:1:stats", "owners", 1);
            }).thenCompose(res11 -> {
                System.out.println(res11); // >>> 1
                return asyncCommands.hget("bike:1:stats", "rides");
            }).thenCompose(res12 -> {
                System.out.println(res12); // >>> 3
                return asyncCommands.hmget("bike:1:stats", "crashes", "owners");
            })
                    .thenAccept(System.out::println)
                    // >>> [KeyValue[crashes, 1], KeyValue[owners, 1]]
                    .toCompletableFuture();

            CompletableFuture.allOf(
                    hIncrBy, incrByGetMget).join();
        } finally {
            redisClient.shutdown();
        }
    }

}

package io.redis.examples.reactive;

import io.lettuce.core.*;
import io.lettuce.core.api.reactive.RedisReactiveCommands;
import io.lettuce.core.api.StatefulRedisConnection;

import reactor.core.publisher.Mono;

import java.util.*;

public class HashExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();

            Map<String, String> bike1 = new HashMap<>();
            bike1.put("model", "Deimos");
            bike1.put("brand", "Ergonom");
            bike1.put("type", "Enduro bikes");
            bike1.put("price", "4972");

            Mono<Long> setGetAll = reactiveCommands.hset("bike:1", bike1).doOnNext(result -> {
                System.out.println(result); // >>> 4
            });

            setGetAll.block();

            Mono<String> getModel = reactiveCommands.hget("bike:1", "model").doOnNext(result -> {
                System.out.println(result); // >>> Deimos
            });

            Mono<String> getPrice = reactiveCommands.hget("bike:1", "price").doOnNext(result -> {
                System.out.println(result); // >>> 4972
            });

            Mono<List<KeyValue<String, String>>> getAll = reactiveCommands.hgetall("bike:1").collectList().doOnNext(result -> {
                System.out.println(result);
                // >>> [KeyValue[type, Enduro bikes], KeyValue[brand, Ergonom],
                // KeyValue[price, 4972], KeyValue[model, Deimos]]
            });

            Mono<List<KeyValue<String, String>>> hmGet = reactiveCommands.hmget("bike:1", "model", "price").collectList()
                    .doOnNext(result -> {
                        System.out.println(result);
                        // >>> [KeyValue[model, Deimos], KeyValue[price, 4972]]
                    });

            Mono.when(getModel, getPrice, getAll, hmGet).block();

            Mono<Void> hIncrBy = reactiveCommands.hincrby("bike:1", "price", 100).doOnNext(result -> {
                System.out.println(result); // >>> 5072
            }).flatMap(v -> reactiveCommands.hincrby("bike:1", "price", -100)).doOnNext(result -> {
                System.out.println(result); // >>> 4972
            }).then();
            hIncrBy.block();

            Mono<Void> incrByGetMget = reactiveCommands.hincrby("bike:1:stats", "rides", 1).doOnNext(result -> {
                System.out.println(result); // >>> 1
            }).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "rides", 1)).doOnNext(result -> {
                System.out.println(result); // >>> 2
            }).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "rides", 1)).doOnNext(result -> {
                System.out.println(result); // >>> 3
            }).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "crashes", 1)).doOnNext(result -> {
                System.out.println(result); // >>> 1
            }).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "owners", 1)).doOnNext(result -> {
                System.out.println(result); // >>> 1
            }).then();

            incrByGetMget.block();

            Mono<String> getRides = reactiveCommands.hget("bike:1:stats", "rides").doOnNext(result -> {
                System.out.println(result); // >>> 3
            });

            Mono<List<KeyValue<String, String>>> getCrashesOwners = reactiveCommands.hmget("bike:1:stats", "crashes", "owners")
                    .collectList().doOnNext(result -> {
                        System.out.println(result);
                        // >>> [KeyValue[crashes, 1], KeyValue[owners, 1]]
                    });

            Mono.when(getRides, getCrashesOwners).block();
        } finally {
            redisClient.shutdown();
        }
    }

}

package example_commands_test

import (
	"context"
	"fmt"

	"github.com/redis/go-redis/v9"
)


func ExampleClient_set_get_all() {
	ctx := context.Background()

	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password docs
		DB:       0,  // use default DB
	})


	hashFields := []string{
		"model", "Deimos",
		"brand", "Ergonom",
		"type", "Enduro bikes",
		"price", "4972",
	}

	res1, err := rdb.HSet(ctx, "bike:1", hashFields).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res1) // >>> 4

	res2, err := rdb.HGet(ctx, "bike:1", "model").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res2) // >>> Deimos

	res3, err := rdb.HGet(ctx, "bike:1", "price").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res3) // >>> 4972

	cmdReturn := rdb.HGetAll(ctx, "bike:1")
	res4, err := cmdReturn.Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res4)
	// >>> map[brand:Ergonom model:Deimos price:4972 type:Enduro bikes]

	type BikeInfo struct {
		Model string `redis:"model"`
		Brand string `redis:"brand"`
		Type  string `redis:"type"`
		Price int    `redis:"price"`
	}

	var res4a BikeInfo

	if err := cmdReturn.Scan(&res4a); err != nil {
		panic(err)
	}

	fmt.Printf("Model: %v, Brand: %v, Type: %v, Price: $%v\n",
		res4a.Model, res4a.Brand, res4a.Type, res4a.Price)
	// >>> Model: Deimos, Brand: Ergonom, Type: Enduro bikes, Price: $4972

}

func ExampleClient_hmget() {
	ctx := context.Background()

	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password docs
		DB:       0,  // use default DB
	})


	hashFields := []string{
		"model", "Deimos",
		"brand", "Ergonom",
		"type", "Enduro bikes",
		"price", "4972",
	}

	_, err := rdb.HSet(ctx, "bike:1", hashFields).Result()

	if err != nil {
		panic(err)
	}

	cmdReturn := rdb.HMGet(ctx, "bike:1", "model", "price")
	res5, err := cmdReturn.Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res5) // >>> [Deimos 4972]

	type BikeInfo struct {
		Model string `redis:"model"`
		Brand string `redis:"-"`
		Type  string `redis:"-"`
		Price int    `redis:"price"`
	}

	var res5a BikeInfo

	if err := cmdReturn.Scan(&res5a); err != nil {
		panic(err)
	}

	fmt.Printf("Model: %v, Price: $%v\n", res5a.Model, res5a.Price)
	// >>> Model: Deimos, Price: $4972

}

func ExampleClient_hincrby() {
	ctx := context.Background()

	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password docs
		DB:       0,  // use default DB
	})


	hashFields := []string{
		"model", "Deimos",
		"brand", "Ergonom",
		"type", "Enduro bikes",
		"price", "4972",
	}

	_, err := rdb.HSet(ctx, "bike:1", hashFields).Result()

	if err != nil {
		panic(err)
	}

	res6, err := rdb.HIncrBy(ctx, "bike:1", "price", 100).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res6) // >>> 5072

	res7, err := rdb.HIncrBy(ctx, "bike:1", "price", -100).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res7) // >>> 4972

}

func ExampleClient_incrby_get_mget() {
	ctx := context.Background()

	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password docs
		DB:       0,  // use default DB
	})


	res8, err := rdb.HIncrBy(ctx, "bike:1:stats", "rides", 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res8) // >>> 1

	res9, err := rdb.HIncrBy(ctx, "bike:1:stats", "rides", 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res9) // >>> 2

	res10, err := rdb.HIncrBy(ctx, "bike:1:stats", "rides", 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res10) // >>> 3

	res11, err := rdb.HIncrBy(ctx, "bike:1:stats", "crashes", 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res11) // >>> 1

	res12, err := rdb.HIncrBy(ctx, "bike:1:stats", "owners", 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res12) // >>> 1

	res13, err := rdb.HGet(ctx, "bike:1:stats", "rides").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res13) // >>> 3

	res14, err := rdb.HMGet(ctx, "bike:1:stats", "crashes", "owners").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res14) // >>> [1 1]

}


using NRedisStack.Tests;
using StackExchange.Redis;

public class HashExample
{
    public void Run()
    {
        var muxer = ConnectionMultiplexer.Connect("localhost:6379");
        var db = muxer.GetDatabase();
        db.KeyDelete("bike:1");
        db.HashSet("bike:1", [
            new("model", "Deimos"),
            new("brand", "Ergonom"),
            new("type", "Enduro bikes"),
            new("price", 4972)
        ]);

        Console.WriteLine("Hash Created");
        // Hash Created

        var model = db.HashGet("bike:1", "model");
        Console.WriteLine($"Model: {model}");
        // Model: Deimos

        var price = db.HashGet("bike:1", "price");
        Console.WriteLine($"Price: {price}");
        // Price: 4972

        var bike = db.HashGetAll("bike:1");
        Console.WriteLine("bike:1");
        Console.WriteLine(string.Join("\n", bike.Select(b => $"{b.Name}: {b.Value}")));
        // Bike:1:
        // model: Deimos
        // brand: Ergonom
        // type: Enduro bikes
        // price: 4972


        var values = db.HashGet("bike:1", ["model", "price"]);
        Console.WriteLine(string.Join(" ", values));
        // Deimos 4972

        var newPrice = db.HashIncrement("bike:1", "price", 100);
        Console.WriteLine($"New price: {newPrice}");
        // New price: 5072

        newPrice = db.HashIncrement("bike:1", "price", -100);
        Console.WriteLine($"New price: {newPrice}");
        // New price: 4972

        var rides = db.HashIncrement("bike:1", "rides");
        Console.WriteLine($"Rides: {rides}");
        // Rides: 1

        rides = db.HashIncrement("bike:1", "rides");
        Console.WriteLine($"Rides: {rides}");
        // Rides: 2

        rides = db.HashIncrement("bike:1", "rides");
        Console.WriteLine($"Rides: {rides}");
        // Rides: 3

        var crashes = db.HashIncrement("bike:1", "crashes");
        Console.WriteLine($"Crashes: {crashes}");
        // Crashes: 1

        var owners = db.HashIncrement("bike:1", "owners");
        Console.WriteLine($"Owners: {owners}");
        // Owners: 1

        var stats = db.HashGet("bike:1", ["crashes", "owners"]);
        Console.WriteLine($"Bike stats: crashes={stats[0]}, owners={stats[1]}");
        // Bike stats: crashes=1, owners=1
    }
}

<?php

require 'vendor/autoload.php';

use Predis\Client as PredisClient;

class DtHashTest
{
    public function testDtHash() {
        $r = new PredisClient([
            'scheme'   => 'tcp',
            'host'     => '127.0.0.1',
            'port'     => 6379,
            'password' => '',
            'database' => 0,
        ]);

        $res1 = $r->hmset('bike:1', [
            'model' => 'Deimos',
            'brand' => 'Ergonom',
            'type' => 'Enduro bikes',
            'price' => 4972,
        ]);

        echo $res1 . PHP_EOL;
        // >>> 4

        $res2 = $r->hget('bike:1', 'model');
        echo $res2 . PHP_EOL;
        // >>> Deimos

        $res3 = $r->hget('bike:1', 'price');
        echo $res3 . PHP_EOL;
        // >>> 4972

        $res4 = $r->hgetall('bike:1');
        echo json_encode($res3) . PHP_EOL;
        // >>> {"name":"Deimos","brand":"Ergonom","type":"Enduro bikes","price":"4972"}

        $res5 = $r->hmget('bike:1', ['model', 'price']);
        echo json_encode($res5) . PHP_EOL;
        // >>> ["Deimos","4972"]

        $res6 = $r->hincrby('bike:1', 'price', 100);
        echo $res6 . PHP_EOL;
        // >>> 5072

        $res7 = $r->hincrby('bike:1', 'price', -100);
        echo $res7 . PHP_EOL;
        // >>> 4972

        $res8 = $r->hincrby('bike:1:stats', 'rides', 1);
        echo $res8 . PHP_EOL;
        // >>> 1

        $res9 = $r->hincrby('bike:1:stats', 'rides', 1);
        echo $res9 . PHP_EOL;
        // >>> 2

        $res10 = $r->hincrby('bike:1:stats', 'rides', 1);
        echo $res10 . PHP_EOL;
        // >>> 3

        $res11 = $r->hincrby('bike:1:stats', 'crashes', 1);
        echo $res11 . PHP_EOL;
        // >>> 1

        $res12 = $r->hincrby('bike:1:stats', 'owners', 1);
        echo $res12 . PHP_EOL;
        // >>> 1

        $res13 = $r->hget('bike:1:stats', 'rides');
        echo $res13 . PHP_EOL;
        // >>> 3

        $res14 = $r->hmget('bike:1:stats', ['crashes', 'owners']);
        echo json_encode($res14) . PHP_EOL;
        // >>> ["1","1"]
    }
}

mod hash_tests {
    use redis::Commands;

    fn run() {
        let mut r = match redis::Client::open("redis://127.0.0.1") {
            Ok(client) => {
                match client.get_connection() {
                    Ok(conn) => conn,
                    Err(e) => {
                        println!("Failed to connect to Redis: {e}");
                        return;
                    }
                }
            },
            Err(e) => {
                println!("Failed to create Redis client: {e}");
                return;
            }
        };

        let hash_fields = [
            ("model", "Deimos"),
            ("brand", "Ergonom"),
            ("type", "Enduro bikes"),
            ("price", "4972"),
        ];

        if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
            let res: String = res;
            println!("{res}");    // >>> OK
        }

        match r.hget("bike:1", "model") {
            Ok(res) => {
                let res: String = res;
                println!("{res}");   // >>> Deimos
            },
            Err(e) => {
                println!("Error getting bike:1 model: {e}");
                return;
            }
        };

        match r.hget("bike:1", "price") {
            Ok(res) => {
                let res: String = res;
                println!("{res}");   // >>> 4972
            },
            Err(e) => {
                println!("Error getting bike:1 price: {e}");
                return;
            }
        };

        match r.hgetall("bike:1") {
            Ok(res) => {
                let res: Vec<(String, String)> = res;
                println!("{res:?}");
                // >>> [("model", "Deimos"), ("brand", "Ergonom"), ("type", "Enduro bikes"), ("price", "4972")]
            },
            Err(e) => {
                println!("Error getting bike:1: {e}");
                return;
            }
        };

        match r.hmget("bike:1", &["model", "price"]) {
            Ok(res) => {
                let res: Vec<String> = res;
                println!("{res:?}");   // >>> ["Deimos", "4972"]
            },
            Err(e) => {
                println!("Error getting bike:1: {e}");
                return;
            }
        };

        if let Ok(res) = r.hincr("bike:1", "price", 100) {
            let res: i32 = res;
            println!("{res}");    // >>> 5072
        }

        if let Ok(res) = r.hincr("bike:1", "price", -100) {
            let res: i32 = res;
            println!("{res}");    // >>> 4972
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1) {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1) {
            let res: i32 = res;
            println!("{res}");    // >>> 2
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1) {
            let res: i32 = res;
            println!("{res}");    // >>> 3
        }

        if let Ok(res) = r.hincr("bike:1:stats", "crashes", 1) {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        if let Ok(res) = r.hincr("bike:1:stats", "owners", 1) {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        match r.hget("bike:1:stats", "rides") {
            Ok(res) => {
                let res: i32 = res;
                println!("{res}");   // >>> 3
            },
            Err(e) => {
                println!("Error getting bike:1:stats rides: {e}");
                return;
            }
        };

        match r.hmget("bike:1:stats", &["crashes", "owners"]) {
            Ok(res) => {
                let res: Vec<i32> = res;
                println!("{res:?}");   // >>> [1, 1]
            },
            Err(e) => {
                println!("Error getting bike:1:stats crashes and owners: {e}");
                return;
            }
        };
    }
}

mod tests {
    use redis::AsyncCommands;

    async fn run() {
        let mut r = match redis::Client::open("redis://127.0.0.1") {
            Ok(client) => {
                match client.get_multiplexed_async_connection().await {
                    Ok(conn) => conn,
                    Err(e) => {
                        println!("Failed to connect to Redis: {e}");
                        return;
                    }
                }
            },
            Err(e) => {
                println!("Failed to create Redis client: {e}");
                return;
            }
        };

        let hash_fields = [
            ("model", "Deimos"),
            ("brand", "Ergonom"),
            ("type", "Enduro bikes"),
            ("price", "4972"),
        ];

        if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
            let res: String = res;
            println!("{res}");    // >>> OK
        }

        match r.hget("bike:1", "model").await {
            Ok(res) => {
                let res: String = res;
                println!("{res}");   // >>> Deimos
            },
            Err(e) => {
                println!("Error getting bike:1 model: {e}");
                return;
            }
        };

        match r.hget("bike:1", "price").await {
            Ok(res) => {
                let res: String = res;
                println!("{res}");   // >>> 4972
            },
            Err(e) => {
                println!("Error getting bike:1 price: {e}");
                return;
            }
        };

        match r.hgetall("bike:1").await {
            Ok(res) => {
                let res: Vec<(String, String)> = res;
                println!("{res:?}");
                // >>> [("model", "Deimos"), ("brand", "Ergonom"), ("type", "Enduro bikes"), ("price", "4972")]
            },
            Err(e) => {
                println!("Error getting bike:1: {e}");
                return;
            }
        };

        match r.hmget("bike:1", &["model", "price"]).await {
            Ok(res) => {
                let res: Vec<String> = res;
                println!("{res:?}");   // >>> ["Deimos", "4972"]
            },
            Err(e) => {
                println!("Error getting bike:1: {e}");
                return;
            }
        };

        if let Ok(res) = r.hincr("bike:1", "price", 100).await {
            let res: i32 = res;
            println!("{res}");    // >>> 5072
        }

        if let Ok(res) = r.hincr("bike:1", "price", -100).await {
            let res: i32 = res;
            println!("{res}");    // >>> 4972
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1).await {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1).await {
            let res: i32 = res;
            println!("{res}");    // >>> 2
        }

        if let Ok(res) = r.hincr("bike:1:stats", "rides", 1).await {
            let res: i32 = res;
            println!("{res}");    // >>> 3
        }

        if let Ok(res) = r.hincr("bike:1:stats", "crashes", 1).await {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        if let Ok(res) = r.hincr("bike:1:stats", "owners", 1).await {
            let res: i32 = res;
            println!("{res}");    // >>> 1
        }

        match r.hget("bike:1:stats", "rides").await {
            Ok(res) => {
                let res: i32 = res;
                println!("{res}");   // >>> 3
            },
            Err(e) => {
                println!("Error getting bike:1:stats rides: {e}");
                return;
            }
        };

        match r.hmget("bike:1:stats", &["crashes", "owners"]).await {
            Ok(res) => {
                let res: Vec<i32> = res;
                println!("{res:?}");   // >>> [1, 1]
            },
            Err(e) => {
                println!("Error getting bike:1:stats crashes and owners: {e}");
                return;
            }
        };
    }
}

While hashes are handy to represent objects, actually the number of fields you can put inside a hash has no practical limits (other than available memory), so you can use hashes in many different ways inside your application.

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

Index and query vectors

Mon, 01 Jan 0001 00:00:00 +0000

JMESPath custom functions

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

JMESPath custom functions

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Manage user login

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software secures user access in a few different ways, including automatically:

Locking user accounts after a series of authentication failures (invalid passwords)
Signing sessions out after a period of inactivity

Here, you learn how to configure the relevant settings.

By default, after 5 failed login attempts within 15 minutes, the user account is locked for 30 minutes. You can change the user login lockout settings in the Cluster Manager UI or with rladmin.

Multi-namespace examples

Mon, 01 Jan 0001 00:00:00 +0000

Multi-namespace deployment lets a single Redis Enterprise operator manage clusters and databases in different namespaces, providing better resource isolation and organization.

Multi-namespace deployment enables:

Namespace isolation: Separate Redis Enterprise resources by team, environment, or application
Centralized management: Single operator manages multiple namespaces
Resource sharing: Efficient use of cluster resources across namespaces
Flexible RBAC: Fine-grained permissions per namespace

This example shows:

Operator namespace: redis-enterprise-operator (where the operator and REC run)
Consumer namespaces: app-production, app-staging (where REDB resources are created)

For complete deployment instructions, see Manage databases in multiple namespaces.

Notebooks collection

Mon, 01 Jan 0001 00:00:00 +0000

Notebook	Category	Description
The place to start if you are brand new to Redis	Introduction	Great for Redis beginners looking for a guided Colab experience.	Open in Colab
Implementing hybrid search with Redis	Hybrid and Vector Search	Combines vector similarity with keyword filters.	Open in Colab
Vector search with Redis Python client	Hybrid and Vector Search	Demonstrates pure vector search using the Redis Python client.	Open in Colab
Vector search with Redis Vector Library	Hybrid and Vector Search	Uses RedisVL for advanced vector indexing and querying.	Open in Colab
Shows how to convert a float32 index to float16 or integer data types	Hybrid and Vector Search	Demonstrates data type optimization for vector indices.	Open in Colab
RAG from scratch with Redis Vector Library	RAG	Basic RAG implementation using RedisVL.	Open in Colab
RAG using Redis and LangChain	RAG	Shows integration between Redis and LangChain for RAG.	Open in Colab
RAG using Redis and LlamaIndex	RAG	Walkthrough of RAG with Redis and LlamaIndex.	Open in Colab
Advanced RAG with RedisVL	RAG	Advanced concepts and techniques using RedisVL.	Open in Colab
RAG using Redis and Nvidia	RAG	NVIDIA + Redis for LLM context retrieval.	Open in Colab
Utilize RAGAS framework to evaluate RAG performance	RAG	Evaluation of RAG apps using the RAGAS framework.	Open in Colab
Implement a simple RBAC policy with vector search using Redis	RAG	Role-based access control implementation for RAG systems.	Open in Colab
LangGraph and agents	Agents	Getting started with agent workflows.	Open in Colab
Movie recommendation system	Agents	Collaborative agent-based movie recommender.	Open in Colab
Full-Featured Agent Architecture	Agents	Comprehensive agent implementation with advanced features.	Open in Colab
Optimize semantic cache threshold with RedisVL	Semantic Cache	Performance optimization for semantic caching systems.	Open in Colab
Simple examples of how to build an allow/block list router in addition to a multi-topic router	Semantic Router	Basic routing patterns and access control mechanisms.	Open in Colab
Use `RouterThresholdOptimizer` from RedisVL to setup best router config	Semantic Router	Router configuration optimization using RedisVL.	Open in Colab
Facial recognition	Computer Vision	Face matching using Facenet and RedisVL.	Open in Colab
Content filtering with RedisVL	Recommendation Systems	Introduction to content-based filtering.	Open in Colab
Collaborative filtering with RedisVL	Recommendation Systems	Intro to collaborative filtering with RedisVL.	Open in Colab
Intro deep learning two tower example with RedisVL	Recommendation Systems	Deep learning approach to recommendation systems.	Open in Colab
Credit scoring system using Feast with Redis as the online store	Feature Store	Feature store implementation for ML model serving.	Open in Colab

Additional resources

Looking for more ways to learn about Redis for AI? Check out our:

Redis Cloud changelog (November 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New Features

Pro subscription version upgrade

You can now upgrade all databases in your Pro subscription from your subscription page.

Observability

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Upgrade Redis Enterprise with OpenShift OperatorHub

Mon, 01 Jan 0001 00:00:00 +0000

Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:

Prerequisites

The following steps ensure you have the minimum versions of all components necessary to upgrade. Without these minimum versions, the upgrade will freeze and require manual recovery.

Use persistent volumes in Redis Enterprise clusters

Mon, 01 Jan 0001 00:00:00 +0000

Storage types

Redis Enterprise for Kubernetes can only use storage classes supported by block storage. Block storage is mounted at the Kubernetes node level and utilizes EXT4 or XFS file systems. It can be sourced from enterprise-grade SANs or cloud environments such as EBS, Azure Managed Disks, or GCP persistent disks.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

To execute commands in a pipeline, you first create a pipeline object and then add commands to it using methods that resemble the standard command methods (for example, Set() and Get()). The commands are buffered in the pipeline and only execute when you call the Exec() method on the pipeline object.

Connection pools and multiplexing

Mon, 01 Jan 0001 00:00:00 +0000

Redis example code generally opens a connection, demonstrates a command or feature, and then closes. Real-world code typically has short bursts of communication with the server and periods of inactivity in between. Opening and closing connections involves some overhead and leads to inefficiency if you do it frequently. This means that you can improve the performance of production code by making as few separate connections as possible.

Managing connections in your own code can be tricky, so the Redis client libraries give you some help. The two basic approaches to connection management are called connection pooling and multiplexing. The redis-py, jedis, and go-redis clients support connection pooling, while NRedisStack supports multiplexing. Lettuce supports both approaches.

Configure proxy policy

Mon, 01 Jan 0001 00:00:00 +0000

Redis Software provides high-performance data access through a proxy process that manages and optimizes access to shards within the Redis Software cluster. Each node contains a single proxy process. Each proxy can be active and take incoming traffic or it can be passive and wait for failovers.

Proxy policies

A database can have one of the following proxy policies:

Redis feature sets

Mon, 01 Jan 0001 00:00:00 +0000

A Redis feature set includes a specific Redis database version along with the advanced capabilities and data structures provided by compatible module versions.

To use a new feature introduced in a later feature set, you must upgrade the corresponding components according to the following table.

Redis feature set	What's new
Feature set version: 8.4	See here
Feature set version: 8.2	See here
Feature set version: 8.0	See here
Feature set version: 7.4 Component versions: Redis 7.4 Search 2.10 JSON 2.8 Time series 1.12 Bloom 2.8	Hash: - Expiration of individual hash fields. Streams: - To start reading from the last stream message, use `XREAD` with the new ID value `+`. Time series: Insertion-filter for close samples. JSON: - A fix to not duplicate `AOF` commands multiple times in `JSON.MSET`. Probabilistic: - Returns an error if `CMS.MERGE` results in an overflow or underflow. Redis Query Engine: - New `BFLOAT16` and `FLOAT16` vector data types, reducing memory consumed by vectors while preserving accuracy. - Support for indexing empty and missing values and enhanced developer experience for queries with exact matching capabilities. - You can match `TAG` fields without needing to escape special characters. - Expanded geospatial search with new `INTERSECT` and `DISJOINT` operators, improved reporting of the memory consumed by the index, and exposed full-text scoring in aggregation pipelines.
Feature set version: 7.2 Component versions: Redis 7.2 Search 2.8 JSON 2.6 Time series 1.10 Bloom 2.6 Gears 2.0	- Performance and resource utilization improvements, including significant memory and speed optimizations for lists, sets, and sorted sets. JSON: - New JSON commands: `JSON.MERGE` and `JSON.MSET`. Redis Query Engine: - Geo polygon search. Compatibility changes: - Redis 7.2 uses a new format (version 11) for RDB files, which is incompatible with older versions. - Redis feature set 7.2 does not include graph capabilities.
Feature set version: 6.2 Component versions: Redis 6.2 Search 2.6 JSON 2.4 Time series 1.8 Bloom 2.4 Graph 2.10	Time series: - Time series gap filling. JSON: - Improved JSON path parser. Probabilistic: - New probabilistic data structure t-digest. Redis Query Engine: - Wildcard queries for `TEXT` and `TAG`. - Suffix search. - Multi-value indexing and queries. Graph: - New pathfinding algorithms for graphs.

Remapping the fields in the output

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Remove fields from a key

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with a primary database in near real time.

Database replication

Mon, 01 Jan 0001 00:00:00 +0000

Database replication helps ensure high availability. When replication is enabled, your dataset is replicated to a replica shard, which is constantly synchronized with the primary shard. If the primary shard fails, an automatic failover happens and the replica shard is promoted. That is, it becomes the new primary shard.

When the old primary shard recovers, it becomes the replica shard of the new primary shard. This auto-failover mechanism guarantees that data is served with minimal interruption.

Restructure JSON or hash objects

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with a primary database in near real time.

RG.JDUMPSESSIONS

Mon, 01 Jan 0001 00:00:00 +0000

RG.JDUMPSESSIONS [VERBOSE] [SESSIONS s1 s2 ...]

Outputs information about existing Java sessions.

Note:

When you run the RG.JEXECUTE command, it creates a Java session.

Arguments

Name	Description
VERBOSE	Output more details about registrations.
SESSIONS	Only output information about sessions that appears in the given list. Can only be the last argument.

Returns

Returns information about existing Java sessions.

RG.JEXECUTE

Mon, 01 Jan 0001 00:00:00 +0000

RG.JEXECUTE <path.to.main.class> [UPGRADE] <JAR file>

Executes a Java function.

The code runs immediately if it uses GearsBuilder.run(). Code that uses GearsBuilder.register() will run later, every time certain events occur in the database.

Arguments

Name	Description
path.to.main.class	The path to the main class in the JAR
JAR file	A JAR file that contains the RedisGears code to run or register
UPGRADE	Upgrades registered code to a new version

Returns

If the executed code calls GearsBuilder.run(), it returns the output of the executed code.

Schedule periodic backups

Mon, 01 Jan 0001 00:00:00 +0000

Periodic backups provide a way to restore data with minimal data loss. With Redis Enterprise Software, you can schedule periodic backups to occur once a day (every 24 hours), twice a day (every twelve hours), every four hours, or every hour.

As of v6.2.8, you can specify the start time in UTC for 24-hour or 12-hour backups.

To make an on-demand backup, export your data.

You can schedule backups to a variety of locations, including:

Set custom expiration times / TTL

Mon, 01 Jan 0001 00:00:00 +0000

How to set expiration times / TTL for keys

Set the key name in the target database

Mon, 01 Jan 0001 00:00:00 +0000

Learn how to customize Redis key names when synchronizing data from your primary database using Redis Data Integration.

Stemming

Mon, 01 Jan 0001 00:00:00 +0000

RediSearch supports stemming - that is adding the base form of a word to the index. This allows the query for "hiring" to also return results for "hire" and "hired", for example.

The current stemming support is based on the Snowball stemmer library, which supports most European languages, as well as Arabic and other. See the "Supported languages" section below. We hope to include more languages soon (if you need a specific language support, please open an issue).

t-digest

Mon, 01 Jan 0001 00:00:00 +0000

The t-digest is a sketch data structure in Redis Open Source for estimating percentiles from a data stream or a large dataset using a compact sketch.

It can answer questions like:

Which fraction of the values in the data stream are smaller than a given value?
How many values in the data stream are smaller than a given value?
What's the highest value that's smaller than p percent of the values in the data stream? (what is the p-percentile value)?

What is t-digest?

t-digest is a data structure that will estimate a percentile point without having to store and order all the data points in a set. For example: to answer the question "What's the average latency for 99% of my database operations" we would have to store the average latency for every user, order the values, cut out the last 1% and only then find the average value of all the rest. This kind of process is costly not just in terms of the processing needed to order those values but also in terms of the space needed to store them. Those are precisely the problems t-digest solves.

Use the REST API

Mon, 01 Jan 0001 00:00:00 +0000

You can access and use the API endpoint URI (https://api.redislabs.com/v1) with any of the following tools:

The Swagger user interface
The cURL HTTP client
An HTTP client in any programming language

Note:

For the Redis Cloud API, there is a request limit of 400 requests per minute per Account API key. If you go past this limit, your API requests will fail.

Swagger user interface

The Swagger UI is useful for initial introduction and for learning about API operations, models, and simulated usage.

Redis Open Source 8.0 release notes

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source 8.0.5 (November 2025)

Update urgency: HIGH: There are critical bugs that may affect a subset of users.

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

You can use vector sets to store any type of numeric vector but they are particularly optimized to work with text embedding vectors (see Redis for AI to learn more about text embeddings). The example below shows how to use the Microsoft.ML library to generate vector embeddings and then store and retrieve them using a vector set with StackExchange.Redis.

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

Vector set embeddings

Mon, 01 Jan 0001 00:00:00 +0000

You can use vector sets to store any type of numeric vector but they are particularly optimized to work with text embedding vectors (see Redis for AI to learn more about text embeddings). The example below shows how to use the sentence-transformers library to generate vector embeddings and then store and retrieve them using a vector set with redis-py.

View and edit Redis Cloud Pro plan

Mon, 01 Jan 0001 00:00:00 +0000

To view the details of a Redis Cloud Pro subscription:

Sign in to the Redis Cloud console and select Subscriptions.
If you have more than one subscription, select the target subscription from the subscription list.
Your subscription details appear, along with a summary of your database details.

From here, you can:

Create replica databases on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

You can configure a replica of a database by creating an item in the replicaSources section of the RedisEnterpriseDatabase (REDB) custom resource.

A secret must be created with the stringData section containing the replica source URI as follows:

Create a secret with the replica source URI listed in the stringData field as follows:

apiVersion: v1
kind: Secret
metadata:
   name: my-replica-source
stringData:
   uri: <replica-source-uri-goes-here>

The replica source URL can be retrieved by going to "UI > database > configuration > Press the button Get Replica of source URL" in the administrative UI. But, this information can also be retrieved directly from the REST API as well.

Redis Cloud changelog (October 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New Features

Redis 7.4 Preview on Redis Cloud Pro

A preview of Redis 7.4 is now available on Redis Cloud Pro databases.

Synonym support

Mon, 01 Jan 0001 00:00:00 +0000

Redis Open Source supports synonyms. That is, searching for synonym words defined by the synonym data structure.

The synonym data structure is a set of groups, each of which contains synonym terms. For example, the following synonym data structure contains three groups, and each group contains three synonym terms:

{boy, child, baby}
{girl, child, baby}
{man, person, adult}

When these three groups are located inside the synonym data structure, it is possible to search for "child" and receive documents containing "boy", "girl", "child" and "baby".

Delete database

Mon, 01 Jan 0001 00:00:00 +0000

To delete a database, use the Delete button located in the Danger zone section of the database's Configuration tab.

Deleting a database requires the Account Owner role.

Deleted databases cannot be recovered. We recommend making a backup, just in case.

Sign in to the Redis Cloud console.
Select the database from the list. The Configuration tab is selected by default.
Scroll to the Danger zone.

Redis Enterprise Software observability and monitoring guidance

Mon, 01 Jan 0001 00:00:00 +0000

Observe Redis Enterprise resources and database perfomance indicators.

Redis Enterprise Software observability and monitoring guidance

Mon, 01 Jan 0001 00:00:00 +0000

Observe Redis Enterprise resources and database perfomance indicators.

Probabilistic data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports several probabilistic data types that let you calculate values approximately rather than exactly. The types fall into two basic categories:

Set operations: These types let you calculate (approximately) the number of items in a set of distinct values, and whether or not a given value is a member of a set.
Statistics: These types give you an approximation of statistics such as the quantiles, ranks, and frequencies of numeric data points in a list.

To see why these approximate calculations would be useful, consider the task of counting the number of distinct IP addresses that access a website in one day.

Probabilistic data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports several probabilistic data types that let you calculate values approximately rather than exactly. The types fall into two basic categories:

Set operations: These types let you calculate (approximately) the number of items in a set of distinct values, and whether or not a given value is a member of a set.
Statistics: These types give you an approximation of statistics such as the quantiles, ranks, and frequencies of numeric data points in a list.

To see why these approximate calculations would be useful, consider the task of counting the number of distinct IP addresses that access a website in one day.

Probabilistic data types

Mon, 01 Jan 0001 00:00:00 +0000

Redis supports several probabilistic data types that let you calculate values approximately rather than exactly. The types fall into two basic categories:

Set operations: These types let you calculate (approximately) the number of items in a set of distinct values, and whether or not a given value is a member of a set.
Statistics: These types give you an approximation of statistics such as the quantiles, ranks, and frequencies of numeric data points in a list.

To see why these approximate calculations would be useful, consider the task of counting the number of distinct IP addresses that access a website in one day.

Update database ACLs

Mon, 01 Jan 0001 00:00:00 +0000

To grant LDAP users access to a database, assign the mapped access role to the access control list (ACL) for the database.

In the Cluster Manager UI, go to Databases, then select the database from the list.
From the Security tab, select the Edit button.
In the Access Control List section, select + Add ACL.
Select the appropriate roles and then save your changes.

Upgrade database from Redis Cloud Essentials to Redis Cloud Pro

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud Essentials supports low throughput workflows. It supports a range of availability, persistence, and backup options, and can be great for testing and prototyping. However, if your databases need higher throughput, or you're missing features that are not available with Redis Cloud Essentials, you may want to upgrade Redis Cloud Essentials to Redis Cloud Pro.

For more information about the different subscription plans, see Subscription plans.

To upgrade your Essentials plan, see Upgrade subscription plan.

Redis Cloud changelog (July 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New Features

Query performance factor preview

When you create a Pro database with Search and query capabilities, you can now choose to boost your query capabilities with the Query performance factor. The query performance factor adds dedicated power specifically for Search and query. For more information, see Search and query sizing.

Spellchecking

Mon, 01 Jan 0001 00:00:00 +0000

Query spelling correction provides suggestions for misspelled search terms. For example, the term 'reids' may be a misspelled version of 'redis'.

In such cases, and as of v1.4, RediSearch can be used for generating alternatives to misspelled query terms. A misspelled term is a full text term (i.e., a word) that is:

Not a stop word
Not in the index
At least 3 characters long

The alternatives for a misspelled term are generated from the corpus of already-indexed terms and, optionally, one or more custom dictionaries. Alternatives become spelling suggestions based on their respective Levenshtein distances from the misspelled term. Each spelling suggestion is given a normalized score based on its occurrences in the index.

Redis Cloud changelog (June 2024)

Mon, 01 Jan 0001 00:00:00 +0000

Enhancements

Redis Cloud Essentials support for Terraform

The Redis Cloud Terraform provider now supports provisioning Redis Cloud Essentials databases. It also supports Active-Active databases with advanced capabilities.

Prometheus metrics v1

Mon, 01 Jan 0001 00:00:00 +0000

You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.

Prometheus metrics v1

Mon, 01 Jan 0001 00:00:00 +0000

You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.

Geospatial

Mon, 01 Jan 0001 00:00:00 +0000

Redis Query Engine supports geospatial data. This feature lets you store geographical locations and geometric shapes in the fields of JSON objects.

Note:

Take care not to confuse the geospatial indexing features in Redis Query Engine with the Geospatial data type that Redis also supports. Although there are some similarities between these two features, the data type is intended for simpler use cases and doesn't have the range of format options and queries available in Redis Query Engine.

You can index these fields and use queries to find the objects by their location or the relationship of their shape to other shapes. For example, if you add the locations of a set of shops, you can find all the shops within 5km of a user's position or determine which ones are within the boundary of a particular town.

Transition from Prometheus v1 to Prometheus v2

Mon, 01 Jan 0001 00:00:00 +0000

Transition from v1 metrics to v2 PromQL equivalents.

Transition from Prometheus v1 to Prometheus v2

Mon, 01 Jan 0001 00:00:00 +0000

Transition from v1 metrics to v2 PromQL equivalents.

Accumulate

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> accumulate(
    gears.operations.AccumulateOperation<T,I> accumulator)

public <I extends java.io.Serializable> GearsBuilder<I> accumulate(
    I initialValue, 
    gears.operations.AccumulateOperation<T,I> accumulator)

Accumulate is a many-to-one function that iterates through the records in the pipe and reduces them to a single record.

You can provide a parameter to set the initial accumulator value. Otherwise, the initial accumulator object is null.

Parameters

Type parameters:

AccumulateBy

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> accumulateBy(
	gears.operations.ExtractorOperation<T> extractor, 
	gears.operations.AccumulateByOperation<T,I> accumulator)

public <I extends java.io.Serializable> GearsBuilder<I> accumulateBy(
	gears.operations.ValueInitializerOperation<I> valueInitializer, 
	gears.operations.ExtractorOperation<T> extractor, 
	gears.operations.AccumulateByOperation<T,I> accumulator)

Iterates through the records in the pipe, groups them based on the provided extractor, and then reduces each group to a single record per group with the accumulator function.

The initial value of the accumulator is null unless you provide a value initializer operation as a parameter.

Store JSON in Active-Active databases

Mon, 01 Jan 0001 00:00:00 +0000

RedisJSON v2.2 adds support for JSON in Active-Active Redis Enterprise databases.

The design is based on A Conflict-Free Replicated JSON Datatype by Kleppmann and Beresford, but the implementation includes some changes. Several conflict resolution rule examples were adapted from this paper as well.

Create an Active-Active JSON database

To use JSON in an Active-Active database, you must enable JSON during database creation.

Alerts and events

Mon, 01 Jan 0001 00:00:00 +0000

The following alerts and events can appear in syslog and the Cluster Manager UI logs.

Alerts

Alert	UI message	Severity	Notes
aof_slow_disk_io	Redis performance is degraded as a result of disk I/O limits	True: error, False: info	Node alert
authentication_err	Error authenticating with the source database	error	BDB event
backup_delayed	Periodic backup has been delayed for longer than `<threshold>` minutes	True: warning, False: info	BDB alert; Has threshold parameter in the data section of the log entry
cpu_utilization	CPU utilization has reached `<threshold>`%	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
even_node_count	True high availability requires an odd number of nodes	True: warning, False: info	Cluster alert
ephemeral_storage	Ephemeral storage has reached `<threshold>`% of its capacity	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
free_flash	Flash storage has reached `<threshold>`% of its capacity	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
high_latency	Latency is higher than `<threshold>` milliseconds	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
high_syncer_lag	Sync lag is higher than `<threshold>` seconds	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
high_throughput	Throughput is higher than `<threshold>` RPS (requests per second)	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
inconsistent_rl_sw	Not all nodes in the cluster are running the same Redis Labs Enterprise Cluster version	True: warning, False: info	Cluster alert
insufficient_disk_aofrw	Node has insufficient disk space for AOF rewrite	True: error, False: info	Node alert
memory	Node memory has reached `<threshold>`% of its capacity	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
multiple_nodes_down	Multiple cluster nodes are down - this might cause data loss	True: warning, False: info	Cluster alert
net_throughput	Network throughput has reached `<threshold>` MB/s	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
ocsp_query_failed	Failed querying OCSP server	True: error, False: info	Cluster alert
ocsp_status_revoked	OCSP status revoked	True: error, False: info	Cluster alert
persistent_storage	Persistent storage has reached `<threshold>`% of its capacity	True: warning, False: info	Node alert; Has global_threshold parameter in the key/value section of the log entry
ram_dataset_overhead	RAM Dataset overhead in a shard has reached `<threshold>`% of its RAM limit	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
ram_overcommit	Cluster capacity is less than total memory allocated to its databases	True: error, False: info	Cluster alert
ram_values	Percent of values in a shard's RAM is lower than `<threshold>`% of its key count	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
shard_num_ram_values	Number of values in a shard's RAM is lower than `<threshold>` values	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
size	Dataset size has reached `<threshold>`% of the memory limit	True: warning, False: info	BDB alert; Has threshold parameter in the key/value section of the log entry
syncer_connection_error	Syncer connection error	error	BDB alert
syncer_general_error	Syncer general error	error	BDB alert
too_few_nodes_for_replication	Database replication requires at least two nodes in cluster	True: warning, False: info	Cluster alert

Events

Event	UI message	Severity	Notes
backup_failed	Backup failed	error	BDB event
backup_started	Backup started	info	BDB event
backup_succeeded	Backup succeeded	info	BDB event
bdb_created	Database created	info	BDB event
bdb_deleted	Database deleted	info	BDB event
bdb_updated	Database updated	info	BDB event; Indicates that a BDB configuration has been updated
checks_error	Node checks error	error	Node event; Indicates that one or more node checks have failed
cluster_updated	Cluster settings updated	info	Cluster event; Indicates that cluster settings have been updated
compression_unsup_err	Compression not supported by sync destination	error	BDB event
crossslot_err	Sharded destination does not support operation executed on source	error	BDB event
export_failed	Export failed	error	BDB event
export_started	Export started	info	BDB event
export_succeeded	Export succeeded	info	BDB event
import_failed	Import failed	error	BDB event
import_started	Import started	info	BDB event
import_succeeded	Import succeeded	info	BDB event
license_added	License added	info	Cluster event
license_deleted	License deleted	info	Cluster event
license_updated	License updated	info	Cluster event
node_abort_remove_request	Node abort remove request	info	Node event
node_joined	Node joined	info	Cluster event
node_operation_failed	Node operation failed	error	Cluster event
node_remove_abort_completed	Node remove abort completed	info	Cluster event; Node remove is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail
node_remove_abort_failed	Node remove abort failed	error	Cluster event; Node remove is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail
node_remove_completed	Node removed	info	Cluster event; Node remove is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail
node_remove_failed	Node removed	error	Cluster event; Node remove is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail
node_remove_request	Node remove request	info	Node event
user_created	User created	info	User event
user_deleted	User deleted	info	User event
user_updated	User updated	info	User event; Indicates that a user configuration has been updated

AsyncFilter

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> asyncFilter(
    gears.operations.AsyncFilterOperation<T> filter)

The asyncFilter function allows you to use a GearsFuture object to asynchronously filter out records in the pipe based on a given condition.

The filter operation should contain a conditional statement and return a boolean for each record:

If true, the record will continue through the pipe.
If false, it filters out the record.

Parameters

Name	Type	Description
filter	AsyncFilterOperation	A function that checks a condition for each record in the pipe. Returns a boolean.

Returns

Returns a GearsBuilder object with the same template type as the input builder.

AsyncForeach

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> asyncForeach(
    gears.operations.AsyncForeachOperation<T> foreach)

The asyncForeach function allows you to use a GearsFuture object to define a set of operations and run them asynchronously for each record in the pipe.

Parameters

Name	Type	Description
foreach	AsyncForeachOperation	The set of operations to run for each record

Returns

Returns a GearsBuilder object with a new template type.

AsyncMap

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> asyncMap(
	gears.operations.AsyncMapOperation<T,I> mapper)

The asyncMap function allows you to use a GearsFuture object to asynchronously map each input record in the pipe to an output record, one-to-one.

Parameters

Type parameters:

CallNext

Mon, 01 Jan 0001 00:00:00 +0000

public static java.lang.Object callNext(java.lang.String... args)

When you override a Redis command with the CommandOverrider, use callNext to run the next execution that overrides the command or the original command itself.

It is a more flexible version of callNextArray since the list of string arguments does not have to be an explicit String[] object. This allows function calls like: callNext("key", "value").

Parameters

Name	Type	Description
args	string	Redis command arguments

Returns

Returns the command result. It could be a string or an array of strings, depending on the command.

CallNextArray

Mon, 01 Jan 0001 00:00:00 +0000

public static native java.lang.Object callNextArray(
    java.lang.String[] command)

When you override a Redis command with the CommandOverrider, use callNextArray to run the next execution that overrides the command or the original command itself.

It accepts an array of strings, which represents the command arguments.

Parameters

Name	Type	Description
args	array of strings	Redis command arguments

Returns

Returns the command result. It could be a string or an array of strings, depending on the command.

Collect

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> collect()

Collects all of the records to the shard where the RedisGears job started.

Parameters

None

ConfigGet

Mon, 01 Jan 0001 00:00:00 +0000

public static java.lang.String configGet(java.lang.String key)

Gets the value of a RedisGears configuration setting.

Note:

You can set configuration values when you load the module or use the RG.CONFIGSET command.

Parameters

Name	Type	Description
key	string	The configuration setting to get

Returns

Returns the configuration value of a RedisGears configuration setting.

Compatibility with Redis Open Source configuration settings

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software and Redis Cloud only support a subset of Redis Open Source configuration settings. Using CONFIG GET or CONFIG SET with unsupported configuration settings returns an error.

Setting	Redis Enterprise	Redis Cloud	Notes
activerehashing	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
busy-reply-threshold	✅ Standard ✅ Active-Active	❌ Standard ❌ Active-Active	Value must be between 0 and 60000 milliseconds.
hash-max-listpack-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
hash-max-listpack-value	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
hash-max-ziplist-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
hash-max-ziplist-value	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
hll-sparse-max-bytes	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
list-compress-depth	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
list-max-listpack-size	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
list-max-ziplist-size	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
lua-time-limit	✅ Standard ✅ Active-Active	❌ Standard ❌ Active-Active	Value must be between 0 and 60000 milliseconds.
notify-keyspace-events	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
set-max-intset-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
slowlog-log-slower-than	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Value must be larger than 1000 microseconds.
slowlog-max-len	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active	Value must be between 128 and 1024.
stream-node-max-bytes	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
stream-node-max-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
tracking-table-max-keys	❌ Standard ❌ Active-Active	❌ Standard ❌ Active-Active	For Redis Software, use an update database configuration REST API request or `rladmin tune db` to set `tracking_table_max_keys` instead.
zset-max-listpack-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
zset-max-listpack-value	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
zset-max-ziplist-entries	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active
zset-max-ziplist-value	✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Configure TLS protocol

Mon, 01 Jan 0001 00:00:00 +0000

You can change TLS protocols to improve the security of your Redis Enterprise cluster and databases. The default settings are in line with industry best practices, but you can customize them to match the security policy of your organization.

Configure TLS protocol

The communications for which you can modify TLS protocols are:

Count

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<java.lang.Integer> count()

Counts the number of records in the pipe and returns the total as a single record.

Parameters

None

CreateGearsBuilder

Mon, 01 Jan 0001 00:00:00 +0000

public static <I extends java.io.Serializable> GearsBuilder<I> CreateGearsBuilder(
    gears.readers.BaseReader<I> reader)

public static <I extends java.io.Serializable> GearsBuilder<I> CreateGearsBuilder(
    gears.readers.BaseReader<I> reader, 
    java.lang.String desc)

Creates a new GearsBuilder object. Use this function instead of a GearsBuilder constructor to avoid type warnings.

Parameters

Type Parameters:

Delete a subscription

Mon, 01 Jan 0001 00:00:00 +0000

Note:

Once a subscription is deleted, it cannot be recovered. We recommend backing up your data before removing databases or subscriptions.

To delete a subscription:

Delete all databases from the subscription.

The number of databases for the subscription is shown in the subscription list. You cannot delete a subscription until there are zero databases in the subscription.

Deploy a pipeline

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Diagnostic logging

Mon, 01 Jan 0001 00:00:00 +0000

The diagnostic logging service collects detailed system logs, which you can use to troubleshoot Redis Enterprise Software.

View diagnostic logs

Diagnostic logs are collected at scheduled intervals and saved in the /var/opt/redislabs/log/diagnostics/ directory. Each diagnostic log file is overwritten with the new data at the scheduled collection interval.

Redis AI ecosystem integrations

Mon, 01 Jan 0001 00:00:00 +0000

Redis integrates with a wide range of AI frameworks, platforms, and tools to enhance your AI applications. This page highlights key ecosystem integrations that can help you build more powerful, efficient, and scalable AI solutions with Redis.


Kong AI Gateway & Redis	Unstructured & Redis	Mem0 & Redis
Combine Kong's AI Gateway with Redis for efficient AI request routing, caching, and rate limiting to optimize your AI infrastructure.	Accelerate AI workflows by using Redis to cache document processing results from Unstructured, reducing processing time and costs.	Implement smarter memory management for AI agents with Mem0's integration with Redis, providing persistent, queryable memory for LLMs.
LiteLLM & Redis	LangGraph & Redis	LangChain & Redis
Optimize LLM performance with LiteLLM's Redis caching capabilities, supporting both traditional and semantic caching to reduce costs and latency.	Build smarter AI agents with LangGraph's Redis integration for memory persistence, state management, and multi-agent coordination.	Leverage LangChain's Redis integration for vector storage, memory, and caching to create more capable AI applications with improved performance.
LlamaIndex & Redis	Amazon Bedrock & Redis	NVIDIA NIM & Redis
Use LlamaIndex with Redis as a vector store for efficient document indexing, retrieval, and querying in RAG applications.	Integrate Redis with Amazon Bedrock to enhance your generative AI applications with persistent memory and efficient vector search.	Deploy GenAI applications faster by combining NVIDIA NIM's inference optimization with Redis for vector search, caching, and data management.

Additional integrations

Microsoft Semantic Kernel: Use Redis as a vector store connector with Microsoft's Semantic Kernel framework.
DocArray: Leverage Redis as a document store and vector database with Jina AI's DocArray.
Redis Cloud on Vercel: Deploy and manage Redis databases directly from your Vercel dashboard with the Redis Cloud integration. Refer to the setup guide for more details.
Spring AI & Redis: Build powerful RAG applications by combining Spring AI's framework with Redis for vector storage and retrieval.
Kernel Memory & Redis: Create memory-enabled LLM applications using Microsoft's Kernel Memory with Redis for efficient storage and retrieval.

Getting started

To learn more about using Redis with AI frameworks and tools, check out our:

Enable OCSP stapling

Mon, 01 Jan 0001 00:00:00 +0000

OCSP (Online Certificate Status Protocol) lets a client or server verify the status (GOOD, REVOKED, or UNKNOWN) of a certificate maintained by a third-party certificate authority (CA).

To check whether a certificate is still valid or has been revoked, a client or server can send a request to the CA's OCSP server (also called an OCSP responder). The OCSP responder checks the certificate's status in the CA's certificate revocation list and sends the status back as a signed and timestamped response.

Encrypt private keys

Mon, 01 Jan 0001 00:00:00 +0000

Enable PEM encryption to automatically encrypt all private keys on disk. Public keys (.cert files) are not encrypted.

When certificates are rotated, the encrypted private keys are also rotated.

Enable PEM encryption

To enable PEM encryption and encrypt private keys on the disk, use rladmin or the REST API.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

When working with Redis, errors can occur for various reasons, including network issues, invalid commands, or resource constraints. This guide explains the types of errors you might encounter and how to handle them effectively.

Categories of errors

Redis errors fall into four main categories. The table below provides a quick overview of each type. Click on any error type to jump to its detailed section, which includes common causes, examples, handling strategies, and code examples.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

go-redis uses explicit error returns following Go's idiomatic error handling pattern. Code examples in the documentation often omit error handling for brevity, but it is essential in production code. This page explains how go-redis's error handling works and how to apply some common error handling patterns. For an overview of error types and handling strategies, see Error handling. See also Production usage for more information on connection management, timeouts, and other aspects of app reliability.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

Jedis uses exceptions to signal errors. Code examples in the documentation often omit error handling for brevity, but it is essential in production code. This page explains how Jedis's error handling works and how to apply common error handling patterns.

For an overview of error types and handling strategies, see Error handling. See also Production usage for more information on connection management, timeouts, and other aspects of app reliability.

Exception hierarchy

Jedis organizes exceptions in a hierarchy rooted at JedisException, which extends RuntimeException. All Jedis exceptions are unchecked exceptions:

Estimate cost

Mon, 01 Jan 0001 00:00:00 +0000

When you change your subscriptions and databases, you also change the cost of your deployment. With a dry-run request, you can evaluate the impact and obtain a new cost estimate before you deploy these changes:

Create subscription
Create a database
Update a database

Defining a dry-run request

API operations that support dry-run requests accept the dryRun boolean parameter in the JSON request body.

Execute

Mon, 01 Jan 0001 00:00:00 +0000

public static java.lang.Object execute(java.lang.String... command)

Runs a Redis command, similar to executeArray. However, the execute function is more flexible. Unlike executeArray, the list of string arguments does not have to be an explicit String[] object. It allows function calls like this: execute("SET", "key", "value").

Parameters

Name	Type	Description
command	string	A Redis command

Returns

Returns the command result. It could be a string or an array of strings, depending on the command.

ExecuteArray

Mon, 01 Jan 0001 00:00:00 +0000

public static native java.lang.Object executeArray(
    java.lang.String[] command)

Runs a Redis command. It accepts an array of strings, which represents the command to execute.

Parameters

Name	Type	Description
command	array of strings	A Redis command

Returns

Returns the command result. It could be a string or an array of strings, depending on the command.

FAQ

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Filter

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> filter(
    gears.operations.FilterOperation<T> filter)

Filters out records in the pipe based on a given condition.

The filter operation should contain a conditional statement and return a boolean for each record:

If true, the record will continue through the pipe.
If false, it filters out the record.

Parameters

Name	Type	Description
filter	FilterOperation	A function that checks a condition for each record in the pipe. Returns a boolean.

Returns

Returns a GearsBuilder object with the same template type as the input builder.

FlatMap

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> flatMap(
	gears.operations.FlatMapOperation<T,I> flatmapper)

Maps a single input record to one or more output records.

The FlatMap operation must return an Iterable. RedisGears splits the elements from the Iterable object and processes them as individual records.

Parameters

Type parameters:

Foreach

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> foreach(
    gears.operations.ForeachOperation<T> foreach)

Defines a set of operations to run for each record in the pipe.

Parameters

Name	Type	Description
foreach	ForeachOperation	The set of operations to run for each record

Returns

Returns a GearsBuilder object with a new template type.

Client-side geographic failover

Mon, 01 Jan 0001 00:00:00 +0000

Some Redis client libraries support Client-side geographic failover to improve the availability of connections to Redis databases. Use this page to get a general overview of the concepts and then see the documentation for your client library to learn how to configure it for failover and failback:

Jedis
redis-py (preview)

Concepts

You may have several Active-Active databases or independent Redis servers that are all suitable to serve your app. Typically, you would prefer to use some database endpoints over others for a particular instance of your app (perhaps the ones that are closest geographically to the app server to reduce network latency). However, if the best endpoint is not available due to a failure, it is generally better to switch to another, suboptimal endpoint than to let the app fail completely.

Client-side geographic failover

Mon, 01 Jan 0001 00:00:00 +0000

Jedis supports Client-side geographic failover to improve the availability of connections to Redis databases. This page explains how to configure Jedis for failover. For an overview of the concepts, see the main Client-side geographic failover page.

Failover configuration

Jedis uses the resilience4j library to detect connection problems using a circuit breaker design pattern.

Set global database configurations

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Enterprise Active-Active database (REAADB) custom resource contains the field .spec.globalConfigurations. This field sets configurations for the Active-Active database across all participating clusters, such as memory size, shard count, and the global database secrets.

The REAADB API reference contains a full list of available fields.

Edit global configurations

Edit or patch the REAADB custom resource with your global configuration changes.

Set global database secret

Mon, 01 Jan 0001 00:00:00 +0000

Set global database secret

One of the fields available for globalConfigurations is databaseSecretName which can point to a secret containing the database password. To set the database secret name and sync the data to all participating clusters, follow the steps below.

Hashtag

Mon, 01 Jan 0001 00:00:00 +0000

public static java.lang.String hashtag()

Returns a string that maps to the current shard according to the cluster slot mapping.

Note:

You can use the hashtag function when you need to create a key that resides on the current shard.

Parameters

None

LocalAccumulateBy

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> localAccumulateBy(
	gears.operations.ExtractorOperation<T> extractor, 
	gears.operations.AccumulateByOperation<T,I> accumulator)

The localAccumulateBy function is similar to accumulateBy, except it performs the operation locally on each shard without moving data between shards.

On each shard, it iterates through the records in the pipe, groups them based on the provided extractor, and then reduces each group to a single record per group with the accumulator function.

The initial value of the accumulator is null.

Log

Mon, 01 Jan 0001 00:00:00 +0000

public static void log(java.lang.String msg)

public static void log(java.lang.String msg, LogLevel level)

Writes a log message to the Redis log file. If you do not specify a LogLevel, it will default to NOTICE.

Parameters

Name	Type	Description
msg	string	The message to write to the log
level	LogLevel	The log level (DEBUG, NOTICE, VERBOSE, WARNING)

Returns

None

Log collector RBAC examples

Mon, 01 Jan 0001 00:00:00 +0000

This page provides YAML examples for configuring RBAC permissions for the Redis Enterprise log collector tool. The log collector requires different permission levels depending on the collection mode you choose.

For complete log collection instructions, see Collect logs.

Prerequisites

Install the Redis Enterprise operator
Appropriate permissions to create RBAC resources in target namespaces
Understanding of your deployment model (single namespace, multi-namespace, etc.)

Collection modes

The log collector has two collection modes that require different RBAC permissions:

Build and run Redis Open Source on macOS 13 (Ventura) and macOS 14 (Sonoma)

Mon, 01 Jan 0001 00:00:00 +0000

Follow the steps below to build and run Redis Open Source from its source code on a system running macOS 13 (Ventura) and macOS 14 (Sonoma).

1. Install homebrew

If Homebrew isn't already installed, follow the installation instructions on the Homebrew home page.

Manage logs

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise comes with a set of logs on the server and available through the user interface to assist users in investigating actions taken on the server and to troubleshoot issues.

Send logs to a remote logging server

Redis Enterprise sends logs to syslog by default. You can send these logs to a remote logging server by configuring syslog.

Manage API tasks

Mon, 01 Jan 0001 00:00:00 +0000

Examples of API operations that use tasks are:

create subscription
create database
update database
delete database

All create, update, and delete API operations (POST, PUT, and DELETE) and some query operations (GET) use tasks.

After you request an asynchronous operation, the operation returns a taskId that identities the specific task, and contains contextual and status data on the API operation performed by the task.

Tasks are part of the API processing and provisioning lifecycle.

Map

Mon, 01 Jan 0001 00:00:00 +0000

public <I extends java.io.Serializable> GearsBuilder<I> map(
	gears.operations.MapOperation<T,I> mapper)

Maps each input record in the pipe to an output record, one-to-one.

Parameters

Type parameters:

Redis Cloud changelog (May 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Multi-domain SAML setup

SAML single sign-on now supports multiple username domains. Select Manage domains on the Single sign-on screen to associate additional domains to your SAML setup.

Metrics and alerts for monitoring v1

Mon, 01 Jan 0001 00:00:00 +0000

Current monitoring system (deprecated)

The current monitoring system, which is deprecated as of Redis Enterprise Software version 7.22, consists of the following components:

Configure password expiration

Mon, 01 Jan 0001 00:00:00 +0000

Enable password expiration

To enforce an expiration of a user's password after a specified number of days:

Persistent and ephemeral node storage

Mon, 01 Jan 0001 00:00:00 +0000

For each node in the cluster, you can configure paths for both persistent storage and ephemeral storage. To do so, the volume must have full permissions for user and group redislabs or users:group redislabs:redislabs. See the Customize system user and group page for instructions.

Note:

The persistent storage and ephemeral storage discussed in this document are not related to Redis persistence or AWS ephemeral drives.

Persistent storage

Persistent storage is mandatory. The cluster uses persistent storage to store information that needs to persist if a shard or a node fails, such as server logs, configurations, and files.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

To execute commands in a pipeline, you first create a pipeline object and then add commands to it using methods that resemble the asynchronous versions of the standard command methods (for example, StringSetAsync() and StringGetAsync()). The commands are buffered in the pipeline and only execute when you call the Execute() method on the pipeline object.

Pipelines and transactions

Mon, 01 Jan 0001 00:00:00 +0000

Redis lets you send a sequence of commands to the server together in a batch. There are two types of batch that you can use:

Pipelines avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the Pipelining page for more information.
Transactions guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. See the Transactions page for more information.

Execute a pipeline

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Prometheus metrics v2

Mon, 01 Jan 0001 00:00:00 +0000

V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.

Prometheus metrics v2

Mon, 01 Jan 0001 00:00:00 +0000

V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.

Integrate hiredis with a Qt app

Mon, 01 Jan 0001 00:00:00 +0000

Qt is a popular cross-platform C++ framework that you can use to build command line and GUI apps. This guide explains how to use hiredis to connect to a Redis server from a Qt app.

Install Qt

You should first download and install the Qt development environment for your development platform, if you have not already done so. The example below briefly explains how to use Qt Creator to manage your project, but see the Qt Creator docs for an extensive set of examples and tutorials.

Register

Mon, 01 Jan 0001 00:00:00 +0000

public java.lang.String register()

public java.lang.String register(ExecutionMode mode)

public java.lang.String register(
    ExecutionMode mode, 
    gears.operations.OnRegisteredOperation onRegister, 
    gears.operations.OnUnregisteredOperation onUnregistered)

Registers the pipeline of functions to run when certain events occur. The registered functions will run each time the event occurs.

Execution modes:

Name	Description
ASYNC	Runs asynchronously on all of the shards.
ASYNC_LOCAL	Runs asynchronously but only on the current shard that generated the event.
SYNC	Runs synchronously only on the same shard that generated the event.

Note:

If you call register() without specifying an execution mode, it will default to ASYNC.

Parameters

Name	Type	Description
mode	ExecutionMode	The execution mode to use (ASYNC/ASYNC_LOCAL/SYNC)
onRegister	OnRegisteredOperation	Register callback that will be called on each shard upon register
onUnregistered	OnUnregisteredOperation	Unregister callback that will be called on each shard upon unregister

Returns

Returns a registration ID.

Repartition

Mon, 01 Jan 0001 00:00:00 +0000

public GearsBuilder<T> repartition(
	gears.operations.ExtractorOperation<T> extractor)

Moves records between the shards. The extracted data determines the new shard location for each record.

Parameters

Name	Type	Description
extractor	ExtractorOperation	Extracts a specific value from each record

Returns

Returns a GearsBuilder object with a new template type.

Configure high availability for replica shards

Mon, 01 Jan 0001 00:00:00 +0000

When you enable database replication, Redis Enterprise Software creates a replica of each primary shard. The replica shard will always be located on a different node than the primary shard to make your data highly available. If the primary shard fails or if the node hosting the primary shard fails, then the replica is promoted to primary.

Without replica high availability (replica_ha) enabled, the promoted primary shard becomes a single point of failure as the only copy of the data.

Run

Mon, 01 Jan 0001 00:00:00 +0000

public void run()

public void run(boolean jsonSerialize, boolean collect)

Runs the pipeline of functions immediately upon execution. It will only run once.

Parameters

Name	Type	Description
collect	boolean	Whether or not to collect the results from the entire cluster before returning them
jsonSerialize	boolean	Whether or not to serialize the results to JSON before returning them

Returns

None

SetError

Mon, 01 Jan 0001 00:00:00 +0000

public void setError(java.lang.String error) 
	throws java.lang.Exception

Sets an error message for an asynchronous computation.

Parameters

Name	Type	Description
error	string	An error message

Returns

None

SetResult

Mon, 01 Jan 0001 00:00:00 +0000

public void setResult(I result) 
	throws java.lang.Exception

Sets a computation to run asynchronously.

Parameters

Name	Type	Description
result	template type I	The result of a computation

Returns

None

Size and scale a Redis Enterprise cluster deployment on Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

The following article reviews the mechanism and methods available for sizing and scaling a Redis Enterprise cluster deployment.

For minimum and recommended sizing, always follow the sizing guidelines detailed in the Redis Enterprise hardware requirements.

Sizing and scaling cluster nodes

Setting the number of cluster nodes

Define the number of cluster nodes in redis-enterprise-cluster.yaml file.

Smart client handoffs

Mon, 01 Jan 0001 00:00:00 +0000

Smart client handoffs (SCH) is a feature of Redis Cloud and Redis Enterprise servers that lets them actively notify clients about planned server maintenance shortly before it happens. This lets a client reconnect or otherwise respond gracefully without significant interruptions in service.

SCH is primarily useful when server software or hardware upgrades are required. It provides two main features to help the client avoid disruptions in service during the maintenance period:

Redis sorted sets

Mon, 01 Jan 0001 00:00:00 +0000

A Redis sorted set is a collection of unique strings (members) ordered by an associated score. When more than one string has the same score, the strings are ordered lexicographically. Some use cases for sorted sets include:

Leaderboards. For example, you can use sorted sets to easily maintain ordered lists of the highest scores in a massive online game.
Rate limiters. In particular, you can use a sorted set to build a sliding-window rate limiter to prevent excessive API requests.

You can think of sorted sets as a mix between a Set and a Hash. Like sets, sorted sets are composed of unique, non-repeating string elements, so in some sense a sorted set is a set as well.

Top-K

Mon, 01 Jan 0001 00:00:00 +0000

Top K is a probabilistic data structure in Redis Open Source used to estimate the K highest-rank elements from a stream.

"Highest-rank" in this case means "elements with a highest number or score attached to them", where the score can be a count of how many times the element has appeared in the stream - thus making the data structure perfect for finding the elements with the highest frequency in a stream. One very common application is detecting network anomalies and DDoS attacks where Top K can answer the question: Is there a sudden increase in the flux of requests to the same address or from the same IP?

Transition cluster manager alerts to Prometheus alerts

Mon, 01 Jan 0001 00:00:00 +0000

As Redis Enterprise Software transitions from the deprecated monitoring system to the new metrics stream engine, some internal cluster manager alerts were deprecated in favor of external monitoring solutions.

You can use the following table to transition from the deprecated alerts and set up equivalent alerts in Prometheus with PromQL (Prometheus Query Language):

Cluster manager alert	Equivalent PromQL	Description
BdbSizeAlert	`sum by(db, cluster) (redis_server_used_memory) / sum by(db, cluster) (redis_server_maxmemory) > 0.8`	Redis server memory usage exceeds 80%
NodeMemoryAlert	`(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes > 0.7`	Node memory usage exceeds 70%
NodeFreeFlashAlert	`(node_available_flash_bytes - node_bigstore_free_bytes) / node_available_flash_bytes > 0.7`	Node flash storage usage exceeds 70%
NodeEphemeralStorageAlert	`(node_ephemeral_storage_avail_bytes - node_ephemeral_storage_free_bytes) / node_ephemeral_storage_avail_bytes > 0.7`	Node ephemeral storage usage exceeds 70%
NodePersistentStorageAlert	`(node_persistent_storage_avail_bytes - node_persistent_storage_free_bytes) / node_persistent_storage_avail_bytes > 0.7`	Node persistent storage usage exceeds 70%

Troubleshooting

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Upgrade a Redis Enterprise Software database

Mon, 01 Jan 0001 00:00:00 +0000

Default Redis database versions

When you upgrade an existing database, it uses the latest bundled Redis version unless you specify a different version with the redis_version option in the REST API or rladmin upgrade db.

Upgrade modules

Mon, 01 Jan 0001 00:00:00 +0000

Upgrade a module in Redis Enterprise to get the latest features and fixes.

Note:

If you upgrade a single-node cluster, it does not load the new modules that are bundled with the new cluster version.
Before you upgrade a database with the RediSearch module enabled to Redis 5.0, you must upgrade the RediSearch module to version 1.4.2 or later.

Phonetic matching

Mon, 01 Jan 0001 00:00:00 +0000

Phonetic matching, for example "Jon" vs. "John", allows searching for terms based on their pronunciation. This capability can be a useful tool when searching for names of people.

Phonetic matching is based on the use of a phonetic algorithm. A phonetic algorithm transforms the input term to an approximate representation of its pronunciation. This allows terms to be indexed and searched by their pronunciation.

As of v1.4, Redis Query Engine, which is included in Redis Open Source, provides phonetic matching of text fields specified with the PHONETIC attribute. This causes the terms in such fields to be indexed both by their textual value as well as their phonetic approximation.

Redis Enterprise for Kubernetes release notes 6.4.2-8 (Oct 2024)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

This is a maintenance release of Redis Enterprise for Kubernetes version 6.4.2-8 and includes an updated Redis Enterprise image.

Redis Enterprise for Kubernetes release notes 6.4.2-8 (Dec 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

This is a maintenance release of Redis Enterprise for Kubernetes version 6.4.2-8 and includes an updated Redis Enterprise image.

Redis Enterprise for Kubernetes release notes 6.4.2-8 (July 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Redis Enterprise for Kubernetes version 6.4.2-8 is a maintenance release of version 6.2.4-6. It includes critical bug fixes and an updated Redis Enterprise image.

Redis Enterprise for Kubernetes release notes 6.4.2-6 (June 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.4.2-6 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.

Redis Cloud changelog (April 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Nano billing unit

We added a Nano billing unit for Pro databases with a maximum size of 500 MB and a maximum throughput of 500 ops/sec. Use it to create smaller databases for a lower cost.

Chinese support

Mon, 01 Jan 0001 00:00:00 +0000

Support for adding documents in Chinese is available starting at version 0.99.0.

Chinese support allows Chinese documents to be added and tokenized using segmentation rather than simple tokenization using whitespace and/or punctuation.

Indexing a Chinese document is different than indexing a document in most other languages because of how tokens are extracted. While most languages can have their tokens distinguished by separation characters and whitespace, this is not common in Chinese.

Redis Cloud changelog (December 2025)

Mon, 01 Jan 0001 00:00:00 +0000

New features

FOCUS-compliant cost reports with REST API

Select users can now generate and download cost reports in a FinOps Open Cost and Usage Specification (FOCUS) compliant format using the Redis Cloud REST API. You can use this cost report with any FOCUS-compatible cost reporting tool to analyze and visualize your costs.

Migrate to role-based LDAP

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software supports LDAP through a role-based mechanism, first introduced in v6.0.20.

Earlier versions of Redis Enterprise Software supported a cluster-based mechanism; however, that mechanism was removed in v6.2.12.

If you're using the cluster-based mechanism to enable LDAP authentication, you need to migrate to the role-based mechanism before upgrading to Redis Enterprise Software v6.2.12 or later.

Migration checklist

This checklist covers the basic process:

Redis Enterprise for Kubernetes release notes 6.4.2-5 (April 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

This is a maintenance release of Redis Enterprise for Kubernetes 6.4.2-4 that adds supports for Redis Enterprise 6.4.2-61.

Redis Enterprise for Kubernetes release notes 6.4.2-4 (March 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.4.2-4 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.

Redis Enterprise for Kubernetes release notes 6.2.18-41 (Jan 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

This is a maintenance release of Redis Enterprise for Kubernetes 6.2.18-41 that adds supports for Redis Enterprise 6.2.18-72.

Redis Enterprise for Kubernetes release notes 6.2.18-41 (Dec 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.18-41 is a maintenance release which supports the Redis Enterprise Software release 6.2.18 and contains bug fixes.

Redis Enterprise for Kubernetes release notes 6.2.12-1 (Sept 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.12-1 supports the Redis Enterprise Software release 6.2.12 and includes feature improvements and bug fixes.

Redis Enterprise for Kubernetes release notes 6.2.18-3 (Nov 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.18-3 supports the Redis Enterprise Software release 6.2.18 and includes feature improvements and bug fixes.

Redis Enterprise Software release notes 7.4.6-272 (September 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

The API request lifecycle

Mon, 01 Jan 0001 00:00:00 +0000

Redis Cloud owners and viewers can leverage a REST API that permits operations against a variety of resources, including subscriptions, databases, and related infrastructure.

Once it's enabled, you can use the REST API to create, update, and delete subscriptions, databases, and other entities.

All create, update, and delete API operations (POST, PUT, and DELETE) and some query operations (GET) run asynchronously, which means that provisioning or processing occurs in the background. When you submit a request, a background process, known as a Task, starts working on it. The response object includes an ID that lets you determine the status of the background process as it works.

Audit using System Log

Mon, 01 Jan 0001 00:00:00 +0000

System logs collect and report actions performed on various entities in your Redis Cloud subscription. These entities include the account itself, users, API Keys, subscriptions, databases, accounts, payment methods, and more. For each entity, various lifecycle events are logged in the system log.

To view the log, sign in to the Redis Cloud console and then select Logs from the main menu.

To learn more, see System logs.

CommandOverrider

Mon, 01 Jan 0001 00:00:00 +0000

The CommandOverrider allows you to override and customize Redis commands.

Pass the CommandOverrider to the GearsBuilder.CreateGearsBuilder() function in your Java code.
Call the register() function.
Run RG.JEXECUTE to register your code.

Note:

If you register code that uses CommandOverrider, its reader value is "CommandReader" when you run the RG.DUMPREGISTRATIONS command, not "CommandOverrider".

Parameters

Name	Type	Description
command	string	The command to override
prefix	string	Only override the command for keys that start with this string

Output records

Outputs a record with the command's name and arguments.

CommandReader

Mon, 01 Jan 0001 00:00:00 +0000

The CommandReader allows you to run RedisGears functions on command when you:

Pass the CommandReader to the GearsBuilder.CreateGearsBuilder() function in your Java code.
Call the register() function.
Run RG.JEXECUTE to register your code.

Use RG.TRIGGER to run your code on command:

RG.TRIGGER <Trigger name> [arg1 arg2 ...]

Parameters

Name	Type	Description
trigger	string	The command name that triggers the registered RedisGears functions to run

Output records

Outputs a record with the command trigger's name and arguments.

Conditional execution

Mon, 01 Jan 0001 00:00:00 +0000

Most Redis client libraries use transactions with the WATCH command as the main way to prevent two clients writing to the same key at once (see Transactions for more information). Unfortunately, this approach is difficult to use explicitly in NRedisStack. Its multiplexing system is highly efficient and convenient but can also cause bad interactions when different connections use watched transactions at the same time.

Instead, NRedisStack relies more heavily on conditional execution. This comes in two basic forms, When conditions and transaction conditions, both of which are explained in the sections below.

Configure cipher suites

Mon, 01 Jan 0001 00:00:00 +0000

Ciphers are algorithms that help secure connections between clients and servers. You can change the ciphers to improve the security of your Redis Enterprise cluster and databases. The default settings are in line with industry best practices, but you can customize them to match the security policy of your organization.

TLS 1.2 cipher suites

Name	Configurable	Description
control_cipher_suites	✅ Yes	Cipher list for TLS 1.2 communications for cluster administration (control plane)
data_cipher_list	✅ Yes	Cipher list for TLS 1.2 communications between applications and databases (data plane)
sentinel_cipher_suites	✅ Yes	Cipher list for discovery service (Sentinel) TLS 1.2 communications

TLS 1.3 cipher suites

Name	Configurable	Description
control_cipher_suites_tls_1_3	❌ No	Cipher list for TLS 1.3 communications for cluster administration (control plane)
data_cipher_suites_tls_1_3	✅ Yes	Cipher list for TLS 1.3 communications between applications and databases (data plane)
sentinel_cipher_suites_tls_1_3	❌ No	Cipher list for discovery service (Sentinel) TLS 1.3 communications

Configure cipher suites

You can configure ciphers with the Cluster Manager UI, rladmin, or the REST API.

Count-min sketch

Mon, 01 Jan 0001 00:00:00 +0000

Count-Min Sketch is a probabilistic data structure in Redis Open Source that can be used to estimate the frequency of events/elements in a stream of data.

It uses a sub-linear space at the expense of over-counting some events due to collisions. It consumes a stream of events/elements and keeps estimated counters of their frequency.

It is very important to know that the results coming from a Count-Min sketch lower than a certain threshold (determined by the error_rate) should be ignored and often even approximated to zero. So Count-Min sketch is indeed a data-structure for counting frequencies of elements in a stream, but it's only useful for higher counts. Very low counts should be ignored as noise.

Edit Redis Enterprise remote clusters

Mon, 01 Jan 0001 00:00:00 +0000

Note:

Before a RedisEnterpriseCluster (REC) can participate in an Active-Active database, it needs an accompanying RedisEnterpriseRemoteCluster (RERC) custom resource. The RERC contains details allowing the REC to link to the RedisEnterpriseActiveActiveDatabase (REAADB). The RERC resource is listed in the REAADB resource to become a participating cluster for the Active-Active database.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

NRedisStack uses exceptions to signal errors. Code examples in the documentation often omit error handling for brevity, but it is essential in production code. This page explains how NRedisStack's error handling works and how to apply common error handling patterns.

For an overview of error types and handling strategies, see Error handling. See also Production usage for more information on connection management, timeouts, and other aspects of app reliability.

Exception types

NRedisStack throws exceptions to signal errors. Common exception types include:

File locations

Mon, 01 Jan 0001 00:00:00 +0000

Warning:

To ensure that Redis Enterprise Software functions properly, be careful with the files in the application directories. If you modify or delete the application files, Redis Enterprise Software might not work as expected.

Application directories

The directories that Redis Enterprise Software installs into are:

Generate FOCUS-compliant cost report

Mon, 01 Jan 0001 00:00:00 +0000

You can use the Redis Cloud REST API to generate and download a cost report in a FinOps Open Cost and Usage Specification (FOCUS) compatible format. The report includes detailed information about your Redis Cloud subscription usage and associated charges.

To get the cost report using the REST API:

Use POST /cost-report to generate a cost report, with the request body containing the startDate and endDate for the report as well as any optional filters. Your account must have the Owner or Viewer role to generate a cost report through this endpoint.

Install RedisGears

Mon, 01 Jan 0001 00:00:00 +0000

Before you can use RedisGears, you have to install the RedisGears module on your Redis Enterprise cluster.

Minimum requirements

Redis Enterprise 6.0.12 or later
The cluster is setup and all of the nodes are joined to the cluster

Install RedisGears

If your cluster uses Redis Enterprise v6.0.12 or later and has internet access, you only need to download the RedisGears package. It automatically fetches dependencies like the Python and JVM plugins during online installation.

JavaReader

Mon, 01 Jan 0001 00:00:00 +0000

The JavaReader is an abstract class that allows you to create a custom reader in Java.

Create a custom reader

To create a custom reader:

KeysOnlyReader

Mon, 01 Jan 0001 00:00:00 +0000

The KeysOnlyReader only extracts the key names from a database.

Constructors

You can use one of these constructors to create a new KeysOnlyReader object:

KeysReader

Mon, 01 Jan 0001 00:00:00 +0000

Creates records from the keys and values stored in a Redis database.

Note:

Currently only supports string and hash data types. For other data types, it will only extract the key name.

Constructors

You can use one of these constructors to create a new KeysReader object:

Integrate hiredis with a libevent app

Mon, 01 Jan 0001 00:00:00 +0000

The libevent library provides an implementation of an event loop that lets you call functions asynchronously in response to events. This guide explains how to use hiredis to connect to a Redis server from a libevent app.

Install `libevent`

The libevent home page has links to download all versions of the library, but you should use the latest version unless there is a specific version you need to target.

Maintenance mode for cluster nodes

Mon, 01 Jan 0001 00:00:00 +0000

Use maintenance mode to prevent data loss during hardware patching or operating system maintenance on Redis Enterprise servers. When maintenance mode is on, all shards move off of the node under maintenance and migrate to another available node.

Activate maintenance mode

When you activate maintenance mode, Redis Enterprise does the following:

Manage default user

Mon, 01 Jan 0001 00:00:00 +0000

When you create a database, default user database access is enabled by default (Unauthenticated access is selected). This gives the default user full access to the database and enables compatibility with versions of Redis before Redis 6.

Select Password-only authentication, then enter and confirm a default database password to require authentication for connections to the database.

Authenticate as default user

When you configure a password for your database, all connections to the database must authenticate using the AUTH command. See Redis security's authentication section for more information.

Redis Cloud changelog (March 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New Features

Fixed subscriptions through Google Cloud Marketplace

You can now use your Google Cloud Marketplace account to pay for your Fixed subscriptions as well as your Flexible subscriptions.

Monitoring v2

Mon, 01 Jan 0001 00:00:00 +0000

The new metrics stream engine is generally available as of Redis Enterprise Software version 8.0.

The new metrics stream engine:

Exposes the v2 Prometheus scraping endpoint at https://<IP>:8070/v2.
Exports all time-series metrics to external monitoring tools such as Grafana, DataDog, NewRelic, and Dynatrace using Prometheus.
Enables real-time monitoring, including full monitoring during maintenance operations, which provides full visibility into performance during events such as shards' failovers and scaling operations.

Integrate with external monitoring tools

To integrate Redis Enterprise metrics into your monitoring environment, see the integration guides for Prometheus and Grafana.

Redis Cloud changelog (November 2025)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Redis 8.2 on Redis Cloud Pro

Redis 8.2 is now available on Redis Cloud Pro. You can now upgrade your existing Pro database to Redis 8.2.

Offline installation

Mon, 01 Jan 0001 00:00:00 +0000

By default, the installation process requires an internet connection to enable installing dependency packages and for synchronizing the operating system clock against an NTP server.

If you install Redis Enterprise Software on a machine without an internet connection, you need to perform two tasks manually.

Install required dependency packages

When you install Redis Enterprise Software on a machine that is not connected to the internet, the installation process fails and displays an error message informing you it failed to automatically install dependencies. Review the installation steps in the console to see which missing dependencies the process attempted to install. Install all these dependency packages and then run the installation again.

Deployment with OpenShift CLI for Redis Enterprise for Kubernetes

Mon, 01 Jan 0001 00:00:00 +0000

Use these steps to set up a Redis Enterprise Software cluster with OpenShift.

Prerequisites

OpenShift cluster with at least 3 nodes (each meeting the minimum requirements for a development installation)
OpenShift CLI

To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see Supported Kubernetes distributions.

Permissions

Mon, 01 Jan 0001 00:00:00 +0000

Some Redis Enterprise REST API requests may require the user to have specific permissions.

Administrators can assign a predefined role to a user with the Cluster Manager UI or a PUT /v1/users/{uid} API request to grant necessary permissions to them.

Roles

Each user in the cluster has an assigned cluster management role, which defines the permissions granted to the user.

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Redis Data Integration (RDI)

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration (RDI) is a change data capture (CDC) system that tracks changes to the data in a non-Redis source database and makes corresponding changes to a Redis target database. You can use the target as a cache to improve performance because it will typically handle read queries much faster than the source.

See the main RDI docs section under Libraries and tools to learn how to install and use RDI on your own servers. See the Redis Cloud RDI guide to learn how to set up RDI for a cloud database.

SAML single sign-on

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software supports both IdP-initiated and SP-initiated single sign-on (SSO) with SAML (Security Assertion Markup Language) for the Cluster Manager UI. Redis Enterprise Software uses SAML 2.0, which is the latest SAML version and an industry standard.

You cannot use SCIM (System for Cross-domain Identity Management) to provision Redis Enterprise Software users. However, Redis Enterprise Software supports just-in-time (JIT) user provisioning, which means Redis Enterprise Software automatically creates a user account the first time a new user signs in with SSO.

Scan iteration

Mon, 01 Jan 0001 00:00:00 +0000

Redis has a small family of related commands that retrieve keys and, in some cases, their associated values:

SCAN retrieves keys from the main Redis keyspace.
HSCAN retrieves keys and optionally, their values from a hash object.
SSCAN retrieves keys from a set object.
ZSCAN retrieves keys and their score values from a sorted set object.

These commands can potentially return large numbers of results, so Redis provides a paging mechanism to access the results in small, separate batches. With the basic commands, you must maintain a cursor value in your code to keep track of the current page. As a convenient alternative, redis-py also lets you access the results using an iterator. This handles the paging transparently, so you simply need to process the items it returns one-by-one in a for loop or pass the iterator object itself in place of a sequence.

Configure shard placement

Mon, 01 Jan 0001 00:00:00 +0000

In Redis Enterprise Software , the location of master and replica shards on the cluster nodes can impact the database and node performance. Master shards and their corresponding replica shards are always placed on separate nodes for data resiliency. The shard placement policy helps to maintain optimal performance and resiliency.

In addition to the shard placement policy, considerations that determine shard placement are:

Separation of master and replica shards
Available persistence and Auto Tiering storage
Rack-zone awareness
Memory available to host the database when fully populated

The shard placement policies are:

ShardsIDReader

Mon, 01 Jan 0001 00:00:00 +0000

The ShardsIDReader creates a single record on each shard that represents the current shard's ID.

Use this reader when you want to run an operation on each shard in the database.

Parameters

None

StreamReader

Mon, 01 Jan 0001 00:00:00 +0000

Reads Redis stream data.

Parameters

Name	Type	Default value	Description
batchSize	integer	1	The number of new messages that will cause the functions to run
duration	integer	0	How many seconds to wait before execution, regardless of batch size
failurePolicy	FailurePolicy	FailurePolicy.CONTINUE	How to handle execution failure (CONTINUE/ABORT/RETRY)
failureRetryInterval	integer	5000	The number of seconds to wait before retrying
pattern	string	"*" (match all keys)	The pattern of keys that store streams
startId	string	"0-0"	Start reading from this stream ID
trimStream	boolean	true	Whether or not to trim the stream

Output records

Creates a record for each message in the input stream.

Redis Streams

Mon, 01 Jan 0001 00:00:00 +0000

A Redis stream is a data structure that acts like an append-only log but also implements several operations to overcome some of the limits of a typical append-only log. These include random access in O(1) time and complex consumption strategies, such as consumer groups. You can use streams to record and simultaneously syndicate events in real time. Examples of Redis stream use cases include:

Event sourcing (e.g., tracking user actions, clicks, etc.)
Sensor monitoring (e.g., readings from devices in the field)
Notifications (e.g., storing a record of each user's notifications in a separate stream)

Redis generates a unique ID for each stream entry. You can use these IDs to retrieve their associated entries later or to read and process all subsequent entries in the stream. Note that because these IDs are related to time, the ones shown here may vary and will be different from the IDs you see in your own Redis instance.

Redis video tutorial collection

Mon, 01 Jan 0001 00:00:00 +0000

Explore our collection of video tutorials and demonstrations showcasing how Redis powers AI applications. From vector search fundamentals to advanced RAG implementations, these videos provide practical insights and hands-on examples.


Long-Term Memory with LangGraph	Short-Term Memory with LangGraph	What is semantic search?
Learn how to implement long-term memory capabilities in AI agents using LangGraph. This video shows you how to build AI systems that can retain and recall information across extended interactions.	Want your AI agents to remember what users tell them? Short-term memory is the key to natural conversations, and in this tutorial, you'll learn how to implement it with LangGraph.	Traditional search matches words — but what if your AI app could match meaning instead? This video explains how semantic search works and why it's essential for modern AI applications.
What is a semantic cache?	Building a RAG Pipeline from Scratch with RedisVL	What is a vector database?
What if you could skip redundant LLM calls and make your AI app faster, cheaper, and smarter? This video breaks down semantic caching and shows how it can transform your AI applications.	Unlock the Power of Retrieval-Augmented Generation (RAG) with RedisVL. This tutorial will show you how to build a complete RAG pipeline from scratch using Redis as your vector database.	Vector databases have been trending recently as they power modern search, recommendations, and AI-driven applications. Learn what vector databases are and how they work.
Building the future Architecting AI Agents with AWS, LlamaIndex and Redis	Building AI Apps using LangChain	Resources to Learn AI with Redis
The ins and outs of AI agents: understand their role in breaking down tasks into manageable components for better performance. Learn how to architect AI agents using AWS, LlamaIndex, and Redis.	This series of videos dives into the integration between LangChain and Redis to power AI applications that need runtime speed, scalability, and intelligent data management.	This video shows which resources you can use to learn AI with Redis and build powerful AI applications.
What Is RAG? Retrieval-Augmented Generation Explained Simply	Chunking Strategies Explained	What is an embedding model?
Retrieval-Augmented Generation (RAG) is one of the most powerful architectural patterns in GenAI today—combining the strengths of large language models (LLMs) with real-time, external context from your own data. In this session, learn why it matters and how each component—from query rewriting to dense retrieval to semantic chunking—works behind the scenes to power more accurate, grounded, and up-to-date responses.	Are you interested in building LLM applications that actually work? Your chunking strategy makes all the difference. In this video, get a break down of the science of text chunking so your embeddings can start answering the right questions to your users.	Everyone’s talking about embedding models lately—but what do they actually do, and why does it matter? This video breaks it down in simple terms and shows how embeddings power search, recommendations, and AI features behind the scenes.

Additional Resources


LLM Session Management with Redis	A Semantic Cache using LangChain	Similarity Search using Vector Store
Developers building AI applications require a way to store the conversation history between an LLM and a user. This is important to provide context and maintain coherent conversations across sessions.	One common concern of developers building AI applications is how quickly answers from LLMs will be served to their end users, as well as how much it will cost. Learn how to implement semantic caching using LangChain and Redis.	Similarity search is one of the most popular use cases for developers building AI applications. It allows users to perform searches that can find semantically similar content using vector embeddings.
Create a New Database on Redis Cloud	Redis Insight: A Developer's Deep Dive	Redis + Amazon SageMaker for real-time fraud detection demo
Learn how to create a new database on Redis Cloud in this step-by-step tutorial. Perfect for developers getting started with Redis Cloud for their AI and data applications.	This video breaks down Redis Insight and shows developers how to use this powerful tool for database management and development.	See how Redis integrates with Amazon SageMaker to build real-time fraud detection systems. This demo shows practical applications of Redis in machine learning and AI-powered fraud prevention.
Redis + Amazon Bedrock in two minutes
AWS has announced Redis Cloud as one of the few supported vector databases supported for Amazon Bedrock. Learn how to integrate Redis with Amazon Bedrock for your generative AI applications.

Getting Started

Ready to start building AI applications with Redis? Check out our:

Redis Enterprise for Kubernetes release notes 6.2.10-45 (July 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.10-45 supports the Redis Enterprise Software release 6.2.10 and includes feature improvements and bug fixes.

Redis Enterprise Software release notes 6.4.2-131 (September 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.6-268 (June 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.2.10-34 (May 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.10-34 supports the Redis Enterprise Software release 6.2.10 and includes feature improvements and bug fixes.

Redis Enterprise Software release notes 6.4.2-127 (June 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.6-232 (March 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.2.10-4 (March 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.10-4 supports the Redis Enterprise Software release 6.2.10 and includes feature improvements and bug fixes.

Redis Enterprise Software release notes 6.4.2-121 (March 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.2.4-138 (September 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This maintenance release offers:

Redis Enterprise Software release notes 7.4.6-188 (January 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.2.8-15 (January 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.8-15 is a maintenance release for the Redis Enterprise Software release 6.2.8 and includes bug fixes.

Redis Enterprise Software release notes 6.4.2-115 (Oct 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.2.4-132 (June 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This maintenance release offers:

Redis Enterprise Software release notes 7.4.6-102 (October 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.2.8-11 (January 2022)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.8-11 release provides support for the Redis Enterprise Software release 6.2.8 and includes several enhancements and bug fixes.

Redis Enterprise Software release notes 6.4.2-110 (May 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.2.4-130 (May 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.6-77 (September 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.6.

Highlights

This version offers:

Change node roles

Mon, 01 Jan 0001 00:00:00 +0000

A Redis Software cluster contains a primary node, which coordinates cluster-wide management operations, and multiple secondary nodes. Nodes with either role can host database shards.

Demote primary node

Cluster Manager UI rladmin

To demote the primary node to a secondary node using the Cluster Manager UI:

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

redis-py uses exceptions to signal errors. The redis-py documentation mainly shows the "happy path" in code examples and omits error handling for brevity. This page explains how redis-py's error handling works and how to apply common error handling patterns. For an overview of error types and handling strategies, see Error handling. See also Production usage for more information on connection management, timeouts, and other aspects of app reliability.

Exception hierarchy

redis-py organizes exceptions in a hierarchy. The base exception is redis.RedisError, with specific subclasses for different error types, as shown below:

Redis Cloud changelog (February 2024)

Mon, 01 Jan 0001 00:00:00 +0000

Enhancements

Dataset size alert set by default

The Dataset size has reached alert is now set by default when you create your first database in a Flexible subscription.

Client-side geographic failover

Mon, 01 Jan 0001 00:00:00 +0000

redis-py supports Client-side geographic failover to improve the availability of connections to Redis databases. This page explains how to configure redis-py for failover. For an overview of the concepts, see the main Client-side geographic failover page.

Failover configuration

The example below shows a simple case with a list of two servers, redis-east and redis-west, where redis-east is the preferred target. If redis-east fails, redis-py should fail over to redis-west.

Redis Cloud changelog (October 2025)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Data Integration

Redis Cloud now supports Redis Data Integration (RDI) to create data pipelines that ingest data from a supported primary database to Redis.

Redis Enterprise for Kubernetes Release Notes 6.2.8-2 (November 2021)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.8-2 release provides support for the Redis Enterprise Software release 6.2.8 and includes several enhancements and bug fixes.

Redis Enterprise Software release notes 6.4.2-103 (October 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

Highlights

This version offers:

Redis Enterprise Software release notes 7.2.4-122 (March 2025)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.6-22 (July 2024)

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software version 7.4.6 is now available! This release includes API enhancements that warranted a new minor version instead of a maintenance release for version 7.4.2. However, you can upgrade from 7.4.2 to 7.4.6 without issue.

Highlights

This version offers:

Create a Redis Cloud database with the Vercel integration

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Cloud Vercel integration lets you create a new Redis database from your Vercel account and connect it to your Vercel project(s).

Create database

Redis Enterprise for Kubernetes Release Notes 6.2.4-1 (September 2021)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.2.4-1 release provides support for the Redis Enterprise Software release 6.2.4 and includes several enhancements and bug fixes.

Redis Enterprise Software release notes 6.4.2-94 (July 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-94 July release)
Ubuntu 16	e664a93108aeb72cf9dc849b84b79239
Ubuntu 18	9b547be7e093a0668caa9d5af36ddd21
Ubuntu 20	d623c8458a28f09a1e6ae0c0a8650023
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	f9df1080427660bab601f1690ee7ffca
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	f44dfaf4da5d54d35d739ba1e243eca0
Amazon Linux 2	f2c5c2b5e879b8fd6792336f757593e2

New features and enhancements

RS98361 - Enhanced the algorithm responsible for placing shards in the cluster. This improvement applies when creating new databases and when calling the REST API GET optimize_shards_placement for existing databases.

Redis Enterprise Software release notes 7.2.4-109 (May 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-216 (July 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.2.

Highlights

This version offers:

Deploy Redis Cloud as a Heroku add-on

Mon, 01 Jan 0001 00:00:00 +0000

Deploy Redis Cloud as a Heroku add-on to enhance your applications with high-performance data storage and caching capabilities.

Overview

The Redis Cloud Heroku add-on provides a fully managed Redis service as a Heroku add-on, making it easy to quickly add high-performance data storage to your Heroku applications. Redis Cloud on Heroku is perfect for web applications requiring fast caching, session storage, and real-time features.

Redis Enterprise for Kubernetes Release Notes 6.0.20-12 (July 2021)

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The Redis Enterprise K8s 6.0.20-12 release is a major release on top of 6.0.20-4 providing support for the Redis Enterprise Software release 6.0.20-97 and includes several enhancements and bug fixes.

Redis Enterprise Software release notes 6.4.2-81 (June 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-81 June release)
Ubuntu 16	31631248672de0154ec20aee0bff9adc
Ubuntu 18	eb4e8c1bc1443923ebcd457e51684f7e
Ubuntu 20	1256292b8dca6456e69dc309be51a8d0
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	1e51c5fdf22c0b6988565444ba08c6cd
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	96dc036339fe18fb218e8d4c8ff50c99
Amazon Linux 2	1a549bdb360c9e22ef764faeadbd4c90

New features and enhancements

RS77279 - Database backup failures and replica high availability (replica HA) failures (for example, when relocating a shard from a node) now generate email alerts

Redis Stack v6.2.6

Redis Enterprise Software v6.4.2 includes the new features delivered in the latest Redis Stack release (6.2.6 v6):

Redis Enterprise Software release notes 7.2.4-105 (February 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-169 (May 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.2.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.0.20-4 (May 2021)

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Enterprise K8s 6.0.20-4 release is a major release on top of 6.0.8-20 providing support for the Redis Enterprise Software release 6.0.20-69 and includes several enhancements and bug fixes.

Overview

This release of the operator provides:

Redis Enterprise Software release notes 6.2.18-70 (January 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.2.18.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.2.18-70 January release)
Ubuntu 16	`69d2d2c71232adb15cebf29308ac54da`
Ubuntu 18	`22e0637107a32ccb96a704abe9650adf`
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	`e14fcf6973418602f2b64a55a0bc8374`
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	`f61d0d8f0bb5ad90a470482d6575eb27`

New features and enhancements

Added a new script to generate new self-signed certificates for renewal. For details, see Certificates
Added rpm -q command output to the logs (RS82673)
Added logs for server operations: start, stop, restart (RS87775)
Added alert_mgr to the services you can deactivate with rladmin (RS89572)

Resolved issues

RS61062 - Remove leading colon added to PATH variable

Known upgrade limitations

Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:

Redis Enterprise Software release notes 6.4.2-69 (May 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-69 May release)
Ubuntu 16	31631248672de0154ec20aee0bff9adc
Ubuntu 18	7d9ebd4ea5a23137d2bb3928134ea6ef
Ubuntu 20	357ceda7467fd66962f3cb5aa143def7
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	4d53fcce8c80910a05ed37ab64b57a7a
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	88dc6a4d96b948b086f785dc42786d03
Amazon Linux 2	7ed06bc0b35494e4a5c084528d6e8b9f

New features and enhancements

Amazon Linux 2 support

Redis Enterprise Software release notes 7.2.4-92 (November 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4, originally released as version 7.2.4-86. Version 7.2.4-92 fixes several additional issues that affect version 7.2.4-86.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-129 (April 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.2. This version fixes several issues that affect version 7.4.2-126.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.0.12-5 (February 2021)

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Enterprise K8s 6.0.12-5 release is a major release on top of 6.0.8-20 providing support for the Redis Enterprise Software release 6.0.12-57 and includes several enhancements and bug fixes.

Overview

This release of the operator provides:

Redis Enterprise Software release notes 6.2.18-65 (December 2022)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.2.18.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.2.18-65 December release)
Ubuntu 16	`515c7bbc97eaf1939757c8894eda9523`
Ubuntu 18	`830e8704c0f6902a04df9ff53cc5e41f`
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	`b51d13e30f4a7e1a134982342b8865b0`
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8	`762f907c1f0e6e0e88e4ae5bf967e143`

New features and enhancements

When setting up an alert email server in the UI: added a To field to the test email server function (RS86119)
Added a new flag to skip cluster resource validation when performing import (RS88086)
Enhanced error message information for connection handling
Added logging details to insufficient_resources planner error

Redis modules

Redis Enterprise Software v6.2.18-65 (December release) includes newer versions of the following Redis modules:

Redis Enterprise Software release notes 6.4.2-61 (April 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-61 April release)
Ubuntu 16	f8f616147c9daaaeb9cd8cb1ae44157f
Ubuntu 18	1de5b0bafd4edec8d7817bddcecf3824
Ubuntu 20	829e91c7fac1a0ab7e36cb4a65d19906
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	477f1d3161ea16e8d52c41eb61d92637
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	1170af43f88bf5f9095890916c0fe74d
Amazon Linux 2 (Release Candidate)	e246ae158db32e0a483a23392b2a7f47

New features and enhancements

Amazon Linux 2 supported as a release candidate (RC)

Redis Enterprise Software release notes 7.2.4-72 (October 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-126 (April 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.2.

Highlights

This version offers:

Upgrade an Active-Active database

Mon, 01 Jan 0001 00:00:00 +0000

Upgrade an Active-Active database

To upgrade an Active-Active (CRDB) database:

Redis Cloud changelog (August 2025)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Active-Active on Redis Cloud BYOC

You can now deploy Active-Active databases to Redis Cloud Bring your own Cloud.

Write-behind, write-through, and read-through caching

Mon, 01 Jan 0001 00:00:00 +0000

The rghibernate recipe uses RedisGears functions and the Hibernate framework to implement write-behind, write-through, and read-through caching.

These caching strategies allow applications to simply connect to a Redis cache layer instead of an underlying database. Whenever the application updates data in the cache, Redis also syncs the data in the backend database.

The underlying database could be an SQL database like MySQL, so you will need to provide an XML file that tells rghibernate how to map data between Redis and the other database.

Enable causal consistency

Mon, 01 Jan 0001 00:00:00 +0000

When you enable causal consistency in Active-Active databases, the order of operations on a specific key are maintained across all Active-Active database instances.

For example, if operations A and B were applied on the same key and the effect of A was observed by the instance that initiated B before B was applied to the key. All instances of an Active-Active database would then observe the effect of A before observing the effect of B. This way, any causal relationship between operations on the same key is also observed and maintained by every replica.

Certificate-based authentication

Mon, 01 Jan 0001 00:00:00 +0000

You can set up certificate-based authentication for specific users to enable secure, passwordless access to the Redis Enterprise Software REST API and databases.

Set up certificate-based authentication

To set up certificate-based authentication:

Delete custom resources

Mon, 01 Jan 0001 00:00:00 +0000

Multi-namespace management

Before you can delete a namespace, you must remove the Redis custom resources (REDB, REC, and operator) residing within a namespace before you can delete that namespace. Deleting namespace containing an REDB may cause errors or data loss.

Install RedisGears for Redis Data Integration

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Redis Cloud changelog (January 2024)

Mon, 01 Jan 0001 00:00:00 +0000

New features

Transit Gateway

You can now connect your Flexible subscriptions hosted on Amazon Web Services (AWS) to AWS Transit Gateway. See Connect to Transit Gateway to learn how to connect your Flexible subscription to Transit Gateway.

Monitoring guide

Mon, 01 Jan 0001 00:00:00 +0000

Redis Data Integration keeps Redis in sync with the primary database in near real time.

Deploy Redis Enterprise with OpenShift OperatorHub

Mon, 01 Jan 0001 00:00:00 +0000

You can deploy Redis Enterprise for Kubernetes from the Red Hat OpenShift CLI. You can also use a UI, OperatorHub (Red Hat) to install operators and create custom resources.

Note:

To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see Supported Kubernetes distributions.

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Production usage

Mon, 01 Jan 0001 00:00:00 +0000

This guide offers recommendations to get the best reliability and performance in your production environment.

Checklist

Each item in the checklist below links to the section for a recommendation. Use the checklist icons to record your progress in implementing the recommendations.

Rack-zone awareness in Redis Enterprise Software

Mon, 01 Jan 0001 00:00:00 +0000

Rack-zone awareness helps ensure high availability in the event of a rack or zone failure.

When you enable rack-zone awareness in a Redis Enterprise Software cluster, you assign a rack-zone ID to each node. This ID is used to map the node to a physical rack or logical zone. The cluster can then ensure that primary shards, corresponding replica shards, and associated endpoints are placed on nodes in different racks or zones.

Recover a failed cluster

Mon, 01 Jan 0001 00:00:00 +0000

When a Redis Enterprise Software cluster fails, you must use the cluster configuration file and database data to recover the cluster.

Note:

For cluster recovery in a Kubernetes deployment, see Recover a Redis Enterprise cluster on Kubernetes.

Cluster failure can be caused by:

A hardware or software failure that causes the cluster to be unresponsive to client requests or administrative actions.
More than half of the cluster nodes lose connection with the cluster, resulting in quorum loss.

To recover a cluster and re-create it as it was before the failure, you must restore the cluster configuration ccs-redis.rdb to the cluster nodes. To recover databases in the new cluster, you must restore the databases from persistence files such as backup files, append-only files (AOF), or RDB snapshots. These files are stored in the persistent storage location.

Rotate passwords

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software lets you implement password rotation policies using the REST API.

You can add a new password for a database user without immediately invalidating the old one to prevent possible authentication errors in production.

Note:

Password rotation does not work for the default user. Add additional users to enable password rotation.

Password rotation policies

For user access to the Redis Enterprise Software Cluster Manager UI, you can set a password expiration policy to prompt the user to change their password.

Uninstall Redis Enterprise Software

Mon, 01 Jan 0001 00:00:00 +0000

Use the script rl_uninstall.sh to uninstall Redis Enterprise Software and remove its files from a node. The script also deletes all Redis data and configuration from the node.

The uninstall script does not remove the node from the cluster, but the node's status changes to down. For node removal instructions, see Remove a cluster node.

Uninstall Redis Enterprise Software

To uninstall Redis Enterprise Software from a cluster node:

Upgrade a cluster's operating system

Mon, 01 Jan 0001 00:00:00 +0000

To upgrade the operating system (OS) on a Redis Enterprise Software cluster to a later major version, perform a rolling upgrade. Because you upgrade one node at a time, you can upgrade your cluster's OS without downtime.

Prerequisites

Before you upgrade a cluster's operating system:

Usage reports

Mon, 01 Jan 0001 00:00:00 +0000

The Usage Report shows the daily memory usage and shard usage of all databases from the subscriptions associated with your account.

To filter the data, you can:

Select a month and year from the View Statement For list to view the daily memory usage during a specific month.
Select a subscription from the Subscription list to view the daily memory usage of a specific subscription associated with your account.
Select a database from the Database list to view the daily memory usage of a specific database.

You can also hold the pointer over each bar in the graph to view the precise memory usage on that day.

Write-behind caching

Mon, 01 Jan 0001 00:00:00 +0000

Write-behind is a caching strategy in which the cache layer itself connects to the backing database. This means that your applications need only ever connect to your cache layer, and the cache then reads from or updates the backing database as needed. Redis currently supports write-behind caching in Redis Enterprise Software.

Here's how these caching patterns work:

Your application uses the cache for reads and writes.
The cache syncs any changed data to the backing database asynchronously.

Install the write-behind recipe

The write-behind recipe comes with two types of dependencies:

Redis Enterprise Software release notes 6.2.18-58 (November 2022)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.2.18.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.2.18-58 November release)
Ubuntu 16	`38d974c47004df0808b71c2bd5a96996`
Ubuntu 18	`6a5ca7a287f1808a50d13312162aac4b`
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	`d8283a3475a70823641249e3cfe3ab6e`
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8	`040e45c866fde391b35ae85d648a4afa`

New features and enhancements

Added support to the UI to work with custom REST API port (RS84428)
Added info level print to redis_mgr for troubleshooting (RS85385)

Redis modules

Redis Enterprise Software v6.2.18-58 (November release) includes newer versions of the following Redis modules:

Redis Enterprise Software release notes 6.4.2-43 (March 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.4.2.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-43 March release)
Ubuntu 16	bb3d3ab7590834790d2d9d9e3dcdf788
Ubuntu 18	55e99e6db76277c15fa46c49d58995b5
Ubuntu 20	cccfa62ca7ea955b8c19d9c40bdc1fea
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	eed4083b0b4c066d31ea9b8ba60a34f5
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	7fd4321f6a5502c76197fc039f44ffa3

New features and enhancements

Support for Ubuntu 20

Added operating system support for Ubuntu 20.04.

Redis Enterprise Software release notes 7.2.4-64 (September 2023)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.2.4.

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-104 (March 2024)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 7.4.2.

Highlights

This version offers:

Redis Enterprise for Kubernetes Release Notes 6.0.8-20 (December 2020)

Mon, 01 Jan 0001 00:00:00 +0000

The Redis Enterprise K8s 6.0.8-20 release is a major release on top of 6.0.8-1 providing support for the Redis Enterprise Software release 6.0.8-30 and includes several enhancements and bug fixes.

Overview

This release of the operator provides:

Redis Enterprise Software release notes 6.2.18-49 (October 2022)

Mon, 01 Jan 0001 00:00:00 +0000

This is a maintenance release for Redis Enterprise Software version 6.2.18.

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.2.18-49 October release)
Ubuntu 16	`89029a28a2b0e3ad379559b94d00ae32`
Ubuntu 18	`830e8704c0f6902a04df9ff53cc5e41f`
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	`766d2f8448fc28d0ea67cac20387a9e3`
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8	`7e31fb3e3416b404513dad508669f836`

New features and enhancements

The /nodes/status REST API endpoint indicates whether a node is the primary. (RS82566)
Added metrics to track certificates expiration time (RS56040)

Redis modules

Redis Enterprise Software v6.2.18-49 (October release) includes the following Redis modules:

Redis Enterprise Software release notes 6.4.2-30 (February 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software version 6.4.2 is now available!

This version offers:

Extended validation of client certificates via mTLS (mutual TLS) full subject support
Support for default restrictive permissions when using publish/subscribe commands and ACLs (access control lists)
Enhanced TLS performance when Redis returns large arrays in responses
Compatibility with open source Redis 6.2.7
Additional enhancements and bug fixes

The following table shows the MD5 checksums for the available packages:

Package	MD5 checksum (6.4.2-30 February release)
Ubuntu 16	b0dbecaa974ca08245dda55d53b6fe9b
Ubuntu 18	a5192e8b0734db80d6b7c2b98a170c58
RedHat Enterprise Linux (RHEL) 7 Oracle Enterprise Linux (OL) 7	c1537855dcfe7a7cedf9031ce01e2b9b
RedHat Enterprise Linux (RHEL) 8 Oracle Enterprise Linux (OL) 8 Rocky Enterprise Linux	a24dc749d6dcb5df2162d7a41791c7aa

New features and enhancements

Validate client certificates by subject attributes

You can now validate client certificates by their Subject attributes. When a client attempts to connect to a database, Redis Enterprise Software compares the values of the client certificate subject attributes to the subject values allowed by the database. Clients can connect to the database only if the subject values match. This gives more flexibility in controlling which clients can access which databases.

Redis Enterprise Software release notes 7.2.4-52 (August 2023)

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software version 7.2.4 is now available!

Highlights

This version offers:

Redis Enterprise Software release notes 7.4.2-54 (February 2024)

Mon, 01 Jan 0001 00:00:00 +0000

Redis Enterprise Software version 7.4.2 is now available!

Highlights

This version offers: